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 1/7] 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 00000000..9329244d --- /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 ad679558..a2db6446 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 6cc42ab2..7fe790f2 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 00000000..6f175ad0 --- /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 00000000..b2ae0fec --- /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 00000000..104b393f --- /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 00000000..7314ee0b --- /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 00000000..d73403b7 --- /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 00000000..7b69afcd --- /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 00000000..f8e4a921 --- /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 00000000..39cee2eb --- /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 00000000..646c8bb7 --- /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 00000000..eaba46ff --- /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 00000000..8adbc53a --- /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 00000000..afb74221 --- /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 00000000..b8b198ce --- /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 00000000..db550704 --- /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 00000000..0a0157ae --- /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 00000000..a399dacc --- /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 00000000..dfb9748b --- /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 00000000..b35ec7cc --- /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 00000000..228e3ac2 --- /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 00000000..0165eaed --- /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 00000000..89eddaa7 --- /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 2/7] 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 cec424cd..6dac8945 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 00000000..3b666955 --- /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 00000000..0f4e0f2b --- /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 00000000..70e5b1c6 --- /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 3/7] 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 3b666955..38a6b59b 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 0f4e0f2b..e009476f 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 70e5b1c6..5cd19917 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 4/7] 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 f1df4281..ae1e0efb 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 00000000..85963e9f --- /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 00000000..1e082935 --- /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 00000000..c7c3b865 --- /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 00000000..7fdfbcb4 --- /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: Wed, 30 Sep 2026 00:17:46 +0800 Subject: [PATCH 5/7] 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 07a95a78..b42bbc83 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 3bd7b646..2cca0d94 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 506d0c0b..741a29e4 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 1fc834bd..00000000 --- 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 7b69afcd..00000000 --- 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 f8e4a921..00000000 --- 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 39cee2eb..00000000 --- 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 646c8bb7..00000000 --- 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 eaba46ff..00000000 --- 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 6/7] 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 9329244d..9d4fd7b0 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 2cca0d94..17d41dbb 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 741a29e4..753eef78 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 104b393f..f1474bb9 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 c414bc98..bde882c9 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 b8b198ce..00000000 --- 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 db550704..e3655def 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 edd207da..4346257f 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 dfb9748b..00000000 --- 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 00000000..5fb9939d --- /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 228e3ac2..d37728f3 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 62385986..50bd2cb3 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 7/7] 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 9d4fd7b0..00000000 --- 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 b42bbc83..38579376 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 17d41dbb..76944aa3 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 753eef78..00000000 --- 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 37fe0a06..00000000 --- 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 f1474bb9..00000000 --- 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 ca3e5351..00000000 --- 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 8adbc53a..00000000 --- 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 afb74221..00000000 --- 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 2646837b..6a072600 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 5fb9939d..00000000 --- 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 cca8a458..00000000 --- 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 d37728f3..00000000 --- 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 00ecd769..00000000 --- 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 50bd2cb3..00000000 --- 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