sparta-edgetpu-models

SPARTA — models and measurements for structured pruning on Edge TPU

Every model measured with the SPARTA framework, together with the benchmark CSVs and the compiler reports that describe them.

Code: https://github.com/mouad-zouhdi/sparta-edgetpu The repository README defines every column of every CSV published here.

Internship work at LAAS-CNRS. Author: Mouad Zouhdi.

---

What this collection is

The framework measures how structured pruning behaves once a model actually runs on a Google Coral Edge TPU: latency, accuracy, and the compiler's split between parameters cached in on-chip memory and parameters streamed from the host.

These artefacts are published so the measurements can be checked, re-run on other hardware, or extended without repeating the pruning, which costs thousands of GPU-hours.

---

Contents

Total: 9459 files, 42.4 GiB.

axis1_cifar100

Seven architectures (resnet18, resnet50, vgg19, wrn_28_10, mobilenetv2, googlenet, squeezenet1_1) crossed with seven pruning criteria (magnitude_l1, magnitude_l2, bn_scale, fpgm, taylor, obdc, random) and nine target rates. Each combination is an independent run from the baseline.

Of 441 combinations, 404 produced a model. The rest are criterion and architecture pairs that do not apply: bn_scale needs BatchNorm, and obdc does not support depthwise convolutions or Fire modules.

Naming: <architecture>_pruned<P>pct_<criterion>, where <P> is the requested target. The achieved reduction differs and is recorded in the logs as param_reduction_pct; use that one.

axis2_imagenet

Eight ImageNet architectures pruned from their published weights to a size target, then compiled across 1 to 8 segments so that several accelerators share the model. The *_pipeline_summary.json files record each iteration of the loop that determined how much pruning was needed.

measurements/ holds the Edge TPU measurements of these checkpoints across all 22 ways of splitting eight accelerators between instances, from a single eight-stage pipeline to eight independent copies. Two complete campaigns are published: *_fixedn, 43 checkpoints x 22 partitions = 946 configurations, which every result rests on, and the earlier *_sweepN, 23 checkpoints over ten passes, which is what gives the error bars. accuracy_vs_tpu.csv is the synthesis, one row per checkpoint, and raw_fixedn/ the individual inference times. Its own README describes the protocol, every column, and the three ways the files are easy to read wrongly. The join key against the models is (model, pct).

measurements and provenance_logs

measurements/ is the single-accelerator side: the 411-model CIFAR-100 benchmark in benchmark_results.csv, the five cold-start campaigns that separate what the accelerator loads once from what it streams on every inference, and the synthetic sweeps behind the memory analysis. cold_start_results.json is the warm-up curve of the seven baselines, K passes x N inferences on one interpreter, from which the fixed cost of a first inference is read.

provenance_logs/ holds the scheduler logs of the runs that produced the models: pruning and recovery on the cluster for axis 1, the ImageNet campaigns for axis 2, the extra compilations. Nothing is derived from them; they record what actually ran, and with which options, which no aggregated file keeps.

archive_imagenette_efficientnet_lite0

The first campaign of the internship, on Imagenette, ten classes, by transfer learning from ImageNet weights. It holds 25 pruned efficientnet_lite0 checkpoints, five rates (20 to 60 %) x five criteria (magnitude, l1, taylor, hessian, random), with their INT8 conversions, plus INT8 conversions of eleven other architectures fine-tuned on the same ten classes.

It is not comparable with axis 1 and no published result rests on it: the dataset, the protocol, the resolution and even the criterion names differ. It is kept so that nothing measured is lost, not because it should be used. For the CIFAR-100 results, read axis1_cifar100/.

synthetic

400 configurations: 5 topology families x 4 depths x 5 widths x 4 input resolutions, of which 291 built. The networks are untrained; they exist to sample memory and transfer behaviour more densely than a handful of real models can.

These .tflite files were produced through onnx2tf's flatbuffer_direct backend rather than TFLiteConverter, because models from the other path cannot be compiled with --num_segments above 1. The repository documents this.

---

What is not here

The intermediate artefacts of the guided loop. To make an ImageNet model fit N accelerators, the pipeline prunes, quantizes, compiles, checks the result and prunes again. Every iteration but the last is discarded, and those intermediate checkpoints, quantized models and compiled segments are not published: nothing was measured on them.

Their numbers are kept, in axis2_imagenet/logs/*_pipeline_summary.json, which records the target and the resulting memory split for every iteration.

Failed synthetic builds are documented rather than hidden. Of 400 configurations, 291 built and 109 did not, through memory exhaustion during conversion or an excessive parameter count. Their metadata files are included, with their failure status.

---

Using the models

The .tflite files are INT8, with INT8 input and output tensors. Those under edgetpu/ are already compiled for the accelerator; the others still need edgetpu_compiler.

Read them with ai_edge_litert, not with tflite_runtime 2.5, the version shipped with the Coral stack. That version misreads the quantization produced by ai-edge-quantizer: the output collapses onto the zero point and accuracy reads at chance level, with no error raised.

from ai_edge_litert.interpreter import Interpreter, load_delegate
interp = Interpreter(
    model_path="axis1_cifar100/edgetpu/resnet18_pruned50pct_taylor_int8_edgetpu.tflite",
    experimental_delegates=[load_delegate("libedgetpu.so.1")],
)
interp.allocate_tensors()

The PyTorch checkpoints are whole-model pickles, not state dicts, because structured pruning changes the architecture and a state dict alone could not rebuild it. Load them with weights_only=False, and with mono_tpu/ on sys.path so that cifar_resnet, cifar_vgg and wrn resolve:

import sys; sys.path.insert(0, "path/to/sparta-edgetpu/mono_tpu")
import torch
model = torch.load("axis1_cifar100/pruned_pytorch/resnet18_pruned50pct_taylor.pt",
                   weights_only=False)

---

Downloading

A subset, which is usually what you want:

from huggingface_hub import snapshot_download
snapshot_download("mouad-zouhdi/sparta-edgetpu-models", local_dir="models",
                  allow_patterns=["axis1_cifar100/edgetpu/*", "measurements/*"])

Or through the repository's helper, which names the subsets:

python setup/fetch_models.py --list
python setup/fetch_models.py --set measurements axis1-edgetpu --out models/

The whole collection, 42.4 GiB:

snapshot_download("mouad-zouhdi/sparta-edgetpu-models", local_dir="models")

---

Licence

MIT for the artefacts produced here. They derive from CIFAR-100 and ImageNet-1k and from architectures whose original licences apply.