| | --- |
| | configs: |
| | - config_name: torchbench |
| | data_files: |
| | - split: benchmark |
| | path: "backend_bench_problems.parquet" |
| | - config_name: ops_traces_models |
| | data_files: |
| | - split: operator_input_models |
| | path: "operator_input_models_mapping.parquet" |
| | --- |
| | |
| | # TorchBench |
| |
|
| | The TorchBench suite of [BackendBench](https://github.com/meta-pytorch/BackendBench) is designed to mimic real-world use cases. It provides operators and inputs derived from 155 model traces found in [TIMM](https://huggingface.co/timm) (67), [Hugging Face Transformers](https://huggingface.co/docs/transformers/en/index) (45), and [TorchBench](https://github.com/pytorch/benchmark) (43). (These are also the models PyTorch developers use to [validate performance](https://hud.pytorch.org/benchmark/compilers).) You can view the origin of these traces by switching the subset in the dataset viewer to `ops_traces_models` and `torchbench` for the full dataset. |
| |
|
| | When running BackendBench, much of the extra information about what you are testing is abstracted away, so you can simply run `uv run python --suite torchbench ...`. Here, however, we provide the test suite as a dataset that can be explored directly. It includes details about why certain operations and arguments were included or excluded, reflecting the careful consideration behind curating the set. |
| |
|
| | You can download the dataset in either format: |
| |
|
| | - `backend_bench_problems.parquet` (default format on Hugging Face) |
| | |
| | - `backend_bench_problems.json` (more human-readable) |
| | |
| | |
| | ### Fields |
| |
|
| | - **uuid** – Unique identifier for the `(op_name, args)` pair. |
| | |
| | - **op_name** – Full name of the operator being tested. |
| | |
| | - **args** – Serialized form of the inputs from the trace. [See details below](#serialized-arguments-in-backendbench). |
| | |
| | - **runnable** – Whether the operator is runnable in BackendBench (some are not yet supported). |
| | |
| | - **included_in_benchmark** – Whether this `(op_name, args)` pair is tested in the TorchBench suite. |
| | |
| | - **why_excluded** – If not included, a list of reasons for exclusion (e.g., "BackendBench does not support correctness testing for random ops yet," "BackendBench does not support correctness testing for tensor creation and manipulation ops yet"). |
| | |
| | - **is_synthetic** – Marks synthetically generated inputs (e.g., very large tensors). These are currently excluded from the benchmark. |
| | |
| | - **runtime_ms** – Execution time (ms) on our hardware (single GPU from a machine with 8× H100s and an AMD EPYC 9654 96-core processor). |
| | |
| | - **relative_runtime_to_kernel_launch** – `runtime_ms` divided by the runtime of a dummy CUDA op (`torch.empty(0, device=cuda)`), representing launch overhead. |
| | |
| | - **is_overhead_dominated_op** – Flags operator/argument pairs running close to CUDA overhead as “performance canaries.” [Histogram analysis](https://github.com/meta-pytorch/BackendBench/issues/108) showed that a 1.3× threshold above CUDA overhead is a useful cutoff. These tests can be run for sanity-checking kernels with `uv run python --suite torchbench --check-overhead-dominated-ops ...`. |
| | |
| | - **count** – Number of times this operator/input pair appeared in model traces. |
| | |
| | - **in_models** – List of models (from real-world traces) where this operator/input pair appears. |
| | |
| | - **in_models_count** – Number of distinct models in which this operator/input pair occurs. |
| | |
| | |
| | # Serialized Arguments in BackendBench |
| |
|
| | Generally, arguments are serialized by storing tensor shapes and preserving everything else as it's fairly intuitive. For example: |
| |
|
| | `((T([8, 8, 8, 8, 8], f16), T([8, 8, 8, 8, 8], f16)), {})` |
| |
|
| | Below we'll go into detail about the format for rigor. |
| | ## Format |
| |
|
| | BackendBench stores function arguments as strings with all parameters needed to reproduce PyTorch operations: |
| |
|
| | ```python |
| | ((arg1, arg2, ...), {'key1': val1, 'key2': val2}) |
| | ``` |
| |
|
| | ```python |
| | (([T([5, 5], f32), T([3, 3], i64), 42],), {'weight': T([3, 3], f32)}) |
| | ``` |
| |
|
| | ## Tensor Representation |
| |
|
| | Tensors use the format `T([shape], dtype)` or `T([shape], dtype, [stride])`: |
| |
|
| | ```python |
| | T([10, 20], f32) # 10×20 float32 tensor |
| | T([1, 512, 768], f16) # 1×512×768 float16 tensor |
| | T([64], i32) # 64-element int32 vector |
| | ``` |
| |
|
| | **Data types**: `f16/f32/f64` (float), `bf16` (bfloat16), `i32/i64` (int), `b8` (bool) |
| |
|
| | ## Examples |
| |
|
| | **Single tensor argument:** |
| |
|
| | ```python |
| | ((T([48, 24, 28, 28], f16),), {}) |
| | ``` |
| |
|
| | 48×24×28×28 float16 tensor, no keyword arguments |
| |
|
| | **Multiple tensors:** |
| |
|
| | ```python |
| | ((T([8, 8, 8, 8, 8], f16), T([8, 8, 8, 8, 8], f16)), {}) |
| | ``` |
| |
|
| | Two 5D tensors of identical shapes |
| |
|
| | **Mixed arguments:** |
| |
|
| | ```python |
| | ((T([128, 256], f16), [1024, 249, 249]), {'dtype': torch.float16, 'device': 'cuda'}) |
| | ``` |
| |
|
| | Args are a tensor, list, and keyword arguments |
| |
|
| | **Complex nested:** |
| |
|
| | ```python |
| | (([T([5, 5], f32), T([3, 3], i64), 42],), {'weight': T([3, 3], f32)}) |
| | ``` |
| |
|
| | List containing tensors and numbers, plus tensor keyword argument |
| |
|
| | ## Argument Types |
| |
|
| | - **Tensors**: `T([shape], dtype)` |
| | |
| | - **Lists**: `[item1, item2, ...]` (can contain tensors) |
| | |
| | - **Primitives**: `42`, `'hello'`, `True`, `None` |
| | |
| | - **PyTorch objects**: `torch.float16`, `torch.strided` |
| | |
| | |
| | # Trace Files in BackendBench |
| |
|
| | This repository includes `.txt` trace files, which were the original output format of model traces and are used to compose the dataset. Here’s their structure: |
| |
|
| | ## Format |
| |
|
| | Trace files capture PyTorch operations and arguments from real model executions: |
| |
|
| | ``` |
| | Operator: operation_name |
| | cnt: count, serialized_arguments |
| | cnt: count, serialized_arguments |
| | ... |
| | ``` |
| |
|
| | ## Structure |
| |
|
| | **Operator line**: Specifies the PyTorch operation |
| |
|
| | ``` |
| | Operator: aten.add.Tensor |
| | Operator: aten.relu.default |
| | Operator: aten.linear.default |
| | ``` |
| |
|
| | **Count lines**: Show how often each argument combination was used |
| |
|
| | ``` |
| | cnt: 42, ((T([10, 20], f16), T([10, 20], f16)), {}) |
| | cnt: 0, ((T([5, 5], f32), T([5, 5], f32)), {}) |
| | ``` |
| |
|
| | ## Reading Count Lines |
| |
|
| | - **Count `42`**: Argument combination appeared 42 times in traced models |
| | |
| | - **`cnt: 0`** = Synthetic/generated arguments (not from real models) |
| | |
| | - **`cnt: >0`** = Real usage frequency from model traces |
| | |
| | |
| | **Arguments**: Same format as serialized arguments – `((args), {kwargs})` |
| |
|
| | ## Example |
| |
|
| | ``` |
| | Operator: aten.add.Tensor |
| | cnt: 156, ((T([1, 512, 768], f16), T([1, 512, 768], f16)), {}) |
| | cnt: 89, ((T([32, 128], f32), T([32, 128], f32)), {}) |
| | cnt: 0, ((T([10, 10], f16), T([10, 10], f16)), {}) |
| | |
| | Operator: aten.relu.default |
| | cnt: 234, ((T([64, 256], f16),), {}) |
| | ``` |
| |
|
| | This shows: |
| |
|
| | - `aten.add.Tensor` called 156 times with 1×512×768 tensors |
| | |
| | - Same operation called 89 times with 32×128 tensors |
| | |
| | - One synthetic test case (`cnt: 0`) |
| | |
| | - `aten.relu.default` called 234 times with a 64×256 tensor |
| | |
| | |
| | **Note: Traces may be deprecated in the future, but are described here as they are currently included in the dataset/codebase.** |
| |
|
| | # Acknowledgements |
| |
|
| | We are extremely grateful to the [TritonBench](https://github.com/pytorch-labs/tritonbench/tree/main) team for these traces and their intuitive format. |
