idacy/trace-artifact

TRACE artifact

Code, specifications, and computed outputs for TRACE (Telemetry Rules for Accelerator-Cluster Evidence), a study of what datacenter telemetry lets an auditor detect, rule out, and attribute large AI training runs on monitored accelerator clusters.

This repository holds the machine-readable half of the project. Written material, drafts, review records, and correspondence are kept separately and are not published. Raw telemetry from the two real cases is access-controlled and is not published either; see provider_case/ and instrumented_case/ below for what is released instead.

Layout

framework/            the specification and the evaluator
  observables/        observables.yaml (O01-O15 and their value-level features),
                      sources.yaml, rules/ (8 rule and index files)
  src/                observable_algorithm.py (v0.3, canonical) and
                      observable_algorithm_v0_1.py (the earlier generation, kept for provenance)
  scripts/            generate, run and validate entry points
  synthetic/          sites.json, the hand-written anchor fixtures
  tests/              unittest suite, 60 tests

corpus/
  generator/          the seeded 24-family generator
  logged_run_full/    the accepted run: config, summary, seed, raw_routes.jsonl AND
                      sites_all.jsonl for all 20,284 instances

superseded_sweeps/    six earlier sweeps, two on the v0.1 evaluator and four on v0.3,
                      kept so that changes in reported numbers can be traced

instrumented_case/
  collector/          collect.py and trace.sh, the passive read-only sampler
  runner/             orchestrator.py, workloads.py, setup and preflight scripts,
                      schedules/ including the 19-window schedule that was run and the
                      later paired-identifiability schedule
  analysis/           window_telemetry.py, purpose_channels.py
  derived/            the outputs of those two scripts on the reported run
  ground_truth/       per-node manifests, window bounds, labels and per-window
                      ground-truth records, node identifiers replaced by rank-ordered labels

provider_case/        frozen_paper_values.json, rate_registry.json, account_feed_schema.json

evaluators/           newmodel.py and checkmodel.py, the graded weight-of-evidence model,
                      and judge_recompute.py

figures/              generators, input specs, provenance manifest, and the built
                      PDF, PNG and SVG outputs

Requirements

Python 3.9 or newer. The framework, the collector, the workload runner and both analysis scripts use only the standard library. corpus/generator needs numpy and PyYAML. framework/scripts/validate_synthetic_observables.py needs PyYAML. figures/ needs matplotlib, numpy, pillow and pypdf. Versions are pinned in requirements.txt. The workload runner also needs a CUDA-capable PyTorch on the target cluster, which instrumented_case/runner/setup.sh installs.

Running it

Tests, from a checkout with framework/ at the root:

PYTHONPATH=framework/src PYTHONDONTWRITEBYTECODE=1 python3 -m unittest discover -s framework/tests

Corpus self-check and design total, without writing anything:

cd corpus && PYTHONDONTWRITEBYTECODE=1 PYTHONPATH=. python3 -m generator.run \
    --base-seed 20260609 --out reproduced_sweep --dry-run

The generator resolves the evaluator, the anchor fixtures and the registry relative to the repository root. Paths in these modules are written for the working repository layout, where observables/, src/, scripts/ and synthetic/ sit at the root rather than under framework/; adjust REPO_ROOT in corpus/generator/*.py if you run them from this layout directly.

Analysis, against a run directory holding one directory per node in the collector's output layout:

python3 instrumented_case/analysis/window_telemetry.py --run-dir <run> --out-dir <out>
python3 instrumented_case/analysis/purpose_channels.py --run-dir <run> --out-dir <out>

What the corpus is and is not

The corpus is a boundary and regression harness over the evaluator's decision surface. It is not a labelled workload dataset. The instance counts are fixed grid sizes chosen by the corpus design, so they carry no base rate and support no performance denominator. The expected labels restate the same constants the evaluator tests against, so a match rate measures internal consistency and not detection. The per-family warning and evasion-success rates are properties of the code's decision surface under constructed inputs. The summaries state this in their own h1_qualifier field.

What is not here

The raw NDJSON from the instrumented cluster run is several gigabytes and belongs to a cluster the authors did not administer; the operator's consent covers the study and not publication of the underlying telemetry. The two analysis scripts can be run against a new run produced by the shipped collector and runner, and against the reported run they can be audited but not re-executed.

The provider-account records carry sensitive account and resource identifiers, and a de-identified row-level derivative would still be re-identifiable through rare hardware, timestamp, topology, cost and field combinations. provider_case/ therefore contains the disclosure-reviewed coarse values, the field semantics, and the per-SKU rate map instead of records. The rate map is a project assumption rather than a released rate registry: entries are not bound to a datasheet revision, the precision basis is not recorded per entry, and several are FP8-with-sparsity peaks rather than dense rates. They are deliberately generous, which is the conservative direction for a one-sided upper envelope, and no rule-out rests on them.

figures/manifest.json records paths as they sit in the working repository. figures/manifest_as_submitted.json is the manifest exactly as it shipped with the conference supplement, kept so that artifact reproduces unchanged.