Create README.md

README.md

@@ -0,0 +1,111 @@
+# Understanding Trace Files in BackendBench
+
+## Format
+Trace files capture PyTorch operations and their 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`**: This 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})`
+
+## Complete 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 64×256 tensor
+
+## Interpretation
+Trace files provide real-world operation usage patterns, showing which tensor shapes and operations are most common in actual PyTorch models. These are fairly useful for debugging.
+Note: These may be deprecated in the future, but are described as they are currently included in the dataset / codebase.
+
+
+# Understanding Serialized Arguments in BackendBench
+## Format
+BackendBench stores function arguments as strings containing all parameters needed to reproduce PyTorch operations:
+
+```
+((arg1, arg2, ...), {'key1': val1, 'key2': val2})
+```
+
+## 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)
+
+## Complete Examples
+
+**Single tensor argument:**
+```python
+((T([48, 24, 28, 28], f16),), {})
+```
+= Function called with one 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)), {})
+```
+= Function with two identical 5D tensors
+
+**Mixed arguments:**
+```python
+((T([128, 256], f16), [1024, 249, 249]), {'dtype': torch.float16, 'device': 'cuda'})
+```
+= Function with tensor, list, and keyword arguments
+
+**Complex nested:**
+```python
+(([T([5, 5], f32), T([3, 3], i64), 42],), {'weight': T([3, 3], f32)})
+```
+= Function with list containing tensors and numbers, plus tensor keyword argument
+
+## Argument Types
+- **Tensors**: `T([shape], dtype)` format
+- **Lists**: `[item1, item2, ...]` (can contain tensors)
+- **Primitives**: `42`, `'hello'`, `True`, `None`
+- **PyTorch objects**: `torch.float16`, `torch.strided`
+
+## Acknowledgements
+We are extremely grateful for the folks working on [TritonBench](https://github.com/pytorch-labs/tritonbench/tree/main) for these traces and intuitive format