diff --git a/README.md b/README.md index 9fbd7d1..b678a2b 100644 --- a/README.md +++ b/README.md @@ -57,7 +57,7 @@ Akida 1 and Akida 2 examples are available today; more Akida 2 models can be fou | --- | --- | --- | --- | | **Chip** | AKD1500 | AKD2500 | — | | **Typical use cases** | Image classification, keyword spotting, object detection | Larger models, higher accuracy targets | Always-on sensing, edge inference | -| **Examples in this repo** | [Image Classification (PlantVillage)](akida1/model_zoo/plant_village) · [ImageNet / AkidaNet](akida1/model_zoo/imagenet_akidanet) · [Visual Wake Words](akida1/model_zoo/vww) · [Keyword Spotting](akida1/model_zoo/speech_commands) · [ECG Arrhythmia](akida1/model_zoo/arrhythmia_classification) | [Visual Wake Words](akida2/model_zoo/vww) · [Image Classification (PlantVillage)](akida2/model_zoo/plant_village) · [Keyword Spotting](akida2/model_zoo/speech_commands) | 🔜 Coming soon | +| **Examples in this repo** | [Image Classification (PlantVillage)](akida1/model_zoo/plant_village) · [ImageNet / AkidaNet](akida1/model_zoo/imagenet_akidanet) · [Visual Wake Words](akida1/model_zoo/vww) · [Keyword Spotting](akida1/model_zoo/speech_commands) · [ECG Arrhythmia](akida1/model_zoo/arrhythmia_classification) | [Visual Wake Words](akida2/model_zoo/vww) · [Image Classification (PlantVillage)](akida2/model_zoo/plant_village) · [Keyword Spotting](akida2/model_zoo/speech_commands) · [Gesture Recognition (Jester)](akida2/model_zoo/jester) | 🔜 Coming soon | --- diff --git a/akida2/README.md b/akida2/README.md index e5d0bd1..abe3a5c 100644 --- a/akida2/README.md +++ b/akida2/README.md @@ -165,6 +165,37 @@ benchmarks for every mapping, and the steps to reproduce them. +### Video + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
TaskCategoryDatasetVariantPerformanceMappingLatency @ 25 MHz FPGA (ms)Projected @ 1 GHz AKD2500 (ms)Notes
Hand gesture recognitionClassificationJester (BrainChip subset)8-bit94.64% clip acc.HwPr168.0364.201TENN spatiotemporal, streaming; latency per frame
+ ### Audio diff --git a/akida2/model_zoo/jester/README.md b/akida2/model_zoo/jester/README.md new file mode 100644 index 0000000..009adad --- /dev/null +++ b/akida2/model_zoo/jester/README.md @@ -0,0 +1,462 @@ +BrainChip Dev Hub + +# Hand Gesture Recognition (Jester) — Akida 2 + +BrainChip's **TENN spatiotemporal** model for hand gesture recognition on +[Jester](#dataset), quantized to 8 bits, converted, and evaluated on Akida 2. TENNs +(temporal event-based neural networks) handle time with temporal convolutions. Once +quantized for Akida they run as a **streaming** model: they take one video frame per +inference and give a prediction every frame, keeping just enough of the past frames in +on-chip buffers. + +The example serves two purposes: + +1. **Evaluation and benchmarking**: how much accuracy each step costs, from the float + model through 8-bit quantization to the Akida model, and what one frame costs to run on + Akida 2 hardware. +2. **A worked example of streaming evaluation**: how the model changes when it is + quantized, and what changes when you evaluate a model that sees one frame at a time. + +There is **no training stage**: the float model is BrainChip's published one, and the +8-bit model comes from post-training quantization (PTQ) alone. This example reproduces +that quantization step and checks it against the published 8-bit model. BrainChip's +[training recipe](#training-recipe) is quoted below. For the full train → quantize → +convert pipeline on a dataset that trains in minutes, see +[plant_village](../plant_village). + +## Model Card + +Accuracy on the **BrainChip Jester subset (541 clips)**, a public part of the +Jester validation split (see [Dataset](#dataset)). These are not full validation-set +figures. + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + +
VariantClip accuracyFrame accuracyClips
Float (whole clip)95.01%71.15%541
8-bit PTQ (streaming)94.64%70.52%541
Akida (streaming)94.64%70.52%541
+ +| Parameters | Activation sparsity (Akida) | Input | +|---|---|---| +| 1,353,895 | 56.63% | 100 × 100 RGB, 16 frames per clip | + +- **Clip accuracy** is the headline figure: one decision per clip, from the per-frame + predictions accumulated over its 16 frames (see [Streaming evaluation](#streaming-evaluation)). +- **Frame accuracy** scores each frame's own prediction against the clip's label. It is + lower because a prediction made early in a clip has seen only the start of the gesture. +- Sparsity is the mean over the Akida model's layers, streaming one clip of each class. + +### Akida 2 hardware benchmark + +Latency is measured **per frame**, on the **Akida 2 FPGA** reference platform, which has 6 +nodes (24 neural processors, NPs) and runs at **25 MHz**. The latency projected to the +**1 GHz** AKD2500 target clock is also shown: the cycle count is fixed for a given model +and mapping regardless of clock rate, so the projection is an exact rescale of the +measured cycles. + +> **Note:** 1 GHz is BrainChip's current **target** for AKD2500 production silicon, which +> does not exist yet; treat it as a target, not a measured value. The FPGA has no power +> measurement, so only latency is reported. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
MappingNPsPassesCycles per frameLatency per frame @ 25 MHz (ms)Projected per frame @ 1 GHz (ms) (target)
Minimal4425233177209.3275.233
AllNPs4525227878209.1155.228
HwPr9654200905168.0364.201
+ +**Why per frame.** The model emits a prediction after every frame, so the latency that +matters is that of one frame: it is how far behind the live video the prediction is. +Sixteen times the frame latency is not a "clip latency", because no inference waits for +the end of a clip. + +The model is benchmarked in three mapping modes. **Minimal** maps the model onto the +fewest NPs. **AllNPs** uses as many NPs as possible while keeping the minimum number of +hardware passes. **HwPr** (hardware partial reconfiguration) splits the model into more +passes so that each layer can use more NPs, reloading the weights between passes on every +inference. + +The benchmark streams 160 frames, 10 consecutive clips from the subset, one frame per +inference and in order, so the temporal buffers hold real history as they would on a live +camera feed. Real frames matter because Akida is event-driven: its latency depends on +activation sparsity, which depends on the input. The buffers are not reset between clips +inside the timed loop, which is how a continuous stream runs. Before timing, the benchmark +checks that the hardware streams a clip bit-identically to the software backend. + +**What the mapping modes show.** The NP counts are summed over passes, which is why they +can exceed the FPGA's 24. They also count the input layer's dedicated input processor as +one NP, so they are one more than the count `ak_model.summary()` and BrainChip's +[model zoo](https://doc.brainchipinc.com/model_zoo_performance.html) report. Minimal and +AllNPs are almost the same for this model: both use 2 passes, and AllNPs finds room for only one more NP +(45 against 44), so the latency barely moves. **HwPr** is +the fastest, at 4.201 ms per frame projected to 1 GHz against +5.233 ms for Minimal. It splits the model into 5 +passes over 96 NPs in total. Because this model already needs more than one +pass in every mode, its weights are reloaded at every frame whichever mode you choose. The +extra passes HwPr adds let each layer spread over more NPs, and here that gain outweighs +the extra reloading. That isn't true of every model, so benchmark all three modes for your +own. + +*The full-model plot shows the NPs each layer uses, with pass boundaries, in each mapping +mode; the per-layer plot shows each layer's latency per frame, input sparsity and NPs +under Minimal mapping.* + +Jester TENN: hardware mapping in each mapping mode + +Jester TENN: per-layer latency per frame, input sparsity and mapping + +## The model + +The float model is built from `Conv3D` layers and takes a whole clip, 16 frames of +100 × 100 RGB, returning a prediction for each frame: + +- **Input layer:** a 3 × 3 convolution with stride 2 and 8 filters, applied to each frame + on its own. On Akida it runs on the dedicated input processor, as `InputConv2D`. +- **Five spatiotemporal blocks.** Each has a **temporal** convolution, kernel 5 over time + and 1 × 1 in space, followed by a **spatial** convolution, 3 × 3 with stride 2 and 1 + over time. The first three blocks use full convolutions. The last two use depthwise + separable ones in both parts, a depthwise convolution followed by a pointwise one. The + channels grow from 8 to 640. +- **Head:** average pooling over space (but not time), then `Dense(640)`, ReLU, and the + 27-class `Dense` classifier. There is no softmax: the outputs are logits. +- **No input scaling.** The first layer is a `Rescaling(1.)` placeholder, which only lets + the model take uint8 input. The model was trained on raw pixels in [0, 255], so the + data pipeline must not normalize. + +The temporal convolutions are **causal**: their padding adds 4 frames before the clip and +none after, so each frame's prediction depends only on that frame and the 4 before it at +the first layer, with the history growing through the five blocks. + +**Quantization makes it a streaming model.** `quantizeml` replaces each temporal +`Conv3D` with a `BufferTempConv` (`DepthwiseBufferTempConv` in the last two blocks), +which keeps the last 5 frames' inputs in a FIFO buffer, and each spatial `Conv3D` with a +2D convolution. The quantized model takes one 100 × 100 × 3 frame and returns one +prediction: the computation is the same as the float model's per-frame outputs, done one +frame at a time. Because the convolutions are causal, nothing is lost. On Akida the +buffered layers map onto `TNP_B` components, and each is allotted external memory: both +show in the mapping summary (`ak_model.summary()` in the evaluation notebook). + +## Streaming evaluation + +The float model sees each clip whole. The quantized and Akida models see it one frame at +a time, and their buffers carry state from frame to frame, so evaluation follows two rules: + +- **Reset the buffers at the start of every clip**, or a clip begins with the end of the + previous one. In Keras, `quantizeml.models.reset_buffers(model)` resets them. An + `akida.Model` has no reset: a new model built from the same layers, + `akida.Model(layers=model.layers)`, starts with empty buffers. +- **Accumulate the per-frame predictions into a clip decision.** After each frame, the + running total of softmax outputs is multiplied by 0.8 and the new frame's softmax is + added, so recent frames count most; the clip's class is the largest entry after its last + frame. This is how BrainChip's `evaluate_bufferized_model` scores the model, and it + gives the clip accuracy in the Model Card. Live, the same running total gives a decision + at every frame. + +> **Note:** in Keras the batch holds independent clips, and you step through time +> yourself. On Akida, `jester_eval.py` does as `evaluate_bufferized_model` does: one clip +> at a time, on a new model, one frame per `forward` call. + +## Requirements + +For environment requirements and setup, see the [Requirements](../../../README.md#requirements) +section of the top-level README. + +## Dataset + +**Jester** (20BN-jester, now distributed by Qualcomm) is a large collection of short video +clips of people performing hand gestures in front of a camera: 148,092 clips of about 3 +seconds each, recorded by 1,376 actors, in **27 classes**. These are 25 gestures (swiping, +sliding two fingers, rolling the hand, zooming, thumbs up and down, and so on), plus +*No gesture* and *Doing other things*. The clips are split into train, validation and test +sets in the ratio 8:1:1, with no actor appearing in both the training and the test splits. +The validation split has 14,787 clips, as listed in the dataset's `jester-v1-validation.csv`. + +**This example evaluates on BrainChip's public Jester subset**: 541 clips from the +validation split, covering all 27 classes, stored as GZIP-compressed TFRecords. **Every +accuracy figure in this README is measured on that subset, not on the full validation +set.** See [Using the full validation set](#using-the-full-validation-set) to evaluate on +all of it. + +Each clip is stored as JPEG frames 100 pixels high. For evaluation, the pipeline takes 16 +frames at a stride of 2 from the first frame and center-crops each to 100 × 100, without +resizing or normalizing. See [jester_preprocessing.py](jester_preprocessing.py), a +self-contained copy of the `akida_models` implementation; `python jester_data.py +--check-preprocessing` checks that the two are bit-identical. + +No Jester frames are included in this repository. + +Original dataset licensed under Qualcomm's +[Data License Agreement – Research Use](https://www.qualcomm.com/content/dam/qcomm-martech/dm-assets/documents/jester_something_something_exercise_research_license_final_qti_28jul2022.pdf) +(non-commercial research use only; no redistribution): +> J. Materzynska, G. Berger, I. Bax and R. Memisevic (2019), *"The Jester Dataset: A +> Large-Scale Video Dataset of Human Gestures"*, IEEE/CVF International Conference on +> Computer Vision Workshops (ICCVW). +> [Paper](https://openaccess.thecvf.com/content_ICCVW_2019/html/HANDS/Materzynska_The_Jester_Dataset_A_Large-Scale_Video_Dataset_of_Human_Gestures_ICCVW_2019_paper.html) + +## Dataset setup + +You need two files from BrainChip's dataset mirror: the Jester subset and a calibration +pack (see [Calibration samples](#calibration-samples)). The scripts download both into +`data/` automatically if they're missing: `jester_eval.sh`, `jester_eval.py` and +`jester_data.py` fetch the subset, and `jester_eval.sh` fetches the calibration pack. You +only need the commands below if you're walking through the example by hand or want to +download ahead of time. + +Download the subset (about 100 MB) and extract it into `data/`: + +```bash +wget -N https://data.brainchip.com/dataset-mirror/jester/jester_subset.tar.gz -P data/ +tar -xzf data/jester_subset.tar.gz -C data/ +``` + +Keep the archive in `data/`: on their first run the scripts check it against its sha256 +and use it instead of downloading it again. The extracted subset looks like this: + +``` +data/jester_subset/ +├── jester-v1-labels.csv the 27 class names, in label-index order +├── jester-v1-validation.csv the full validation split's clip list +└── tfrecords/ + └── jester-validation.tfrecord-001-028 541 clips +``` + +`data/jester_subset` is the default dataset path. If you want to store the dataset on a +dedicated data drive, pass the path explicitly to each script (see `--data` / `-d` in the +individual scripts). Alternatively, create a symbolic link from the default path (one-off +step): + +```bash +ln -s /path/to/your/data/jester_subset ./data/jester_subset +``` + +This way the scripts work out of the box without any extra arguments. + +### Calibration samples + +Quantization with `quantizeml` is calibrated on real data. The calibration pack is the set +of samples BrainChip calibrated the published 8-bit model on: 100 clips of 16 frames from +the Jester train split, stored as one `(1600, 100, 100, 3)` uint8 array in clip order. +`jester_eval.sh` fetches it into `data/` automatically: + +```bash +wget -N https://data.brainchip.com/dataset-mirror/samples/jester_video/jester_video_bs100.npz -P data/ +``` + +It lands at `data/jester_video_bs100.npz`. + +### Using the full validation set + +BrainChip doesn't host the full Jester dataset publicly. The scripts read Jester in +BrainChip's TFRecord layout: + +``` +/path/to/jester/ +├── jester-v1-labels.csv +├── jester-v1-train.csv +├── jester-v1-validation.csv +└── tfrecords/ + ├── *train* GZIP TFRecords, one SequenceExample per clip + └── *validation* +``` + +This example only reads `jester-v1-labels.csv` and the TFRecords with `validation` in their +names; the train files are what BrainChip's training script uses. Each record is a +`tf.train.SequenceExample` for one clip, with: + +- context features `filename` (string) and `height`, `width`, `depth`, `frame_count` and + `label` (int64), all required. `label` is the class index in the order of + `jester-v1-labels.csv`. +- a sequence feature `frames`: one JPEG-encoded frame per step, 100 pixels high, in time + order. + +The official download, from Qualcomm after registration, is folders of JPEG frames, one +folder per clip, so you have to convert it to this layout first. This example doesn't +include a converter. Once you have the converted dataset, pass its folder with `--data`: + +```bash +bash jester_eval.sh /path/to/jester +``` + +The accuracy figures you get are then full-validation-set results. + +## Pipeline + +| Stage | Description | +|---|---| +| Float model | BrainChip's published TENN spatiotemporal Jester model (`Conv3D`, whole clips) | +| Calibration samples | BrainChip's pack of 100 train clips × 16 frames | +| 8-bit quantization | `quantizeml quantize -w 8 -i 8 -a 8 --per_tensor_activations -id uint8 -e 1 -bs 100`; PTQ only, no QAT. Temporal `Conv3D` layers become `BufferTempConv` | +| Reproduction check | The result compared with the published 8-bit model: structure, weights, and the converted Akida model | +| Conversion to Akida | `cnn2snn convert` to an Akida 2 model | +| Evaluation | Clip and frame accuracy for all three variants, streaming the quantized and Akida models, plus activation sparsity | +| Hardware benchmark | Akida 2 FPGA latency per frame, in three mapping modes | + +## Training recipe + +The float model was trained by BrainChip on the full Jester train split, with +`train_spatiotemporal_jester.sh`. It is quoted here as the documented recipe; this +example doesn't run it. `tenn_jester_train` comes with `akida_models`, and `-d` is a +full Jester directory, train split included, in the layout described under +[Using the full validation set](#using-the-full-validation-set): + +```bash +wget -N https://data.brainchip.com/dataset-mirror/samples/jester_video/jester_video_bs100.npz + +akida_models create tenn_spatiotemporal_jester + +tenn_jester_train train -d /path/to/jester/ \ + -e 200 -m tenn_spatiotemporal_jester.h5 -s tenn_spatiotemporal_jester.h5 + +tenn_jester_train eval -d /path/to/jester/ -m tenn_spatiotemporal_jester.h5 + +quantizeml quantize -m tenn_spatiotemporal_jester.h5 -w 8 -i 8 -a 8 \ + --per_tensor_activations -id uint8 -e 1 -bs 100 -sa jester_video_bs100.npz \ + -s tenn_spatiotemporal_jester_buffer_i8_w8_a8.h5 + +tenn_jester_train eval -d /path/to/jester/ \ + -m tenn_spatiotemporal_jester_buffer_i8_w8_a8.h5 + +tenn_jester_train eval -d /path/to/jester/ -ak \ + -m tenn_spatiotemporal_jester_buffer_i8_w8_a8.h5 +``` + +`jester_eval.sh` reproduces the steps after training. Its `-bs 100` matters: the +calibration pack is one array of frames in clip order, and for a spatiotemporal TENN the +batch size tells the calibration how to cut it back into clips, so it must equal the +number of clips in the pack. + +## Reference Models + +The models are in `pretrained_models/`, handled with `git-lfs` (git large file storage). +To get the real files rather than text pointers, you need `git-lfs` set up: see the +[Trained models](../../../README.md#trained-models) section of the top-level README. + +``` +tenn_spatiotemporal_jester.h5 float Keras model (Conv3D) +tenn_spatiotemporal_jester_buffer_i8_w8_a8.h5 8-bit quantized Keras model (buffered) +tenn_spatiotemporal_jester_buffer_i8_w8_a8.fbz converted Akida model +``` + +The two `.h5` files are BrainChip's published models, the ones +`akida_models.tenn_spatiotemporal_jester_pretrained` downloads, and the `.fbz` is the +8-bit model converted with `cnn2snn`. The scripts check each file against a sha256 pinned +in [jester_model.py](jester_model.py), so a Git LFS pointer that was never pulled fails +with a clear message. + +Reproducing the quantization gives the same model: identical structure and, after +conversion, identical integer weights and thresholds. Only a few float values differ, by +rounding, in the Keras model and in the Akida model's output scales. Both evaluate +identically. `python jester_model.py --compare ` prints the comparison. + +## Usage + +### Notebooks + +[jester_notebook_evaluation.ipynb](jester_notebook_evaluation.ipynb) takes the float model +to an Akida model: evaluation of the whole-clip float model, 8-bit PTQ and the +reproduction check, streaming evaluation, conversion, mapping onto Akida 2 devices, and +activation sparsity. + +[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Brainchip-Inc/brainchip_devhub/blob/main/akida2/model_zoo/jester/jester_notebook_evaluation.ipynb) + +[jester_notebook_benchmark.ipynb](jester_notebook_benchmark.ipynb) benchmarks the model on +the Akida 2 FPGA: latency per frame in each mapping mode, and per layer. + +> **Note:** the hardware benchmark requires a physical Akida 2 FPGA platform. + +### Script + +To reproduce the evaluation and quantization end to end (float evaluation, quantization, +the check against the published model, conversion, and quantized and Akida evaluation) +into `models/`: + +```bash +bash jester_eval.sh [DATADIR] +``` + +Without `DATADIR` it uses the BrainChip Jester subset. To benchmark the published model on +the FPGA: + +```bash +python jester_benchmark.py +``` + +## Contributing and Maintenance + +This README is generated from `docs/README.md.template`, so that the accuracy and +hardware benchmark values are written directly by the code (via `docs/metrics.json`). + +When the models or the pipeline change, rerun the evaluations of all three variants and +the hardware benchmark with `--save-metrics`, then regenerate the README: + +```bash +python jester_eval.py --variant float --save-metrics +python jester_eval.py --variant quantized --save-metrics +python jester_eval.py --variant akida --save-metrics +python jester_benchmark.py --save-metrics # needs the Akida 2 FPGA + +python update_readme.py +``` + +If you evaluate on a different dataset directory, update the wording that names the +BrainChip Jester subset in the template and in `docs/zoo_card.json`. Then commit the +changed files (template, metrics, figures and the regenerated README). To edit this +README, edit `docs/README.md.template`, not the README itself, and run +`python update_readme.py`. diff --git a/akida2/model_zoo/jester/colab_setup.py b/akida2/model_zoo/jester/colab_setup.py new file mode 100644 index 0000000..049b7c8 --- /dev/null +++ b/akida2/model_zoo/jester/colab_setup.py @@ -0,0 +1,64 @@ +# Copyright 2026 Brainchip Holdings Ltd. Apache 2.0 License +"""Colab setup for the Jester TENN (Akida 2) notebooks. + +IF YOU ARE RUNNING THIS LOCALLY: you can ignore this file completely. +It exists solely to make the "Open in Colab" badge work, and does nothing +on a normal local run. It is not part of the example code (see +jester_data.py, jester_model.py and +jester_eval.py for that). + +If you ARE on Colab, this is the file that gets you running: + - Clones this repo and fetches this example's Git LFS model weights, which + the notebooks need + - Points Python at the right folders (repo root for brainchip_utils, + this example's folder for the local modules) + - Installs akida_models, tf_keras and quantizeml + +There is no dataset step here: the data module downloads the BrainChip Jester +subset and the calibration pack from BrainChip's dataset mirror on first use. + +Called from the notebook's first cell like: + import colab_setup + colab_setup.setup() +""" +import os +import subprocess +import sys + +REPO_URL = 'https://github.com/Brainchip-Inc/brainchip_devhub.git' +REPO_DIR = 'brainchip_devhub' +EXAMPLE_SUBDIR = 'akida2/model_zoo/jester' + + +def _run(cmd): + print(f'$ {cmd}') + subprocess.run(cmd, shell=True, check=True) + + +def setup(): + """Set up a fresh Colab session to run this notebook. No-op if not on Colab.""" + if 'google.colab' not in sys.modules: + print('Not running on Colab — nothing to do. (This step only matters ' + 'for Colab; local runs already have everything they need.)') + return + + if not os.path.exists(REPO_DIR): + # Clone without LFS files, then pull only this example's models, to keep + # the download small. + os.environ['GIT_LFS_SKIP_SMUDGE'] = '1' + _run(f'git clone --depth 1 {REPO_URL} {REPO_DIR}') + _run(f'cd {REPO_DIR} && git lfs pull --include "{EXAMPLE_SUBDIR}/pretrained_models/*"') + + os.chdir(os.path.join(REPO_DIR, EXAMPLE_SUBDIR)) + + # Repo root on sys.path for `brainchip_utils`; example folder for the local + # jester_* modules imported later in the notebook. + repo_root = os.path.abspath(os.path.join(os.getcwd(), '..', '..', '..')) + sys.path.insert(0, repo_root) + sys.path.insert(0, os.getcwd()) + + _run('pip install -q akida_models==1.14.0 tf_keras quantizeml') + + print(f'Colab setup complete. Working directory: {os.getcwd()}') + print('If TensorFlow was just installed/upgraded, restart the runtime ' + '(Runtime > Restart session) and re-run this cell before continuing.') diff --git a/akida2/model_zoo/jester/data/.gitignore b/akida2/model_zoo/jester/data/.gitignore new file mode 100644 index 0000000..647613e --- /dev/null +++ b/akida2/model_zoo/jester/data/.gitignore @@ -0,0 +1,4 @@ +# Git to Ignore everything in this directory +* +# Except this .gitignore file +!.gitignore \ No newline at end of file diff --git a/akida2/model_zoo/jester/docs/README.md.template b/akida2/model_zoo/jester/docs/README.md.template new file mode 100644 index 0000000..ff130ab --- /dev/null +++ b/akida2/model_zoo/jester/docs/README.md.template @@ -0,0 +1,462 @@ +BrainChip Dev Hub + +# Hand Gesture Recognition (Jester) — Akida 2 + +BrainChip's **TENN spatiotemporal** model for hand gesture recognition on +[Jester](#dataset), quantized to 8 bits, converted, and evaluated on Akida 2. TENNs +(temporal event-based neural networks) handle time with temporal convolutions. Once +quantized for Akida they run as a **streaming** model: they take one video frame per +inference and give a prediction every frame, keeping just enough of the past frames in +on-chip buffers. + +The example serves two purposes: + +1. **Evaluation and benchmarking**: how much accuracy each step costs, from the float + model through 8-bit quantization to the Akida model, and what one frame costs to run on + Akida 2 hardware. +2. **A worked example of streaming evaluation**: how the model changes when it is + quantized, and what changes when you evaluate a model that sees one frame at a time. + +There is **no training stage**: the float model is BrainChip's published one, and the +8-bit model comes from post-training quantization (PTQ) alone. This example reproduces +that quantization step and checks it against the published 8-bit model. BrainChip's +[training recipe](#training-recipe) is quoted below. For the full train → quantize → +convert pipeline on a dataset that trains in minutes, see +[plant_village](../plant_village). + +## Model Card + +Accuracy on the **BrainChip Jester subset ({w8a8_akida_n} clips)**, a public part of the +Jester validation split (see [Dataset](#dataset)). These are not full validation-set +figures. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
VariantClip accuracyFrame accuracyClips
Float (whole clip){float_clip_acc}{float_frame_acc}{float_n}
8-bit PTQ (streaming){w8a8_quant_clip_acc}{w8a8_quant_frame_acc}{w8a8_quant_n}
Akida (streaming){w8a8_akida_clip_acc}{w8a8_akida_frame_acc}{w8a8_akida_n}
+ +| Parameters | Activation sparsity (Akida) | Input | +|---|---|---| +| {params} | {w8a8_sparsity} | 100 × 100 RGB, 16 frames per clip | + +- **Clip accuracy** is the headline figure: one decision per clip, from the per-frame + predictions accumulated over its 16 frames (see [Streaming evaluation](#streaming-evaluation)). +- **Frame accuracy** scores each frame's own prediction against the clip's label. It is + lower because a prediction made early in a clip has seen only the start of the gesture. +- Sparsity is the mean over the Akida model's layers, streaming one clip of each class. + +### Akida 2 hardware benchmark + +Latency is measured **per frame**, on the **Akida 2 FPGA** reference platform, which has 6 +nodes (24 neural processors, NPs) and runs at **25 MHz**. The latency projected to the +**1 GHz** AKD2500 target clock is also shown: the cycle count is fixed for a given model +and mapping regardless of clock rate, so the projection is an exact rescale of the +measured cycles. + +> **Note:** 1 GHz is BrainChip's current **target** for AKD2500 production silicon, which +> does not exist yet; treat it as a target, not a measured value. The FPGA has no power +> measurement, so only latency is reported. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
MappingNPsPassesCycles per frameLatency per frame @ 25 MHz (ms)Projected per frame @ 1 GHz (ms) (target)
Minimal{w8a8_minimal_nps}{w8a8_minimal_passes}{w8a8_minimal_cycles}{w8a8_minimal_latency_ms}{w8a8_minimal_projected_ms}
AllNPs{w8a8_allnps_nps}{w8a8_allnps_passes}{w8a8_allnps_cycles}{w8a8_allnps_latency_ms}{w8a8_allnps_projected_ms}
HwPr{w8a8_hwpr_nps}{w8a8_hwpr_passes}{w8a8_hwpr_cycles}{w8a8_hwpr_latency_ms}{w8a8_hwpr_projected_ms}
+ +**Why per frame.** The model emits a prediction after every frame, so the latency that +matters is that of one frame: it is how far behind the live video the prediction is. +Sixteen times the frame latency is not a "clip latency", because no inference waits for +the end of a clip. + +The model is benchmarked in three mapping modes. **Minimal** maps the model onto the +fewest NPs. **AllNPs** uses as many NPs as possible while keeping the minimum number of +hardware passes. **HwPr** (hardware partial reconfiguration) splits the model into more +passes so that each layer can use more NPs, reloading the weights between passes on every +inference. + +The benchmark streams 160 frames, 10 consecutive clips from the subset, one frame per +inference and in order, so the temporal buffers hold real history as they would on a live +camera feed. Real frames matter because Akida is event-driven: its latency depends on +activation sparsity, which depends on the input. The buffers are not reset between clips +inside the timed loop, which is how a continuous stream runs. Before timing, the benchmark +checks that the hardware streams a clip bit-identically to the software backend. + +**What the mapping modes show.** The NP counts are summed over passes, which is why they +can exceed the FPGA's 24. They also count the input layer's dedicated input processor as +one NP, so they are one more than the count `ak_model.summary()` and BrainChip's +[model zoo](https://doc.brainchipinc.com/model_zoo_performance.html) report. Minimal and +AllNPs are almost the same for this model: both use {w8a8_minimal_passes} passes, and AllNPs finds room for only one more NP +({w8a8_allnps_nps} against {w8a8_minimal_nps}), so the latency barely moves. **HwPr** is +the fastest, at {w8a8_hwpr_projected_ms} ms per frame projected to 1 GHz against +{w8a8_minimal_projected_ms} ms for Minimal. It splits the model into {w8a8_hwpr_passes} +passes over {w8a8_hwpr_nps} NPs in total. Because this model already needs more than one +pass in every mode, its weights are reloaded at every frame whichever mode you choose. The +extra passes HwPr adds let each layer spread over more NPs, and here that gain outweighs +the extra reloading. That isn't true of every model, so benchmark all three modes for your +own. + +*The full-model plot shows the NPs each layer uses, with pass boundaries, in each mapping +mode; the per-layer plot shows each layer's latency per frame, input sparsity and NPs +under Minimal mapping.* + +Jester TENN: hardware mapping in each mapping mode + +Jester TENN: per-layer latency per frame, input sparsity and mapping + +## The model + +The float model is built from `Conv3D` layers and takes a whole clip, 16 frames of +100 × 100 RGB, returning a prediction for each frame: + +- **Input layer:** a 3 × 3 convolution with stride 2 and 8 filters, applied to each frame + on its own. On Akida it runs on the dedicated input processor, as `InputConv2D`. +- **Five spatiotemporal blocks.** Each has a **temporal** convolution, kernel 5 over time + and 1 × 1 in space, followed by a **spatial** convolution, 3 × 3 with stride 2 and 1 + over time. The first three blocks use full convolutions. The last two use depthwise + separable ones in both parts, a depthwise convolution followed by a pointwise one. The + channels grow from 8 to 640. +- **Head:** average pooling over space (but not time), then `Dense(640)`, ReLU, and the + 27-class `Dense` classifier. There is no softmax: the outputs are logits. +- **No input scaling.** The first layer is a `Rescaling(1.)` placeholder, which only lets + the model take uint8 input. The model was trained on raw pixels in [0, 255], so the + data pipeline must not normalize. + +The temporal convolutions are **causal**: their padding adds 4 frames before the clip and +none after, so each frame's prediction depends only on that frame and the 4 before it at +the first layer, with the history growing through the five blocks. + +**Quantization makes it a streaming model.** `quantizeml` replaces each temporal +`Conv3D` with a `BufferTempConv` (`DepthwiseBufferTempConv` in the last two blocks), +which keeps the last 5 frames' inputs in a FIFO buffer, and each spatial `Conv3D` with a +2D convolution. The quantized model takes one 100 × 100 × 3 frame and returns one +prediction: the computation is the same as the float model's per-frame outputs, done one +frame at a time. Because the convolutions are causal, nothing is lost. On Akida the +buffered layers map onto `TNP_B` components, and each is allotted external memory: both +show in the mapping summary (`ak_model.summary()` in the evaluation notebook). + +## Streaming evaluation + +The float model sees each clip whole. The quantized and Akida models see it one frame at +a time, and their buffers carry state from frame to frame, so evaluation follows two rules: + +- **Reset the buffers at the start of every clip**, or a clip begins with the end of the + previous one. In Keras, `quantizeml.models.reset_buffers(model)` resets them. An + `akida.Model` has no reset: a new model built from the same layers, + `akida.Model(layers=model.layers)`, starts with empty buffers. +- **Accumulate the per-frame predictions into a clip decision.** After each frame, the + running total of softmax outputs is multiplied by 0.8 and the new frame's softmax is + added, so recent frames count most; the clip's class is the largest entry after its last + frame. This is how BrainChip's `evaluate_bufferized_model` scores the model, and it + gives the clip accuracy in the Model Card. Live, the same running total gives a decision + at every frame. + +> **Note:** in Keras the batch holds independent clips, and you step through time +> yourself. On Akida, `jester_eval.py` does as `evaluate_bufferized_model` does: one clip +> at a time, on a new model, one frame per `forward` call. + +## Requirements + +For environment requirements and setup, see the [Requirements](../../../README.md#requirements) +section of the top-level README. + +## Dataset + +**Jester** (20BN-jester, now distributed by Qualcomm) is a large collection of short video +clips of people performing hand gestures in front of a camera: 148,092 clips of about 3 +seconds each, recorded by 1,376 actors, in **27 classes**. These are 25 gestures (swiping, +sliding two fingers, rolling the hand, zooming, thumbs up and down, and so on), plus +*No gesture* and *Doing other things*. The clips are split into train, validation and test +sets in the ratio 8:1:1, with no actor appearing in both the training and the test splits. +The validation split has 14,787 clips, as listed in the dataset's `jester-v1-validation.csv`. + +**This example evaluates on BrainChip's public Jester subset**: {w8a8_akida_n} clips from the +validation split, covering all 27 classes, stored as GZIP-compressed TFRecords. **Every +accuracy figure in this README is measured on that subset, not on the full validation +set.** See [Using the full validation set](#using-the-full-validation-set) to evaluate on +all of it. + +Each clip is stored as JPEG frames 100 pixels high. For evaluation, the pipeline takes 16 +frames at a stride of 2 from the first frame and center-crops each to 100 × 100, without +resizing or normalizing. See [jester_preprocessing.py](jester_preprocessing.py), a +self-contained copy of the `akida_models` implementation; `python jester_data.py +--check-preprocessing` checks that the two are bit-identical. + +No Jester frames are included in this repository. + +Original dataset licensed under Qualcomm's +[Data License Agreement – Research Use](https://www.qualcomm.com/content/dam/qcomm-martech/dm-assets/documents/jester_something_something_exercise_research_license_final_qti_28jul2022.pdf) +(non-commercial research use only; no redistribution): +> J. Materzynska, G. Berger, I. Bax and R. Memisevic (2019), *"The Jester Dataset: A +> Large-Scale Video Dataset of Human Gestures"*, IEEE/CVF International Conference on +> Computer Vision Workshops (ICCVW). +> [Paper](https://openaccess.thecvf.com/content_ICCVW_2019/html/HANDS/Materzynska_The_Jester_Dataset_A_Large-Scale_Video_Dataset_of_Human_Gestures_ICCVW_2019_paper.html) + +## Dataset setup + +You need two files from BrainChip's dataset mirror: the Jester subset and a calibration +pack (see [Calibration samples](#calibration-samples)). The scripts download both into +`data/` automatically if they're missing: `jester_eval.sh`, `jester_eval.py` and +`jester_data.py` fetch the subset, and `jester_eval.sh` fetches the calibration pack. You +only need the commands below if you're walking through the example by hand or want to +download ahead of time. + +Download the subset (about 100 MB) and extract it into `data/`: + +```bash +wget -N https://data.brainchip.com/dataset-mirror/jester/jester_subset.tar.gz -P data/ +tar -xzf data/jester_subset.tar.gz -C data/ +``` + +Keep the archive in `data/`: on their first run the scripts check it against its sha256 +and use it instead of downloading it again. The extracted subset looks like this: + +``` +data/jester_subset/ +├── jester-v1-labels.csv the 27 class names, in label-index order +├── jester-v1-validation.csv the full validation split's clip list +└── tfrecords/ + └── jester-validation.tfrecord-001-028 {w8a8_akida_n} clips +``` + +`data/jester_subset` is the default dataset path. If you want to store the dataset on a +dedicated data drive, pass the path explicitly to each script (see `--data` / `-d` in the +individual scripts). Alternatively, create a symbolic link from the default path (one-off +step): + +```bash +ln -s /path/to/your/data/jester_subset ./data/jester_subset +``` + +This way the scripts work out of the box without any extra arguments. + +### Calibration samples + +Quantization with `quantizeml` is calibrated on real data. The calibration pack is the set +of samples BrainChip calibrated the published 8-bit model on: 100 clips of 16 frames from +the Jester train split, stored as one `(1600, 100, 100, 3)` uint8 array in clip order. +`jester_eval.sh` fetches it into `data/` automatically: + +```bash +wget -N https://data.brainchip.com/dataset-mirror/samples/jester_video/jester_video_bs100.npz -P data/ +``` + +It lands at `data/jester_video_bs100.npz`. + +### Using the full validation set + +BrainChip doesn't host the full Jester dataset publicly. The scripts read Jester in +BrainChip's TFRecord layout: + +``` +/path/to/jester/ +├── jester-v1-labels.csv +├── jester-v1-train.csv +├── jester-v1-validation.csv +└── tfrecords/ + ├── *train* GZIP TFRecords, one SequenceExample per clip + └── *validation* +``` + +This example only reads `jester-v1-labels.csv` and the TFRecords with `validation` in their +names; the train files are what BrainChip's training script uses. Each record is a +`tf.train.SequenceExample` for one clip, with: + +- context features `filename` (string) and `height`, `width`, `depth`, `frame_count` and + `label` (int64), all required. `label` is the class index in the order of + `jester-v1-labels.csv`. +- a sequence feature `frames`: one JPEG-encoded frame per step, 100 pixels high, in time + order. + +The official download, from Qualcomm after registration, is folders of JPEG frames, one +folder per clip, so you have to convert it to this layout first. This example doesn't +include a converter. Once you have the converted dataset, pass its folder with `--data`: + +```bash +bash jester_eval.sh /path/to/jester +``` + +The accuracy figures you get are then full-validation-set results. + +## Pipeline + +| Stage | Description | +|---|---| +| Float model | BrainChip's published TENN spatiotemporal Jester model (`Conv3D`, whole clips) | +| Calibration samples | BrainChip's pack of 100 train clips × 16 frames | +| 8-bit quantization | `quantizeml quantize -w 8 -i 8 -a 8 --per_tensor_activations -id uint8 -e 1 -bs 100`; PTQ only, no QAT. Temporal `Conv3D` layers become `BufferTempConv` | +| Reproduction check | The result compared with the published 8-bit model: structure, weights, and the converted Akida model | +| Conversion to Akida | `cnn2snn convert` to an Akida 2 model | +| Evaluation | Clip and frame accuracy for all three variants, streaming the quantized and Akida models, plus activation sparsity | +| Hardware benchmark | Akida 2 FPGA latency per frame, in three mapping modes | + +## Training recipe + +The float model was trained by BrainChip on the full Jester train split, with +`train_spatiotemporal_jester.sh`. It is quoted here as the documented recipe; this +example doesn't run it. `tenn_jester_train` comes with `akida_models`, and `-d` is a +full Jester directory, train split included, in the layout described under +[Using the full validation set](#using-the-full-validation-set): + +```bash +wget -N https://data.brainchip.com/dataset-mirror/samples/jester_video/jester_video_bs100.npz + +akida_models create tenn_spatiotemporal_jester + +tenn_jester_train train -d /path/to/jester/ \ + -e 200 -m tenn_spatiotemporal_jester.h5 -s tenn_spatiotemporal_jester.h5 + +tenn_jester_train eval -d /path/to/jester/ -m tenn_spatiotemporal_jester.h5 + +quantizeml quantize -m tenn_spatiotemporal_jester.h5 -w 8 -i 8 -a 8 \ + --per_tensor_activations -id uint8 -e 1 -bs 100 -sa jester_video_bs100.npz \ + -s tenn_spatiotemporal_jester_buffer_i8_w8_a8.h5 + +tenn_jester_train eval -d /path/to/jester/ \ + -m tenn_spatiotemporal_jester_buffer_i8_w8_a8.h5 + +tenn_jester_train eval -d /path/to/jester/ -ak \ + -m tenn_spatiotemporal_jester_buffer_i8_w8_a8.h5 +``` + +`jester_eval.sh` reproduces the steps after training. Its `-bs 100` matters: the +calibration pack is one array of frames in clip order, and for a spatiotemporal TENN the +batch size tells the calibration how to cut it back into clips, so it must equal the +number of clips in the pack. + +## Reference Models + +The models are in `pretrained_models/`, handled with `git-lfs` (git large file storage). +To get the real files rather than text pointers, you need `git-lfs` set up: see the +[Trained models](../../../README.md#trained-models) section of the top-level README. + +``` +tenn_spatiotemporal_jester.h5 float Keras model (Conv3D) +tenn_spatiotemporal_jester_buffer_i8_w8_a8.h5 8-bit quantized Keras model (buffered) +tenn_spatiotemporal_jester_buffer_i8_w8_a8.fbz converted Akida model +``` + +The two `.h5` files are BrainChip's published models, the ones +`akida_models.tenn_spatiotemporal_jester_pretrained` downloads, and the `.fbz` is the +8-bit model converted with `cnn2snn`. The scripts check each file against a sha256 pinned +in [jester_model.py](jester_model.py), so a Git LFS pointer that was never pulled fails +with a clear message. + +Reproducing the quantization gives the same model: identical structure and, after +conversion, identical integer weights and thresholds. Only a few float values differ, by +rounding, in the Keras model and in the Akida model's output scales. Both evaluate +identically. `python jester_model.py --compare ` prints the comparison. + +## Usage + +### Notebooks + +[jester_notebook_evaluation.ipynb](jester_notebook_evaluation.ipynb) takes the float model +to an Akida model: evaluation of the whole-clip float model, 8-bit PTQ and the +reproduction check, streaming evaluation, conversion, mapping onto Akida 2 devices, and +activation sparsity. + +[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/Brainchip-Inc/brainchip_devhub/blob/main/akida2/model_zoo/jester/jester_notebook_evaluation.ipynb) + +[jester_notebook_benchmark.ipynb](jester_notebook_benchmark.ipynb) benchmarks the model on +the Akida 2 FPGA: latency per frame in each mapping mode, and per layer. + +> **Note:** the hardware benchmark requires a physical Akida 2 FPGA platform. + +### Script + +To reproduce the evaluation and quantization end to end (float evaluation, quantization, +the check against the published model, conversion, and quantized and Akida evaluation) +into `models/`: + +```bash +bash jester_eval.sh [DATADIR] +``` + +Without `DATADIR` it uses the BrainChip Jester subset. To benchmark the published model on +the FPGA: + +```bash +python jester_benchmark.py +``` + +## Contributing and Maintenance + +This README is generated from `docs/README.md.template`, so that the accuracy and +hardware benchmark values are written directly by the code (via `docs/metrics.json`). + +When the models or the pipeline change, rerun the evaluations of all three variants and +the hardware benchmark with `--save-metrics`, then regenerate the README: + +```bash +python jester_eval.py --variant float --save-metrics +python jester_eval.py --variant quantized --save-metrics +python jester_eval.py --variant akida --save-metrics +python jester_benchmark.py --save-metrics # needs the Akida 2 FPGA + +python update_readme.py +``` + +If you evaluate on a different dataset directory, update the wording that names the +BrainChip Jester subset in the template and in `docs/zoo_card.json`. Then commit the +changed files (template, metrics, figures and the regenerated README). To edit this +README, edit `docs/README.md.template`, not the README itself, and run +`python update_readme.py`. diff --git a/akida2/model_zoo/jester/docs/metrics.json b/akida2/model_zoo/jester/docs/metrics.json new file mode 100644 index 0000000..818e43c --- /dev/null +++ b/akida2/model_zoo/jester/docs/metrics.json @@ -0,0 +1,28 @@ +{ + "float_clip_acc": "95.01%", + "float_frame_acc": "71.15%", + "float_n": "541", + "params": "1,353,895", + "w8a8_akida_clip_acc": "94.64%", + "w8a8_akida_frame_acc": "70.52%", + "w8a8_akida_n": "541", + "w8a8_allnps_cycles": "5227878", + "w8a8_allnps_latency_ms": "209.115", + "w8a8_allnps_nps": "45", + "w8a8_allnps_passes": "2", + "w8a8_allnps_projected_ms": "5.228", + "w8a8_hwpr_cycles": "4200905", + "w8a8_hwpr_latency_ms": "168.036", + "w8a8_hwpr_nps": "96", + "w8a8_hwpr_passes": "5", + "w8a8_hwpr_projected_ms": "4.201", + "w8a8_minimal_cycles": "5233177", + "w8a8_minimal_latency_ms": "209.327", + "w8a8_minimal_nps": "44", + "w8a8_minimal_passes": "2", + "w8a8_minimal_projected_ms": "5.233", + "w8a8_quant_clip_acc": "94.64%", + "w8a8_quant_frame_acc": "70.52%", + "w8a8_quant_n": "541", + "w8a8_sparsity": "56.63%" +} diff --git a/akida2/model_zoo/jester/docs/ref_benchmark_results_full_tenn_spatiotemporal_jester_buffer_i8_w8_a8.png b/akida2/model_zoo/jester/docs/ref_benchmark_results_full_tenn_spatiotemporal_jester_buffer_i8_w8_a8.png new file mode 100644 index 0000000..7c0e278 Binary files /dev/null and b/akida2/model_zoo/jester/docs/ref_benchmark_results_full_tenn_spatiotemporal_jester_buffer_i8_w8_a8.png differ diff --git a/akida2/model_zoo/jester/docs/ref_benchmark_results_layers_tenn_spatiotemporal_jester_buffer_i8_w8_a8.png b/akida2/model_zoo/jester/docs/ref_benchmark_results_layers_tenn_spatiotemporal_jester_buffer_i8_w8_a8.png new file mode 100644 index 0000000..bb01b60 Binary files /dev/null and b/akida2/model_zoo/jester/docs/ref_benchmark_results_layers_tenn_spatiotemporal_jester_buffer_i8_w8_a8.png differ diff --git a/akida2/model_zoo/jester/docs/zoo_card.json b/akida2/model_zoo/jester/docs/zoo_card.json new file mode 100644 index 0000000..de3c438 --- /dev/null +++ b/akida2/model_zoo/jester/docs/zoo_card.json @@ -0,0 +1,16 @@ +{ + "domain": "Video", + "order": 10, + "rows": [ + { + "task": "Hand gesture recognition", + "category": "Classification", + "dataset": "Jester (BrainChip subset)", + "variant": "8-bit", + "metric_key": "w8a8_akida_clip_acc", + "metric_label": "clip acc.", + "bench_prefix": "w8a8_", + "notes": "TENN spatiotemporal, streaming; latency per frame" + } + ] +} diff --git a/akida2/model_zoo/jester/jester_benchmark.py b/akida2/model_zoo/jester/jester_benchmark.py new file mode 100644 index 0000000..14282f8 --- /dev/null +++ b/akida2/model_zoo/jester/jester_benchmark.py @@ -0,0 +1,253 @@ +#!/usr/bin/env python +# Copyright 2026 Brainchip Holdings Ltd. Apache 2.0 License +""" +Hardware benchmark for the Jester TENN model on Akida 2. + +Measures **per-frame** latency on the Akida 2 FPGA in three mapping modes, then +breaks the timing down per layer. Prints a summary, writes plots to ``docs/``, +and can record the numbers into ``docs/metrics.json``. + +Requires a connected Akida 2 device. Without one the script exits early: +accuracy and activation sparsity don't need hardware and are measured by +``jester_eval.py`` instead. + +Benchmark details: + * The model is streaming: it takes one frame per inference and emits a + prediction every frame, so the cost that matters is the latency of one + frame. A clip's 16 frames are 16 inferences; there is no per-clip latency + to add up. + * The samples are consecutive frames of real clips, fed one per inference in + stream order, so the temporal buffers hold real history, as they would on a + live camera feed. Akida is event-driven and its latency depends on + activation sparsity, which depends on the input, so random or shuffled + frames would give the wrong numbers. The buffers are not reset between + clips inside the timed loop: that is continuous streaming, and the cost of a + reset is not measured. + * The Akida 2 reference hardware is an FPGA running at 25 MHz. Latency is also + projected to the AKD2500 target clock: the cycle count is fixed for a given + model and mapping, so projected_latency_ms = cycles / target_clock. + * Power is not measured: the FPGA has no power measurement path. + * The FPGA has 6 nodes (24 NPs). The model maps in one hardware sequence + (hw_only=True), over more than one pass. + +Before timing, the script checks that the hardware streams a clip exactly as the +software backend does, buffers included. It also reports whether forwarding a whole +clip as one batch gives the same outputs on hardware (the batch axis read as time). +Nothing depends on that check: every inference here is one frame per forward call. + +Example +------- + python jester_benchmark.py +""" +import argparse +import json +import pathlib +import sys + +import numpy as np +import akida + +from jester_data import get_data_dir, get_stream +from jester_eval import stream, stream_sparsity +from jester_model import model_path, verify_model +from jester_preprocessing import FRAMES_PER_CLIP +from brainchip_utils.hardware_utils import (get_mapping_stats, get_akida_device, + per_layer_benchmark, full_model_benchmark, + AKIDA_CLOCKS_HZ) +from brainchip_utils.plot_utils import (plot_full_model_results, plot_per_layer_results, + pretty_print_sparsity) + +# Measured clock: Akida 2 reference hardware is an FPGA clocked at 25 MHz. +MEASURED_CLOCK = AKIDA_CLOCKS_HZ['AKIDA2_FPGA'] + +# Projected clock: latency is also projected to the AKD2500 target silicon clock, to +# indicate expected performance on production hardware. Cycle count is clock-independent, +# so the projection is exact given the target frequency. AKD2500 production silicon does +# not exist yet, so this is BrainChip's current internal target (1 GHz), not a measured +# value -- it may still change before production. See brainchip_utils.hardware_utils.AKIDA_CLOCKS_HZ. +PROJECTED_CLOCK = AKIDA_CLOCKS_HZ['AKD2500'] + +# Consecutive clips streamed by the benchmark: 10 clips of 16 frames +NUM_CLIPS = 10 + + +def check_hw_matches_sw(ak_model, device, clip): + """Streams one clip on hardware and on the software backend, from empty buffers. + + Returns: + bool: True if every frame's output is bit-identical. + """ + hw = akida.Model(layers=ak_model.layers) + hw.map(device, mode=akida.MapMode.Minimal, hw_only=True) + sw = akida.Model(layers=ak_model.layers) + hw_out = np.concatenate([hw.forward(clip[t:t + 1]) for t in range(len(clip))]) + sw_out = np.concatenate([sw.forward(clip[t:t + 1]) for t in range(len(clip))]) + return np.array_equal(hw_out, sw_out) + + +def check_batch_as_time(ak_model, device, clip): + """Forwards one clip on hardware as a single batch, from empty buffers. + + Nothing else depends on it: it records whether the hardware, like the + software backend, reads the batch axis of a buffered model as time. + + Returns: + bool or str: True if the outputs are bit-identical to streaming the clip + one frame per forward call, or the error if the batch is refused. + """ + hw = akida.Model(layers=ak_model.layers) + hw.map(device, mode=akida.MapMode.Minimal, hw_only=True) + try: + batch_out = hw.forward(clip) + except Exception as e: # noqa: BLE001 - report whatever the device raises + return f'refused ({type(e).__name__}: {e})' + return np.array_equal(batch_out, stream(ak_model, clip)) + + +if __name__ == '__main__': + parser = argparse.ArgumentParser( + description='Akida 2 hardware benchmark for the Jester TENN model') + parser.add_argument('-m', '--models-dir', default=None, + help='Directory holding the Akida model. Defaults to pretrained_models/.') + parser.add_argument('-d', '--data', default=None, + help='Jester directory. Defaults to the BrainChip Jester subset, ' + 'downloaded into data/.') + parser.add_argument('--save-metrics', action='store_true', + help='Write benchmark values to docs/metrics.json') + args = parser.parse_args() + + # ------------------------------------------------------------------------- + # Model + # ------------------------------------------------------------------------- + loadmodel = model_path('akida', args.models_dir) + if args.models_dir is None: + verify_model(loadmodel) + print(f'Benchmarking {loadmodel.name}') + model_stem = loadmodel.stem + + ak_model = akida.Model(str(loadmodel)) + + # ------------------------------------------------------------------------- + # Device + # ------------------------------------------------------------------------- + device = get_akida_device(target_version=ak_model.ip_version) + if device is None: + print("No compatible Akida hardware device found. Skipping benchmarking") + sys.exit(0) + + # ------------------------------------------------------------------------- + # Sample + # ------------------------------------------------------------------------- + # Processing in Akida is activity dependent (because it exploits sparsity) + # and that activity is dependent on the input. That makes it imperative to + # use real inputs when benchmarking Akida, rather than synthetic random + # samples. For a streaming model the frames must also come in order. + samples = get_stream(get_data_dir(args.data), NUM_CLIPS) + num_frames = len(samples) + print(f'Stream of {NUM_CLIPS} clips: {num_frames} frames {samples.shape[1:]}') + + match = check_hw_matches_sw(ak_model, device, samples[:FRAMES_PER_CLIP]) + print(f'Hardware streams a clip bit-identically to the software backend: {match}') + if not match: + sys.exit('Hardware and software outputs differ - not benchmarking.') + batch_as_time = check_batch_as_time(ak_model, device, samples[:FRAMES_PER_CLIP]) + print(f'Hardware gives the same outputs for a clip forwarded as one batch: {batch_as_time}') + + # ------------------------------------------------------------------------- + # Full-model benchmark (latency only): one forward call per frame + # ------------------------------------------------------------------------- + map_modes = ['Minimal', 'AllNps', 'HwPr'] + full_results = dict() + for mm in map_modes: + map_mode = getattr(akida.MapMode, mm) + print(f'\nRunning full-model benchmark (MapMode={mm})...') + res = full_model_benchmark(ak_model, device, samples, + map_mode=map_mode, + batch_size=1, + clock_freq=MEASURED_CLOCK) + if res is None: + # full_model_benchmark returns None when the model does not map + # fully onto the device in this mode. + print(f' MapMode={mm} did not map to hardware - skipping this mode.') + continue + + # Projected latency at a higher target clock. Cycle count (mean_inf_clk) + # is clock-independent, so this is an exact rescale, not an estimate of + # host overhead. + res['projected_clk_ms'] = res['mean_inf_clk'] / PROJECTED_CLOCK * 1000 + full_results[mm] = res + + # Re-map without hw_only to populate ak_model.sequences for stats + ak_model.map(device, mode=map_mode) + num_nps, num_passes, num_sequences = get_mapping_stats(ak_model) + full_results[mm]['num_nps'] = num_nps + full_results[mm]['num_passes'] = num_passes + print(f' Mapping: {num_nps} NP(s), {num_passes} pass(es), {num_sequences} sequence(s)') + print(f' Measured latency per frame @ {MEASURED_CLOCK/1e6:.0f} MHz: ' + f'{res["mean_clk_ms"]:.3f} ms') + print(f' Projected latency per frame @ {PROJECTED_CLOCK/1e6:.0f} MHz: ' + f'{res["projected_clk_ms"]:.3f} ms') + + if not full_results: + sys.exit(f'{loadmodel.name} does not fit onto {device.desc} in a single ' + 'hardware sequence in any mode. Nothing to benchmark.') + + # ------------------------------------------------------------------------- + # Full-model plot and metrics + # ------------------------------------------------------------------------- + # Map without hw_only so ak_model.sequences is available for plot_mapping. + ak_model.map(device, mode=akida.MapMode.Minimal) + full_savepath = f'benchmark_results_full_{model_stem}.png' + if args.save_metrics: + full_savepath = pathlib.Path(__file__).parent / 'docs' / ('ref_' + full_savepath) + plot_full_model_results(full_results, ak_model, device, + model_name=loadmodel.name, + example='Jester TENN (Akida 2)', + savepath=full_savepath, + show_power=False) # no power measurement on the FPGA + print('Full model results plot saved to ' + str(full_savepath)) + + if args.save_metrics: + # Updates the stored metrics used to generate the README performance + # tables. For code maintenance only, run against the pretrained model. + # Sparsity is recorded by jester_eval.py, and the FPGA has no power + # measurement. + metrics_path = pathlib.Path(__file__).parent / 'docs' / 'metrics.json' + metrics = json.loads(metrics_path.read_text()) if metrics_path.exists() else {} + for mm, res in full_results.items(): + mode = mm.lower() + metrics[f'w8a8_{mode}_nps'] = str(res['num_nps']) + metrics[f'w8a8_{mode}_passes'] = str(res['num_passes']) + metrics[f'w8a8_{mode}_cycles'] = f'{res["mean_inf_clk"]:.0f}' + metrics[f'w8a8_{mode}_latency_ms'] = f'{res["mean_clk_ms"]:.3f}' + metrics[f'w8a8_{mode}_projected_ms'] = f'{res["projected_clk_ms"]:.3f}' + metrics_path.write_text(json.dumps(metrics, indent=4, sort_keys=True) + '\n') + print(f'Metrics saved to {metrics_path}') + + # ------------------------------------------------------------------------- + # Per-layer benchmark. Minimal mapping mode, one frame per inference + # ------------------------------------------------------------------------- + ak_model.map(device, mode=akida.MapMode.Minimal, hw_only=True) + ak_model.summary() + + # Check sparsity per-layer (for the plot only, see above), streaming the frames + # in order from empty buffers, one per forward call. Runs on the software backend. + sparsity_dict = stream_sparsity(ak_model, samples) + pretty_print_sparsity(sparsity_dict) + + # Each sub-model is timed on the frames in stream order, so its buffers fill + # as they would in the full model. + print(f'Running per-layer benchmark ({num_frames} frames)...') + per_layer_results = per_layer_benchmark(ak_model, device, samples, + repeats=num_frames, + clock_freq=MEASURED_CLOCK) + + ak_model.map(device, mode=akida.MapMode.Minimal) + perlayer_savepath = f'benchmark_results_layers_{model_stem}.png' + if args.save_metrics: + perlayer_savepath = pathlib.Path(__file__).parent / 'docs' / ('ref_' + perlayer_savepath) + plot_per_layer_results(per_layer_results, ak_model, sparsity_dict, + model_name=loadmodel.name, + example='Jester TENN (Akida 2)', + savepath=perlayer_savepath) + print('\nPer-layer results plot saved to ' + str(perlayer_savepath)) diff --git a/akida2/model_zoo/jester/jester_data.py b/akida2/model_zoo/jester/jester_data.py new file mode 100644 index 0000000..b84aebf --- /dev/null +++ b/akida2/model_zoo/jester/jester_data.py @@ -0,0 +1,217 @@ +#!/usr/bin/env python +# Copyright 2026 Brainchip Holdings Ltd. Apache 2.0 License +""" +Data loading for the Jester TENN example (Akida 2). + +Two sources, both mirrored by BrainChip and downloaded on first use into +``data/`` (git-ignored): + +* **The BrainChip Jester subset** (:data:`SUBSET_URL`, about 100 MB): one TFRecord + shard of the Jester validation split, 541 clips covering all 27 classes, plus the + label and split CSV files. The accuracy figures in the README are measured on it; + it is not the full validation split. :func:`get_data` reads it, or any directory + with the same layout, so the full validation set can be dropped in with ``-d``:: + + /jester-v1-labels.csv + /tfrecords/*validation* GZIP TFRecords, one SequenceExample per clip + +* **The calibration pack** (:data:`CALIBRATION_URL`): 100 clips of 16 frames from + the Jester train split, stored as one ``(1600, 100, 100, 3)`` uint8 array in + clip order. It is the file BrainChip calibrated the published 8-bit model on. + +Labels are integer class indices in [0, 26], in the order of +``jester-v1-labels.csv``. + +Run as a script to check that ``jester_preprocessing`` is bit-identical to the +``akida_models`` pipeline over every clip of a dataset directory:: + + python jester_data.py --check-preprocessing +""" +import argparse +import csv +import os +import pathlib +from glob import glob + +import numpy as np +import tensorflow as tf +from akida_models.utils import fetch_file + +from jester_preprocessing import (FRAMES_PER_CLIP, FRAME_SIZE, parse_sequence_example, + decode_clip) + +__all__ = ["NUM_CLASSES", "SUBSET_URL", "CALIBRATION_URL", "get_data_dir", "read_labels", + "count_clips", "get_data", "get_clips", "get_stream", "get_calibration_path", + "get_calibration_samples", "check_preprocessing"] + +NUM_CLASSES = 27 + +SUBSET_URL = "https://data.brainchip.com/dataset-mirror/jester/jester_subset.tar.gz" +SUBSET_SHA256 = "af55f22ead4e2ca086038043457400b97a447f3796fb9c78ef4c497250e6155b" +CALIBRATION_URL = ("https://data.brainchip.com/dataset-mirror/samples/jester_video/" + "jester_video_bs100.npz") +CALIBRATION_SHA256 = "d0ba505971075dc8bd2e0b0fecf4c301e775cdcf1a06e2e7713513303575309a" +# The calibration pack holds this many clips; quantization must be told so (batch_size) +CALIBRATION_CLIPS = 100 + +DATA_DIR = pathlib.Path(__file__).parent / 'data' + + +def get_data_dir(data_path=None): + """Returns the dataset directory, downloading the BrainChip subset if none is given. + + Args: + data_path (str, optional): a Jester directory (see the module docstring). + If None, the BrainChip Jester subset is downloaded into ``data/`` on + first use. + + Returns: + str: the dataset directory. + """ + if data_path: + return str(data_path) + data_dir = DATA_DIR.resolve() / 'jester_subset' + # fetch_file re-extracts the archive on every call, so only call it when the + # extracted subset is missing. + if not (data_dir / '.extracted').exists(): + fetch_file(SUBSET_URL, fname='jester_subset.tar.gz', file_hash=SUBSET_SHA256, + cache_subdir=str(DATA_DIR.resolve()), extract=True) + (data_dir / '.extracted').touch() + return str(data_dir) + + +def read_labels(data_dir): + """Returns the 27 class names, in label-index order.""" + with open(os.path.join(data_dir, 'jester-v1-labels.csv')) as f: + return [row[0] for row in csv.reader(f)] + + +def _records(data_dir): + filenames = sorted(glob(os.path.join(data_dir, 'tfrecords', '*validation*'))) + if not filenames: + raise FileNotFoundError(f'No validation TFRecords under {data_dir}/tfrecords') + return tf.data.TFRecordDataset(filenames, compression_type='GZIP') + + +def count_clips(data_dir): + """Counts the clips in the validation TFRecords. + + The count comes from the records themselves: ``jester-v1-validation.csv`` + lists the whole validation split, even in the subset. + """ + return int(_records(data_dir).reduce(np.int64(0), lambda n, _: n + 1)) + + +def _decode(example): + frames, label, frame_count = parse_sequence_example(example) + return decode_clip(frames, frame_count), tf.cast(label, tf.int32) + + +def get_data(data_dir, batch_size=32): + """Loads the validation clips as a batched tf.data pipeline. + + Args: + data_dir (str): dataset directory (see :func:`get_data_dir`). + batch_size (int, optional): clips per batch. Defaults to 32. + + Returns: + tuple: the dataset, yielding (clips, labels) with clips of shape + (B, 16, 100, 100, 3) uint8 and labels of shape (B,) int32, and the number + of clips. + """ + dataset = _records(data_dir).map(_decode, num_parallel_calls=tf.data.AUTOTUNE) + return dataset.batch(batch_size).prefetch(tf.data.AUTOTUNE), count_clips(data_dir) + + +def get_clips(data_dir, num_clips, one_per_class=False): + """Returns clips as numpy arrays. + + Args: + data_dir (str): dataset directory. + num_clips (int): number of clips to return. + one_per_class (bool, optional): take the first clip of each class in turn + rather than the first ``num_clips`` clips. Defaults to False. + + Returns: + tuple: clips (N, 16, 100, 100, 3) uint8 and labels (N,) int. + """ + clips, labels, seen = [], [], set() + for clip, label in _records(data_dir).map(_decode): + label = int(label) + if one_per_class and label in seen: + continue + seen.add(label) + clips.append(clip.numpy()) + labels.append(label) + if len(clips) == num_clips: + break + return np.stack(clips), np.array(labels) + + +def get_stream(data_dir, num_clips): + """Returns consecutive clips as one frame stream, for the hardware benchmark. + + Returns: + np.ndarray: (num_clips * 16, 100, 100, 3) uint8 frames, clip after clip. + """ + clips, _ = get_clips(data_dir, num_clips) + return clips.reshape(-1, *clips.shape[2:]) + + +def get_calibration_path(): + """Returns the path of the calibration pack, downloading it into ``data/`` on first use.""" + return fetch_file(CALIBRATION_URL, fname='jester_video_bs100.npz', + file_hash=CALIBRATION_SHA256, cache_subdir=str(DATA_DIR.resolve())) + + +def get_calibration_samples(): + """Returns the calibration pack, downloading it into ``data/`` on first use. + + Returns: + np.ndarray: (1600, 100, 100, 3) uint8 frames: 100 train clips of 16 frames, + clip after clip. + """ + with np.load(get_calibration_path()) as data: + return np.concatenate([data[k] for k in data.files]) + + +def check_preprocessing(data_dir): + """Asserts that jester_preprocessing matches akida_models over every clip. + + Returns: + int: the number of clips compared. + """ + from akida_models.tenn_spatiotemporal.jester_train import get_data as reference_get_data + + reference, _ = reference_get_data('val', data_dir, FRAMES_PER_CLIP, FRAME_SIZE, + batch_size=1) + ours = _records(data_dir).map(_decode) + n = 0 + for (ref_clip, ref_onehot), (clip, label) in zip(reference, ours): + assert np.array_equal(ref_clip.numpy()[0], clip.numpy()), f'clip {n} differs' + assert int(np.argmax(ref_onehot[0])) == int(label), f'label {n} differs' + n += 1 + assert n == count_clips(data_dir), 'the pipelines yield different clip counts' + return n + + +if __name__ == '__main__': + parser = argparse.ArgumentParser(description='Jester data utilities') + parser.add_argument('-d', '--data', default=None, + help='Jester directory. Defaults to the BrainChip subset, ' + 'downloaded into data/.') + parser.add_argument('--check-preprocessing', action='store_true', + help='Check jester_preprocessing against akida_models') + parser.add_argument('--fetch-calibration', action='store_true', + help='Download the calibration pack and print its path') + args = parser.parse_args() + + if args.fetch_calibration: + print(get_calibration_path()) + raise SystemExit + + data_dir = get_data_dir(args.data) + print(f'{data_dir}: {count_clips(data_dir)} clips, {len(read_labels(data_dir))} classes') + if args.check_preprocessing: + print(f'Preprocessing bit-identical to akida_models over ' + f'{check_preprocessing(data_dir)} clips') diff --git a/akida2/model_zoo/jester/jester_eval.py b/akida2/model_zoo/jester/jester_eval.py new file mode 100644 index 0000000..a680633 --- /dev/null +++ b/akida2/model_zoo/jester/jester_eval.py @@ -0,0 +1,223 @@ +#!/usr/bin/env python +# Copyright 2026 Brainchip Holdings Ltd. Apache 2.0 License +""" +Evaluation of the Jester TENN model on Akida 2. + +Evaluates one of the three variants (see ``jester_model.py``): + + float the Conv3D Keras model, run on whole 16-frame clips + quantized the 8-bit buffered Keras model, streamed one frame at a time + akida the converted Akida model, streamed one frame at a time on the + software backend + +Each variant produces one prediction per frame, and two accuracies are reported +from them: + +* **Clip accuracy** (the headline figure): one decision per clip, from the + per-frame softmax outputs accumulated over the clip with a decay of 0.8, so + that recent frames count most. This is how BrainChip's + ``evaluate_bufferized_model`` scores the quantized and Akida models. +* **Frame accuracy**: every frame's own prediction, scored against the clip's + label, as the ``TemporalAccuracy`` metric BrainChip trains with does. It is + lower because the first frames of a clip have seen little of the gesture yet. + +Streaming means the buffers carry state from frame to frame, so they are reset +at the start of every clip. For the Akida variant it also measures the mean +activation sparsity, which needs no hardware. + +Examples +-------- + # BrainChip Jester subset (downloaded into data/ on first use) + python jester_eval.py --variant akida + + # Quick check on the first 32 clips + python jester_eval.py --variant quantized -n 32 +""" +import argparse +import json +import pathlib + +import numpy as np +import tensorflow as tf +from scipy.special import softmax +from tqdm import tqdm + +import akida +from akida_models.model_io import load_model +from quantizeml.models import reset_buffers + +from jester_data import get_data, get_data_dir, get_clips +from jester_model import VARIANTS, model_path, verify_model + +# Weight of the accumulated past predictions at each new frame (evaluate_bufferized_model) +DECAY = 0.8 +# Clips used to measure activation sparsity: the first clip of each class +SPARSITY_CLIPS = 27 + + +def score(frame_logits, labels): + """Scores the per-frame predictions of a batch of clips. + + Args: + frame_logits (np.ndarray): (B, T, C) logits, one row per frame, in order. + labels (np.ndarray): (B,) integer labels. + + Returns: + tuple: (correct clips, correct frames), for B clips and B * T frames. + """ + accumulated = np.zeros((frame_logits.shape[0], frame_logits.shape[2])) + for t in range(frame_logits.shape[1]): + accumulated = accumulated * DECAY + softmax(frame_logits[:, t], axis=-1) + clips = int(np.sum(accumulated.argmax(-1) == labels)) + frames = int(np.sum(frame_logits.argmax(-1) == labels[:, None])) + return clips, frames + + +def float_frame_logits(model): + """Per-frame logits of the float model: it sees the whole clip at once.""" + model_fn = tf.function(model) + return lambda clips: model_fn(clips).numpy().reshape(clips.shape[0], clips.shape[1], -1) + + +def quantized_frame_logits(model): + """Per-frame logits of the buffered Keras model, streaming each clip frame by frame.""" + model_fn = tf.function(model) + + def run(clips): + reset_buffers(model) # a new batch of clips: forget the previous frames + return np.stack([model_fn(clips[:, t]).numpy() for t in range(clips.shape[1])], 1) + return run + + +def stream(model, clip): + """Outputs of an Akida model streaming one clip frame by frame, from empty buffers. + + An akida.Model has no buffer reset: a new model built from the same layers + starts with empty buffers, so one is built per clip. Each frame is its own + forward call, as in BrainChip's evaluate_bufferized_model. + """ + streaming = akida.Model(layers=model.layers) + return np.concatenate([streaming.forward(clip[t:t + 1]) for t in range(len(clip))]) + + +def akida_frame_logits(model): + """Per-frame logits of the Akida model, streaming each clip frame by frame.""" + def run(clips): + return np.stack([stream(model, clip).reshape(len(clip), -1) for clip in clips]) + return run + + +def evaluate(frame_logits_fn, dataset, num_clips=None, desc='Evaluating'): + """Runs a variant over the dataset. + + Returns: + dict: ``clip_acc``, ``frame_acc`` and ``n`` (clips evaluated). + """ + correct_clips = correct_frames = clips_seen = frames_seen = 0 + for clips, labels in tqdm(dataset, desc=desc): + clips, labels = clips.numpy(), labels.numpy() + if num_clips is not None: + clips, labels = clips[:num_clips - clips_seen], labels[:num_clips - clips_seen] + c, f = score(frame_logits_fn(clips), labels) + correct_clips += c + correct_frames += f + clips_seen += len(labels) + frames_seen += clips.shape[0] * clips.shape[1] + if num_clips is not None and clips_seen >= num_clips: + break + return {'clip_acc': correct_clips / clips_seen, 'frame_acc': correct_frames / frames_seen, + 'n': clips_seen} + + +def stream_sparsity(model, frames): + """Per-layer activation sparsity of an Akida model streaming frames in order. + + Like ``akida_models.sparsity.compute_sparsity``, but each frame is its own + forward call. The model is sequential, so each layer's output comes from the + sub-model that ends at it, streamed from empty buffers. Same layers as + ``compute_sparsity``: all but InputData, Quantizer and Dequantizer. + """ + skip = (akida.LayerType.InputData, akida.LayerType.Quantizer, akida.LayerType.Dequantizer) + results = {} + for i, layer in enumerate(model.layers): + if layer.parameters.layer_type in skip: + continue + output = stream(akida.Model(layers=model.layers[:i + 1]), frames) + results[layer.name] = np.count_nonzero(output == 0) / output.size + return results + + +def akida_sparsity(model, data_dir, num_clips=SPARSITY_CLIPS): + """Mean activation sparsity of the Akida model, streaming real clips. + + Each clip starts from empty buffers. Returns the per-layer sparsity averaged + over clips, and its mean. + """ + clips, _ = get_clips(data_dir, num_clips, one_per_class=True) + per_clip = [stream_sparsity(model, clip) for clip in clips] + per_layer = {name: float(np.mean([s[name] for s in per_clip])) for name in per_clip[0]} + return per_layer, float(np.mean(list(per_layer.values()))) + + +if __name__ == '__main__': + parser = argparse.ArgumentParser(description='Evaluate the Jester TENN model for Akida 2') + parser.add_argument('--variant', default='akida', choices=VARIANTS, + help='Model variant to evaluate. Defaults to %(default)s.') + parser.add_argument('-m', '--models-dir', default=None, + help='Directory holding the models. Defaults to pretrained_models/.') + parser.add_argument('-d', '--data', default=None, + help='Jester directory. Defaults to the BrainChip Jester subset, ' + 'downloaded into data/.') + parser.add_argument('-b', '--batch-size', type=int, default=32, + help='Clips per batch (Keras variants). Defaults to %(default)s.') + parser.add_argument('-n', '--num-clips', type=int, default=None, + help='Evaluate only the first N clips') + parser.add_argument('--save-metrics', action='store_true', + help='Write accuracy (and sparsity/params) to docs/metrics.json') + args = parser.parse_args() + + if args.save_metrics and args.num_clips is not None: + raise SystemExit('--save-metrics records whole-dataset runs only: drop -n.') + + path = model_path(args.variant, args.models_dir) + if args.models_dir is None: + verify_model(path) + print(f'Evaluating {path.name}') + + if args.variant == 'akida': + model = akida.Model(str(path)) + frame_logits_fn = akida_frame_logits(model) + batch_size = 1 + else: + model = load_model(str(path)) + frame_logits_fn = (float_frame_logits if args.variant == 'float' + else quantized_frame_logits)(model) + batch_size = args.batch_size + + data_dir = get_data_dir(args.data) + dataset, num_clips = get_data(data_dir, batch_size) + print(f'{data_dir}: {num_clips} clips') + result = evaluate(frame_logits_fn, dataset, args.num_clips, desc=f'Evaluating {args.variant}') + print(f'\n{args.variant} over {result["n"]} clips: clip accuracy ' + f'{result["clip_acc"] * 100:.2f}%, frame accuracy {result["frame_acc"] * 100:.2f}%') + + sparsity = None + if args.variant == 'akida': + _, sparsity = akida_sparsity(model, data_dir) + print(f'Mean activation sparsity ({SPARSITY_CLIPS} clips): {sparsity * 100:.2f}%') + + if args.save_metrics: + # Used to update the stored metrics behind the README tables. This is a + # maintenance step, run when the models or the pipeline change. + metrics_path = pathlib.Path(__file__).parent / 'docs' / 'metrics.json' + metrics = json.loads(metrics_path.read_text()) if metrics_path.exists() else {} + prefix = {'float': 'float', 'quantized': 'w8a8_quant', 'akida': 'w8a8_akida'}[args.variant] + metrics[f'{prefix}_clip_acc'] = f'{result["clip_acc"] * 100:.2f}%' + metrics[f'{prefix}_frame_acc'] = f'{result["frame_acc"] * 100:.2f}%' + metrics[f'{prefix}_n'] = str(result['n']) + if sparsity is not None: + metrics['w8a8_sparsity'] = f'{sparsity * 100:.2f}%' + if args.variant == 'float': + metrics['params'] = f'{model.count_params():,}' + metrics_path.write_text(json.dumps(metrics, indent=4, sort_keys=True) + '\n') + print(f'Metrics saved to {metrics_path}') diff --git a/akida2/model_zoo/jester/jester_eval.sh b/akida2/model_zoo/jester/jester_eval.sh new file mode 100644 index 0000000..902e029 --- /dev/null +++ b/akida2/model_zoo/jester/jester_eval.sh @@ -0,0 +1,46 @@ +#!/usr/bin/env bash +# Copyright 2026 Brainchip Holdings Ltd. Apache 2.0 License +# +# Evaluate the published float Jester TENN model, quantize it as BrainChip did, +# check the result against the published 8-bit model, convert it to Akida, and +# evaluate both. +# +# Usage: +# bash jester_eval.sh [DATADIR] +# +# DATADIR Jester directory (default: the BrainChip Jester subset, downloaded +# into data/) +# +# There is no training stage: the float model is BrainChip's published model. +# Its training recipe is train_spatiotemporal_jester.sh, quoted in the README. +# This script reproduces the steps after training into models/. The models in +# pretrained_models/ are the published ones, and the benchmark uses those. + +set -e + +DATADIR="${1:-}" +DATA_ARG=${DATADIR:+-d "$DATADIR"} +NAME=tenn_spatiotemporal_jester + +# 1. Evaluate the float model: whole 16-frame clips at once +python jester_eval.py --variant float $DATA_ARG + +# 2. 8-bit quantization, as in train_spatiotemporal_jester.sh: 8-bit weights +# (input layer included) and activations, per-tensor activation scales, uint8 +# input, calibrated for one epoch on BrainChip's pack of 100 train clips +# (-bs 100: one batch row per clip) +CALIBRATION=$(python jester_data.py --fetch-calibration | tail -n 1) +mkdir -p models +quantizeml quantize -m pretrained_models/${NAME}.h5 -w 8 -i 8 -a 8 \ + --per_tensor_activations -id uint8 -e 1 -bs 100 -sa "$CALIBRATION" \ + -s models/${NAME}_buffer_i8_w8_a8.h5 + +# 3. Compare with the published 8-bit model, then evaluate it: streamed frame +# by frame, buffers reset per clip +python jester_model.py --compare models/${NAME}_buffer_i8_w8_a8.h5 +python jester_eval.py --variant quantized -m models $DATA_ARG + +# 4. Convert to Akida, then evaluate it on the software backend and measure its +# activation sparsity +cnn2snn convert -m models/${NAME}_buffer_i8_w8_a8.h5 +python jester_eval.py --variant akida -m models $DATA_ARG diff --git a/akida2/model_zoo/jester/jester_model.py b/akida2/model_zoo/jester/jester_model.py new file mode 100644 index 0000000..9920a3c --- /dev/null +++ b/akida2/model_zoo/jester/jester_model.py @@ -0,0 +1,182 @@ +#!/usr/bin/env python +# Copyright 2026 Brainchip Holdings Ltd. Apache 2.0 License +""" +Model files, quantization and the reproduction check for the Jester TENN example. + +**The models.** BrainChip's published TENN spatiotemporal model for Jester, in +three variants, stored in ``pretrained_models/`` (Git LFS): + + float ``tenn_spatiotemporal_jester.h5``: the trained Keras model, built + from ``Conv3D`` layers. It takes a whole clip, (16, 100, 100, 3), + and returns one prediction per frame, (16, 1, 1, 27). + quantized ``tenn_spatiotemporal_jester_buffer_i8_w8_a8.h5``: the 8-bit + model. Quantization replaces each temporal ``Conv3D`` with a + ``BufferTempConv`` (or ``DepthwiseBufferTempConv``), which keeps the + last 5 frames' inputs in a FIFO buffer, and each spatial ``Conv3D`` + with a 2D convolution. The model takes one frame, (100, 100, 3), and + returns one prediction, (27,). + akida ``tenn_spatiotemporal_jester_buffer_i8_w8_a8.fbz``: the 8-bit model + converted by ``cnn2snn convert``, which names its output after its + input. + +The ``.h5`` files are the ones ``akida_models.tenn_spatiotemporal_jester_pretrained`` +downloads. :func:`verify_model` checks each file against its sha256 +(:data:`SHA256`), which also catches a Git LFS pointer that was never pulled. + +**Quantization.** :func:`quantize_float_model` repeats BrainChip's quantization +step, the ``quantizeml quantize`` call in ``train_spatiotemporal_jester.sh``, with +the same parameters and calibration pack. :func:`compare_models` checks the result +against the published 8-bit model. Run as a script:: + + python jester_model.py --compare models/tenn_spatiotemporal_jester_buffer_i8_w8_a8.h5 +""" +import argparse +import hashlib +import pathlib + +import numpy as np +from cnn2snn import convert +from quantizeml.models import QuantizationParams, quantize + +__all__ = ["VARIANTS", "PRETRAINED_DIR", "SHA256", "model_path", "verify_model", + "quantization_params", "quantize_float_model", "compare_models"] + +VARIANTS = ("float", "quantized", "akida") +PRETRAINED_DIR = pathlib.Path(__file__).parent / 'pretrained_models' + +_FILENAMES = { + 'float': 'tenn_spatiotemporal_jester.h5', + 'quantized': 'tenn_spatiotemporal_jester_buffer_i8_w8_a8.h5', + 'akida': 'tenn_spatiotemporal_jester_buffer_i8_w8_a8.fbz', +} + +# sha256 of the published files (float and quantized as served by data.brainchip.com, +# akida as converted from the quantized model with cnn2snn 2.19.1) +SHA256 = { + 'tenn_spatiotemporal_jester.h5': + '5950e4d188cbda893c19c47d0a6e9e5c6200f902bb72f64d155d3e7a6f85816f', + 'tenn_spatiotemporal_jester_buffer_i8_w8_a8.h5': + '388f0e312499190ed2cc839fb4c4e6c791e54e5ee4d35736f33fc36acae24015', + 'tenn_spatiotemporal_jester_buffer_i8_w8_a8.fbz': + '058e6c8de86330f564730e62b4cf88813926becabfc5fef8abacdeff85972469', +} + + +def model_path(variant='quantized', models_dir=None): + """Returns the path of a model file. + + Args: + variant (str, optional): 'float', 'quantized' or 'akida'. Defaults to + 'quantized'. + models_dir (str, optional): directory holding the models. Defaults to + this example's ``pretrained_models/``. + + Returns: + pathlib.Path: path to the model file. + """ + if variant not in VARIANTS: + raise ValueError(f'variant must be one of {VARIANTS}, received {variant}') + directory = pathlib.Path(models_dir) if models_dir else PRETRAINED_DIR + return directory / _FILENAMES[variant] + + +def verify_model(path): + """Checks a published model file against its sha256 pin. + + Raises: + FileNotFoundError: if the file is missing. + ValueError: if its hash differs, e.g. a Git LFS pointer that was never pulled. + """ + path = pathlib.Path(path) + if not path.exists(): + raise FileNotFoundError(f'{path} not found. These models are tracked with Git LFS - ' + 'run `git lfs pull` to fetch them.') + digest = hashlib.sha256(path.read_bytes()).hexdigest() + if digest != SHA256[path.name]: + raise ValueError(f'{path.name}: sha256 {digest} does not match the published file. ' + 'If it is a Git LFS pointer, run `git lfs pull`.') + + +def quantization_params(): + """The QuantizationParams of ``quantizeml quantize -w 8 -i 8 -a 8 + --per_tensor_activations -id uint8``: 8-bit weights (input layer included) + and activations, one scale per activation tensor rather than per channel, + and uint8 input. The other defaults (8-bit outputs, 32-bit buffers) match the + CLI's. + """ + return QuantizationParams(input_weight_bits=8, weight_bits=8, activation_bits=8, + per_tensor_activations=True, input_dtype='uint8') + + +def quantize_float_model(model, samples, num_clips=100, epochs=1): + """Quantizes the float model as BrainChip did, with ``-e 1 -bs 100``. + + The calibration samples are frames in clip order, (num_clips * 16, 100, 100, 3). + For a spatiotemporal TENN, ``batch_size`` must be the number of clips: the + calibration uses it to cut the frames back into temporally coherent clips. + + Returns: + keras.Model: the quantized, buffered model, taking one frame at a time. + """ + return quantize(model, qparams=quantization_params(), samples=samples, + num_samples=len(samples), batch_size=num_clips, epochs=epochs) + + +def compare_models(reference, candidate): + """Compares two quantized models, structurally and as converted Akida models. + + Returns: + dict: ``same_structure`` (layer names, types and output shapes), + ``keras_diffs`` (Keras variables that differ, with their max absolute + difference) and ``akida_diffs`` (Akida layer variables that differ after + conversion: the integer weights and thresholds that run on the NPs, and + the float output scales). + """ + def signature(m): + return [(layer.name, type(layer).__name__, str(layer.output_shape)) + for layer in m.layers] + + ref_vars = {v.name: v.numpy() for v in reference.variables} + cand_vars = {v.name: v.numpy() for v in candidate.variables} + keras_diffs = {k: float(np.abs(ref_vars[k] - cand_vars[k]).max()) + for k in ref_vars.keys() & cand_vars.keys() + if not np.array_equal(ref_vars[k], cand_vars[k])} + + akida_diffs = {} + for ref_layer, cand_layer in zip(convert(reference).layers, convert(candidate).layers): + for name in ref_layer.variables.names: + a, b = ref_layer.variables[name], cand_layer.variables[name] + if a.shape != b.shape or not np.array_equal(a, b): + akida_diffs[f'{ref_layer.name}/{name}'] = ( + str(a.dtype), float(np.abs(a.astype(np.float64) - b).max())) + + return {'same_structure': (signature(reference) == signature(candidate) + and ref_vars.keys() == cand_vars.keys()), + 'keras_diffs': keras_diffs, + 'akida_diffs': akida_diffs} + + +def print_comparison(result): + """Prints a :func:`compare_models` result.""" + print(f'Same structure (layers, shapes, variables): {result["same_structure"]}') + print(f'Keras variables that differ: {len(result["keras_diffs"])}') + for name, diff in sorted(result['keras_diffs'].items()): + print(f' {name:60} max |diff| {diff:.3g}') + print(f'Akida variables that differ after conversion: {len(result["akida_diffs"])}') + for name, (dtype, diff) in sorted(result['akida_diffs'].items()): + print(f' {name:60} {dtype:8} max |diff| {diff:.3g}') + + +if __name__ == '__main__': + parser = argparse.ArgumentParser( + description='Check a quantized Jester model against the published one') + parser.add_argument('--compare', required=True, + help='Quantized model to compare, e.g. one written by jester_eval.sh') + args = parser.parse_args() + + from akida_models.model_io import load_model + + published = model_path('quantized') + verify_model(published) + print(f'Comparing {args.compare} with the published {published.name}') + print_comparison(compare_models(load_model(str(published)), load_model(args.compare))) diff --git a/akida2/model_zoo/jester/jester_notebook_benchmark.ipynb b/akida2/model_zoo/jester/jester_notebook_benchmark.ipynb new file mode 100644 index 0000000..c47953b --- /dev/null +++ b/akida2/model_zoo/jester/jester_notebook_benchmark.ipynb @@ -0,0 +1,593 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "c44fa543", + "metadata": {}, + "source": [ + "\"BrainChip\n", + "\n", + "# Hand Gesture Recognition (Jester) — Akida 2 Benchmark\n", + "\n", + "Run Time: ~35 minutes\n", + "\n", + "This notebook benchmarks BrainChip's **TENN spatiotemporal** model for hand gesture\n", + "recognition on **Jester**, on Akida 2 hardware. It measures the latency **per frame** in\n", + "each mapping mode, shows how the model maps onto the neural processors (NPs), and breaks\n", + "the time down layer by layer.\n", + "\n", + "The model is a streaming one: it takes one frame per inference and gives a prediction\n", + "every frame. So the latency that matters is that of a single frame, which is how far the\n", + "prediction lags behind the live video.\n", + "\n", + "For details on the model and the dataset, and on how the Akida model is produced, see the\n", + "neighboring README.md and jester_notebook_evaluation.ipynb.\n", + "\n", + "> **Note:** the hardware benchmark needs a physical Akida 2 FPGA. Every hardware cell is\n", + "> guarded, so the notebook runs end to end without one (on Colab, for instance), but those\n", + "> cells are skipped and no latency is measured." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "88f3d60b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Not running on Colab — nothing to do. (This step only matters for Colab; local runs already have everything they need.)\n" + ] + } + ], + "source": [ + "# Colab-only setup. Local users: ignore this cell - it does nothing for you.\n", + "import sys\n", + "if 'google.colab' in sys.modules:\n", + " !wget -q https://raw.githubusercontent.com/Brainchip-Inc/brainchip_devhub/main/akida2/model_zoo/jester/colab_setup.py\n", + "import colab_setup\n", + "colab_setup.setup()" + ] + }, + { + "cell_type": "markdown", + "id": "a242805b", + "metadata": {}, + "source": [ + "## Configuration\n", + "\n", + "`DATA_PATH = None` uses the BrainChip Jester subset, downloaded into `data/` on first use.\n", + "`NUM_CLIPS` sets how many consecutive clips are streamed through the model: each clip is\n", + "16 frames, and every frame is one timed inference." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "b0c97385", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import akida\n", + "\n", + "from brainchip_utils.hardware_utils import AKIDA_CLOCKS_HZ\n", + "\n", + "DATA_PATH = None # None: the BrainChip Jester subset, downloaded into data/\n", + "NUM_CLIPS = 10 # consecutive clips streamed by the benchmark (16 frames each)\n", + "\n", + "# Clocks: see brainchip_utils.hardware_utils.AKIDA_CLOCKS_HZ\n", + "MEASURED_CLOCK = AKIDA_CLOCKS_HZ['AKIDA2_FPGA'] # 25 MHz FPGA\n", + "PROJECTED_CLOCK = AKIDA_CLOCKS_HZ['AKD2500'] # 1 GHz target (pre-production)" + ] + }, + { + "cell_type": "markdown", + "id": "1891ed0a", + "metadata": {}, + "source": [ + "## Model\n", + "\n", + "The converted Akida model is included in this repo, at\n", + "`pretrained_models/tenn_spatiotemporal_jester_buffer_i8_w8_a8.fbz`. Like every model file\n", + "in the repo, it is stored with Git LFS. If you haven't set that up yet, see the\n", + "[Trained models](../../../README.md#trained-models) section of the top-level README.\n", + "`verify_model` checks the file against its published sha256, so a text pointer left by a\n", + "missing `git lfs pull` fails here with a clear message.\n", + "\n", + "To benchmark the model that `jester_eval.sh` writes to `models/` instead, use\n", + "`model_path('akida', 'models')` and skip `verify_model`." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d6fd00ec", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Model Summary \n", + "________________________________________________\n", + "Input shape Output shape Sequences Layers\n", + "================================================\n", + "[100, 100, 3] [1, 1, 27] 1 18 \n", + "________________________________________________\n", + "\n", + "_________________________________________________________________________\n", + "Layer (type) Output shape Kernel shape \n", + "\n", + "================== SW/input_conv-dequantizer (Software) =================\n", + "\n", + "input_conv (InputConv2D) [50, 50, 8] (3, 3, 3, 8) \n", + "_________________________________________________________________________\n", + "convt_full_1_0 (BufferTempConv) [50, 50, 20] (1, 1, 40, 20) \n", + "_________________________________________________________________________\n", + "convs_full_1_0 (Conv2D) [25, 25, 40] (3, 3, 20, 40) \n", + "_________________________________________________________________________\n", + "convt_full_2_0 (BufferTempConv) [25, 25, 80] (1, 1, 200, 80) \n", + "_________________________________________________________________________\n", + "convs_full_2_0 (Conv2D) [13, 13, 120] (3, 3, 80, 120) \n", + "_________________________________________________________________________\n", + "convt_full_3_0 (BufferTempConv) [13, 13, 160] (1, 1, 600, 160)\n", + "_________________________________________________________________________\n", + "convs_full_3_0 (Conv2D) [7, 7, 200] (3, 3, 160, 200)\n", + "_________________________________________________________________________\n", + "convt_dw_4_0 (DepthwiseBufferTempConv) [7, 7, 200] (1, 1, 5, 200) \n", + "_________________________________________________________________________\n", + "convt_pw_4_0 (Conv2D) [7, 7, 240] (1, 1, 200, 240)\n", + "_________________________________________________________________________\n", + "convs_dw_4_0 (DepthwiseConv2D) [4, 4, 240] (3, 3, 240, 1) \n", + "_________________________________________________________________________\n", + "convs_pw_4_0 (Conv2D) [4, 4, 280] (1, 1, 240, 280)\n", + "_________________________________________________________________________\n", + "convt_dw_5_0 (DepthwiseBufferTempConv) [4, 4, 280] (1, 1, 5, 280) \n", + "_________________________________________________________________________\n", + "convt_pw_5_0 (Conv2D) [4, 4, 320] (1, 1, 280, 320)\n", + "_________________________________________________________________________\n", + "convs_dw_5_0 (DepthwiseConv2D) [2, 2, 320] (3, 3, 320, 1) \n", + "_________________________________________________________________________\n", + "convs_pw_5_0 (Conv2D) [1, 1, 640] (1, 1, 320, 640)\n", + "_________________________________________________________________________\n", + "dense (Dense1D) [1, 1, 640] (640, 640) \n", + "_________________________________________________________________________\n", + "dense_1 (Dense1D) [1, 1, 27] (640, 27) \n", + "_________________________________________________________________________\n", + "dequantizer (Dequantizer) [1, 1, 27] N/A \n", + "_________________________________________________________________________\n" + ] + } + ], + "source": [ + "from jester_model import model_path, verify_model\n", + "\n", + "path = model_path('akida')\n", + "verify_model(path)\n", + "ak_model = akida.Model(str(path))\n", + "ak_model.summary()" + ] + }, + { + "cell_type": "markdown", + "id": "87840181", + "metadata": {}, + "source": [ + "## Device\n", + "\n", + "`get_akida_device` returns the first connected device whose IP version matches the\n", + "model's (Akida 2), or `None` if there isn't one. Without a device, the benchmark cells\n", + "below are skipped." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "5dc81345", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Target Akida device found\n", + "Akida device found: fpga-1766\n" + ] + } + ], + "source": [ + "from brainchip_utils.hardware_utils import get_akida_device\n", + "\n", + "device = get_akida_device(target_version=ak_model.ip_version)\n", + "if device is None:\n", + " print('No compatible Akida hardware device found - the benchmark will be skipped.')\n", + "else:\n", + " print('Akida device found:', device.desc)" + ] + }, + { + "cell_type": "markdown", + "id": "81867d64", + "metadata": {}, + "source": [ + "## Samples\n", + "\n", + "Akida is event-driven: computation scales with the number of non-zero activations, so\n", + "timings depend on the input and the benchmark must use real frames. For a streaming model\n", + "the frames must also come **in order**, so that the temporal buffers hold real history.\n", + "The samples are the frames of consecutive clips, one after the other. The buffers are not\n", + "reset between clips during timing, as in a continuous stream." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "e4f82cca", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading data from https://data.brainchip.com/dataset-mirror/jester/jester_subset.tar.gz.\n", + "105037345/105037345 [==============================] - 7s 0us/step\n", + "Download complete.\n", + "10 clips -> (160, 100, 100, 3) uint8\n" + ] + } + ], + "source": [ + "from jester_data import get_data_dir, get_stream\n", + "\n", + "samples = get_stream(get_data_dir(DATA_PATH), NUM_CLIPS)\n", + "print(f'{NUM_CLIPS} clips -> {samples.shape} {samples.dtype}')" + ] + }, + { + "cell_type": "markdown", + "id": "3fd57ec2", + "metadata": {}, + "source": [ + "## Hardware check\n", + "\n", + "Before timing, one clip is streamed frame by frame on the hardware and on the software\n", + "backend, each starting from empty buffers, and the outputs are compared. The software\n", + "backend is a bit-accurate simulation of the hardware, so the two should be identical." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "33723a5a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Bit-identical: True\n" + ] + } + ], + "source": [ + "from jester_benchmark import check_hw_matches_sw\n", + "\n", + "if device is not None:\n", + " print('Bit-identical:', check_hw_matches_sw(ak_model, device, samples[:16]))" + ] + }, + { + "cell_type": "markdown", + "id": "cbcc4261", + "metadata": {}, + "source": [ + "## Latency benchmark\n", + "\n", + "`full_model_benchmark` from [brainchip_utils/hardware_utils.py](../../../brainchip_utils/hardware_utils.py)\n", + "runs one forward call per frame, so its mean latency is the latency per frame. It times the\n", + "model in each mapping mode:\n", + "\n", + "- **Minimal** maps the model onto the fewest NPs.\n", + "- **AllNps** uses as many NPs as possible while keeping the minimum number of passes.\n", + "- **HwPr** (hardware partial reconfiguration) splits the model into more passes, so that\n", + " each layer can use more NPs, and reloads the weights between passes on every inference.\n", + "\n", + "The FPGA runs at **25 MHz**, so the latency **projected** to the 1 GHz AKD2500 target clock\n", + "is reported too: the cycle count of a model and mapping does not depend on the clock." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "a5859bc2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Power measurement not available: only supported on AKD1500 (IpVersion.v1).\n", + " Repeat 1/10 done.\n", + " Repeat 2/10 done.\n", + " Repeat 3/10 done.\n", + " Repeat 4/10 done.\n", + " Repeat 5/10 done.\n", + " Repeat 6/10 done.\n", + " Repeat 7/10 done.\n", + " Repeat 8/10 done.\n", + " Repeat 9/10 done.\n", + " Repeat 10/10 done.\n", + "\n", + " Mean inference time: 218.666 ms (σ=6.261 ms)\n", + " Mean on-chip time: 209.324 ms (5233100 clocks)\n", + " Total inferences run: 1600\n", + "[Minimal] 44 NPs, 2 passes: 209.324 ms per frame @ 25 MHz, 5.233 ms projected @ 1 GHz\n", + "Power measurement not available: only supported on AKD1500 (IpVersion.v1).\n", + " Repeat 1/10 done.\n", + " Repeat 2/10 done.\n", + " Repeat 3/10 done.\n", + " Repeat 4/10 done.\n", + " Repeat 5/10 done.\n", + " Repeat 6/10 done.\n", + " Repeat 7/10 done.\n", + " Repeat 8/10 done.\n", + " Repeat 9/10 done.\n", + " Repeat 10/10 done.\n", + "\n", + " Mean inference time: 218.460 ms (σ=6.260 ms)\n", + " Mean on-chip time: 209.118 ms (5227952 clocks)\n", + " Total inferences run: 1600\n", + "[AllNps] 45 NPs, 2 passes: 209.118 ms per frame @ 25 MHz, 5.228 ms projected @ 1 GHz\n", + "Power measurement not available: only supported on AKD1500 (IpVersion.v1).\n", + " Repeat 1/10 done.\n", + " Repeat 2/10 done.\n", + " Repeat 3/10 done.\n", + " Repeat 4/10 done.\n", + " Repeat 5/10 done.\n", + " Repeat 6/10 done.\n", + " Repeat 7/10 done.\n", + " Repeat 8/10 done.\n", + " Repeat 9/10 done.\n", + " Repeat 10/10 done.\n", + "\n", + " Mean inference time: 177.304 ms (σ=4.530 ms)\n", + " Mean on-chip time: 168.038 ms (4200946 clocks)\n", + " Total inferences run: 1600\n", + "[HwPr] 96 NPs, 5 passes: 168.038 ms per frame @ 25 MHz, 4.201 ms projected @ 1 GHz\n" + ] + } + ], + "source": [ + "from brainchip_utils.hardware_utils import full_model_benchmark, get_mapping_stats\n", + "\n", + "full_results = {}\n", + "if device is not None:\n", + " for mm in ['Minimal', 'AllNps', 'HwPr']:\n", + " map_mode = getattr(akida.MapMode, mm)\n", + " res = full_model_benchmark(ak_model, device, samples, map_mode=map_mode,\n", + " batch_size=1, clock_freq=MEASURED_CLOCK)\n", + " if res is None:\n", + " print(f'[{mm}] does not map onto this device - skipped')\n", + " continue\n", + " res['projected_clk_ms'] = res['mean_inf_clk'] / PROJECTED_CLOCK * 1000\n", + " ak_model.map(device, mode=map_mode)\n", + " res['num_nps'], res['num_passes'], _ = get_mapping_stats(ak_model)\n", + " full_results[mm] = res\n", + " print(f\"[{mm}] {res['num_nps']} NPs, {res['num_passes']} passes: \"\n", + " f\"{res['mean_clk_ms']:.3f} ms per frame @ 25 MHz, \"\n", + " f\"{res['projected_clk_ms']:.3f} ms projected @ 1 GHz\")" + ] + }, + { + "cell_type": "markdown", + "id": "47b14e7b", + "metadata": {}, + "source": [ + "The plot shows the NPs each layer uses in each mapping mode, and where the pass\n", + "boundaries fall." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "49acd59d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from brainchip_utils.plot_utils import plot_full_model_results\n", + "\n", + "if full_results:\n", + " ak_model.map(device, mode=akida.MapMode.Minimal)\n", + " plot_full_model_results(full_results, ak_model, device,\n", + " model_name=path.name, example='Jester TENN (Akida 2)',\n", + " show_power=False)" + ] + }, + { + "cell_type": "markdown", + "id": "1b01a347", + "metadata": {}, + "source": [ + "## Per-layer benchmark and sparsity\n", + "\n", + "`per_layer_benchmark` reconstructs the latency layer by layer, by timing cumulative\n", + "sub-models on the same frame stream and taking the differences. `stream_sparsity` (from\n", + "`jester_eval.py`) measures each layer's activation sparsity over the stream, one frame per\n", + "call. Sparsity is computed on the software backend, so it is available without a device too." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "529d2ee2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Layer Sparsity\n", + "---------------------------\n", + "input_conv 34.78%\n", + "convt_full_1_0 42.60%\n", + "convs_full_1_0 43.50%\n", + "convt_full_2_0 66.67%\n", + "convs_full_2_0 71.69%\n", + "convt_full_3_0 74.46%\n", + "convs_full_3_0 72.29%\n", + "convt_dw_4_0 59.18%\n", + "convt_pw_4_0 50.23%\n", + "convs_dw_4_0 45.46%\n", + "convs_pw_4_0 66.39%\n", + "convt_dw_5_0 45.42%\n", + "convt_pw_5_0 55.23%\n", + "convs_dw_5_0 39.59%\n", + "convs_pw_5_0 92.23%\n", + "dense 99.13%\n", + "dense_1 0.00%\n", + "---------------------------\n", + "Mean 56.40%\n", + "\n", + "Layer Latency (ms) Clocks\n", + "------------------------------------\n", + "input_conv 0.8198\n", + "convt_full_1_0 20.8465\n", + "convs_full_1_0 40.3146\n", + "convt_full_2_0 43.0287\n", + "convs_full_2_0 38.2751\n", + "convt_full_3_0 16.8656\n", + "convs_full_3_0 13.8589\n", + "convt_dw_4_0 4.2128\n", + "convt_pw_4_0 6.6899\n", + "convs_dw_4_0 0.9064\n", + "convs_pw_4_0 3.1849\n", + "convt_dw_5_0 2.1664\n", + "convt_pw_5_0 3.9962\n", + "convs_dw_5_0 0.4873\n", + "convs_pw_5_0 5.2722\n", + "dense 7.5123\n", + "dense_1 0.5103\n", + "dequantizer 0.0262\n", + "------------------------------------\n", + "Total 208.9744\n" + ] + } + ], + "source": [ + "from brainchip_utils.hardware_utils import per_layer_benchmark\n", + "from brainchip_utils.plot_utils import pretty_print_sparsity\n", + "from jester_eval import stream_sparsity\n", + "\n", + "sparsity_dict = stream_sparsity(ak_model, samples)\n", + "pretty_print_sparsity(sparsity_dict)\n", + "\n", + "per_layer_results = None\n", + "if full_results:\n", + " ak_model.map(device, mode=akida.MapMode.Minimal, hw_only=True)\n", + " per_layer_results = per_layer_benchmark(ak_model, device, samples,\n", + " repeats=len(samples), clock_freq=MEASURED_CLOCK)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "79985731", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from brainchip_utils.plot_utils import plot_per_layer_results\n", + "\n", + "if per_layer_results is not None:\n", + " # Map without hw_only so the mapping plot can be drawn\n", + " ak_model.map(device, mode=akida.MapMode.Minimal)\n", + " plot_per_layer_results(per_layer_results, ak_model, sparsity_dict,\n", + " model_name=path.name, example='Jester TENN (Akida 2)')" + ] + }, + { + "cell_type": "markdown", + "id": "b741e709", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "The latency per frame in each mapping mode, measured on the FPGA and projected to the\n", + "AKD2500 target clock. The README discusses what the three modes show for this model." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "2a08ffeb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Jester TENN, 100 x 100 frames, 8-bit; 160 streamed frames\n", + " mean activation sparsity: 56.40%\n", + " Minimal 44 NPs, 2 passes, 209.324 ms per frame @ 25 MHz, 5.233 ms projected @ 1 GHz\n", + " AllNps 45 NPs, 2 passes, 209.118 ms per frame @ 25 MHz, 5.228 ms projected @ 1 GHz\n", + " HwPr 96 NPs, 5 passes, 168.038 ms per frame @ 25 MHz, 4.201 ms projected @ 1 GHz\n" + ] + } + ], + "source": [ + "print(f'Jester TENN, 100 x 100 frames, 8-bit; {len(samples)} streamed frames')\n", + "print(f' mean activation sparsity: {np.mean(list(sparsity_dict.values())) * 100:.2f}%')\n", + "for mm, res in full_results.items():\n", + " print(f\" {mm:8} {res['num_nps']:3d} NPs, {res['num_passes']:2d} passes, \"\n", + " f\"{res['mean_clk_ms']:8.3f} ms per frame @ 25 MHz, \"\n", + " f\"{res['projected_clk_ms']:6.3f} ms projected @ 1 GHz\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/akida2/model_zoo/jester/jester_notebook_evaluation.ipynb b/akida2/model_zoo/jester/jester_notebook_evaluation.ipynb new file mode 100644 index 0000000..6fc3d82 --- /dev/null +++ b/akida2/model_zoo/jester/jester_notebook_evaluation.ipynb @@ -0,0 +1,878 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "009b6614", + "metadata": {}, + "source": [ + "\"BrainChip\n", + "\n", + "# Hand Gesture Recognition (Jester) — Akida 2 Evaluation\n", + "\n", + "Run Time: ~10 minutes\n", + "\n", + "This notebook takes BrainChip's **TENN spatiotemporal** model for Jester from its float\n", + "form to an Akida 2 model, and measures what each step costs in accuracy:\n", + "\n", + "1. evaluate the float model, which sees each clip whole,\n", + "2. quantize it to 8 bits with post-training quantization (PTQ), as BrainChip did, and check\n", + " the result against the published 8-bit model,\n", + "3. evaluate the quantized model, which is now a **streaming** model: one frame per\n", + " inference,\n", + "4. convert it to Akida, evaluate it, and check how it maps onto Akida 2 devices.\n", + "\n", + "There is no training here: the float model is BrainChip's published one (see 'Training\n", + "recipe' in the README).\n", + "\n", + "The data is the **BrainChip Jester subset**, one shard of the Jester validation split\n", + "(541 clips), downloaded from BrainChip's dataset mirror on first use. Every accuracy in\n", + "this notebook is on that subset, not on the full validation split." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "4eeba568", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Not running on Colab — nothing to do. (This step only matters for Colab; local runs already have everything they need.)\n" + ] + } + ], + "source": [ + "# Colab-only setup. Local users: ignore this cell - it does nothing for you.\n", + "import sys\n", + "if 'google.colab' in sys.modules:\n", + " !wget -q https://raw.githubusercontent.com/Brainchip-Inc/brainchip_devhub/main/akida2/model_zoo/jester/colab_setup.py\n", + "import colab_setup\n", + "colab_setup.setup()" + ] + }, + { + "cell_type": "markdown", + "id": "86f9af3d", + "metadata": {}, + "source": [ + "## Configuration\n", + "\n", + "`DATA_PATH = None` uses the BrainChip Jester subset. To evaluate on the full validation\n", + "split, point it at a Jester directory in the layout described under 'Dataset' in the README." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "0a0f0811", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "DATA_PATH = None # None: the BrainChip Jester subset, downloaded into data/\n", + "BATCH_SIZE = 32 # clips per batch for the Keras models" + ] + }, + { + "cell_type": "markdown", + "id": "df2669e6", + "metadata": {}, + "source": [ + "## Float model\n", + "\n", + "The published float model is built from `Conv3D` layers. It takes a whole clip, 16 frames\n", + "of 100 × 100 RGB, and returns a prediction for every frame. Its blocks alternate a\n", + "**temporal** convolution (kernel 5 over time, 1 × 1 in space) and a **spatial** one (3 × 3,\n", + "1 over time). The temporal convolutions are padded with 4 frames before the clip and none\n", + "after, so they are causal: a frame's prediction only depends on the frames up to it." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "16c751da", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:No training configuration found in the save file, so the model was *not* compiled. Compile it manually.\n", + "input (None, 16, 100, 100, 3) -> output (None, 16, 1, 1, 27), 1,353,895 parameters\n", + "\n", + "input_conv kernel (1, 3, 3) strides (1, 2, 2) groups 1 -> (None, 16, 50, 50, 8)\n", + "convt_full_1_0 kernel (5, 1, 1) strides (1, 1, 1) groups 1 -> (None, 16, 50, 50, 20)\n", + "convs_full_1_0 kernel (1, 3, 3) strides (1, 2, 2) groups 1 -> (None, 16, 25, 25, 40)\n", + "convt_full_2_0 kernel (5, 1, 1) strides (1, 1, 1) groups 1 -> (None, 16, 25, 25, 80)\n", + "convs_full_2_0 kernel (1, 3, 3) strides (1, 2, 2) groups 1 -> (None, 16, 13, 13, 120)\n", + "convt_full_3_0 kernel (5, 1, 1) strides (1, 1, 1) groups 1 -> (None, 16, 13, 13, 160)\n", + "convs_full_3_0 kernel (1, 3, 3) strides (1, 2, 2) groups 1 -> (None, 16, 7, 7, 200)\n", + "convt_dw_4_0 kernel (5, 1, 1) strides (1, 1, 1) groups 200 -> (None, 16, 7, 7, 200)\n", + "convt_pw_4_0 kernel (1, 1, 1) strides (1, 1, 1) groups 1 -> (None, 16, 7, 7, 240)\n", + "convs_dw_4_0 kernel (1, 3, 3) strides (1, 2, 2) groups 240 -> (None, 16, 4, 4, 240)\n", + "convs_pw_4_0 kernel (1, 1, 1) strides (1, 1, 1) groups 1 -> (None, 16, 4, 4, 280)\n", + "convt_dw_5_0 kernel (5, 1, 1) strides (1, 1, 1) groups 280 -> (None, 16, 4, 4, 280)\n", + "convt_pw_5_0 kernel (1, 1, 1) strides (1, 1, 1) groups 1 -> (None, 16, 4, 4, 320)\n", + "convs_dw_5_0 kernel (1, 3, 3) strides (1, 2, 2) groups 320 -> (None, 16, 2, 2, 320)\n", + "convs_pw_5_0 kernel (1, 1, 1) strides (1, 1, 1) groups 1 -> (None, 16, 2, 2, 640)\n", + "\n", + "Temporal padding (before, after): {(4, 0)}\n" + ] + } + ], + "source": [ + "from akida_models.model_io import load_model\n", + "from jester_model import model_path, verify_model\n", + "\n", + "float_path = model_path('float')\n", + "verify_model(float_path) # checks the published sha256 (and that Git LFS fetched the file)\n", + "float_model = load_model(str(float_path))\n", + "print(f'input {float_model.input_shape} -> output {float_model.output_shape}, '\n", + " f'{float_model.count_params():,} parameters\\n')\n", + "\n", + "padding = {l.name: l.padding[0] for l in float_model.layers if l.__class__.__name__ == 'ZeroPadding3D'}\n", + "for layer in float_model.layers:\n", + " if layer.__class__.__name__ == 'Conv3D':\n", + " print(f'{layer.name:16} kernel {str(layer.kernel_size):10} strides {str(layer.strides):10} '\n", + " f'groups {layer.groups:4} -> {layer.output_shape}')\n", + "print('\\nTemporal padding (before, after):', set(padding.values()))" + ] + }, + { + "cell_type": "markdown", + "id": "01398409", + "metadata": {}, + "source": [ + "## Data\n", + "\n", + "Each clip becomes 16 frames, taken at a stride of 2 from its first frame and center-cropped\n", + "to 100 × 100, as raw uint8 pixels. There is no normalization: the model's first layer is a\n", + "`Rescaling(1.)` placeholder, and it was trained on pixels in [0, 255]. See\n", + "[jester_preprocessing.py](jester_preprocessing.py), whose bit-equality with the\n", + "`akida_models` pipeline `python jester_data.py --check-preprocessing` checks." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "00c3eb35", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "541 clips, 27 classes\n", + "batch: (32, 16, 100, 100, 3) , range [0, 255]\n", + "first clips: ['Thumb Up', 'Pushing Two Fingers Away', 'Swiping Left', 'Thumb Down']\n" + ] + } + ], + "source": [ + "from jester_data import get_data, get_data_dir, read_labels\n", + "\n", + "data_dir = get_data_dir(DATA_PATH)\n", + "dataset, num_clips = get_data(data_dir, BATCH_SIZE)\n", + "labels = read_labels(data_dir)\n", + "clips, clip_labels = next(iter(dataset))\n", + "print(f'{num_clips} clips, {len(labels)} classes')\n", + "print(f'batch: {clips.shape} {clips.dtype}, range [{clips.numpy().min()}, {clips.numpy().max()}]')\n", + "print('first clips:', [labels[i] for i in clip_labels.numpy()[:4]])" + ] + }, + { + "cell_type": "markdown", + "id": "72d1cc8c", + "metadata": {}, + "source": [ + "## Float evaluation\n", + "\n", + "The float model produces 16 per-frame predictions for each clip, and two accuracies come\n", + "from them, the same two for every variant in this notebook:\n", + "\n", + "- **clip accuracy**: one decision per clip. The per-frame softmax outputs are accumulated\n", + " with a decay of 0.8 (after each frame, the running total is multiplied by 0.8 and the new\n", + " frame's softmax added), and the clip's class is the largest entry at the end. This is how\n", + " BrainChip's `evaluate_bufferized_model` scores the model, and the headline figure.\n", + "- **frame accuracy**: each frame's own prediction against the clip's label. It is lower,\n", + " because the first frames of a clip have seen little of the gesture." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "590d4152", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Float: 0it [00:00, ?it/s]I0000 00:00:1793122712.573237 3003024 cuda_dnn.cc:529] Loaded cuDNN version 90300\n", + "Float: 17it [00:10, 1.58it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Float over 541 clips: clip accuracy 95.01%, frame accuracy 71.15%\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "from jester_eval import evaluate, float_frame_logits\n", + "\n", + "float_result = evaluate(float_frame_logits(float_model), dataset, desc='Float')\n", + "print(f\"\\nFloat over {float_result['n']} clips: clip accuracy {float_result['clip_acc'] * 100:.2f}%, \"\n", + " f\"frame accuracy {float_result['frame_acc'] * 100:.2f}%\")" + ] + }, + { + "cell_type": "markdown", + "id": "f15804de", + "metadata": {}, + "source": [ + "## Quantization: 8-bit PTQ\n", + "\n", + "BrainChip quantized this model with\n", + "\n", + "```\n", + "quantizeml quantize -m tenn_spatiotemporal_jester.h5 -w 8 -i 8 -a 8 --per_tensor_activations -id uint8 -e 1 -bs 100 -sa jester_video_bs100.npz\n", + "```\n", + "\n", + "`quantize_float_model` in [jester_model.py](jester_model.py) makes the same call through the\n", + "Python API. The calibration pack holds 100 train clips of 16 frames as one array of 1,600\n", + "frames in clip order. For a spatiotemporal TENN, `batch_size` must be the number of clips:\n", + "the calibration uses it to cut the frames back into clips, and `quantize()` refuses to run\n", + "without it.\n", + "\n", + "Quantization also changes the model's structure. Each temporal `Conv3D` becomes a\n", + "`BufferTempConv` (`DepthwiseBufferTempConv` in the depthwise blocks), which keeps the last 5\n", + "frames' inputs in a FIFO buffer, and each spatial `Conv3D` becomes a 2D convolution. The\n", + "quantized model takes **one frame** and returns one prediction." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "72a481b3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "calibration pack: (1600, 100, 100, 3) uint8\n", + "WARNING:tensorflow:5 out of the last 5 calls to triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has reduce_retracing=True option that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for more details.\n", + "WARNING:tensorflow:6 out of the last 6 calls to triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has reduce_retracing=True option that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for more details.\n", + "16/16 [==============================] - 3s 7ms/step\n", + "\n", + "input (None, 100, 100, 3) -> output (None, 27)\n", + "Counter({'QuantizedConv2D': 8, 'QuantizedBufferTempConv': 3, 'QuantizedDepthwiseBufferTempConv': 2, 'QuantizedDepthwiseConv2D': 2})\n" + ] + } + ], + "source": [ + "from collections import Counter\n", + "from jester_data import get_calibration_samples\n", + "from jester_model import quantize_float_model\n", + "\n", + "calibration = get_calibration_samples()\n", + "print(f'calibration pack: {calibration.shape} {calibration.dtype}')\n", + "quantized_model = quantize_float_model(float_model, calibration, num_clips=100)\n", + "\n", + "print(f'\\ninput {quantized_model.input_shape} -> output {quantized_model.output_shape}')\n", + "print(Counter(l.__class__.__name__ for l in quantized_model.layers\n", + " if 'Conv' in l.__class__.__name__))" + ] + }, + { + "cell_type": "markdown", + "id": "ed443cfd", + "metadata": {}, + "source": [ + "### Comparison with the published model\n", + "\n", + "`compare_models` checks the structure, the Keras variables, and the converted Akida models,\n", + "whose integer weights and thresholds are what runs on the NPs." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "929867c0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:No training configuration found in the save file, so the model was *not* compiled. Compile it manually.\n", + "Same structure (layers, shapes, variables): True\n", + "Keras variables that differ: 16\n", + " convs_dw_4_0/depthwise_kernel:0 max |diff| 4.77e-07\n", + " convs_dw_4_0/relu/output_quantizer/rescaling_rate:0 max |diff| 5.96e-08\n", + " convs_dw_5_0/depthwise_kernel:0 max |diff| 1.91e-06\n", + " convs_dw_5_0/relu/output_quantizer/rescaling_rate:0 max |diff| 5.96e-08\n", + " convs_pw_4_0/kernel:0 max |diff| 2.38e-07\n", + " convs_pw_4_0/relu/output_quantizer/rescaling_rate:0 max |diff| 5.96e-08\n", + " convs_pw_5_0/kernel:0 max |diff| 1.19e-07\n", + " convt_dw_4_0/relu/output_quantizer/rescaling_rate:0 max |diff| 1.19e-07\n", + " convt_dw_5_0/kernel:0 max |diff| 9.54e-07\n", + " convt_dw_5_0/relu/output_quantizer/rescaling_rate:0 max |diff| 5.96e-08\n", + " convt_pw_4_0/kernel:0 max |diff| 9.54e-07\n", + " convt_pw_4_0/relu/output_quantizer/rescaling_rate:0 max |diff| 1.79e-07\n", + " convt_pw_5_0/kernel:0 max |diff| 2.38e-07\n", + " convt_pw_5_0/relu/output_quantizer/rescaling_rate:0 max |diff| 5.96e-08\n", + " dense_1/kernel:0 max |diff| 9.54e-07\n", + " re_lu/output_quantizer/rescaling_rate:0 max |diff| 5.96e-08\n", + "Akida variables that differ after conversion: 1\n", + " dequantizer/scales float32 max |diff| 2.33e-10\n" + ] + } + ], + "source": [ + "from jester_model import compare_models, print_comparison\n", + "\n", + "published_path = model_path('quantized')\n", + "verify_model(published_path)\n", + "published_model = load_model(str(published_path))\n", + "print_comparison(compare_models(published_model, quantized_model))" + ] + }, + { + "cell_type": "markdown", + "id": "918ef4cc", + "metadata": {}, + "source": [ + "The structure and the integer weights are identical. The few differences are float\n", + "rounding, in Keras variables that are quantized afterwards and in the Akida model's float\n", + "output scales. The evaluation below uses the model just produced; the published one\n", + "evaluates identically.\n", + "\n", + "## Streaming evaluation\n", + "\n", + "The quantized model sees a clip one frame at a time, and its buffers carry state from\n", + "frame to frame. So the buffers are **reset at the start of every batch of clips**, with\n", + "`reset_buffers`, and the frames are fed in order. In Keras the batch axis holds independent\n", + "clips: a batch of 32 clips steps through its 16 frames together." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "3b27e2fe", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "def quantized_frame_logits(model):\n", + " \"\"\"Per-frame logits of the buffered Keras model, streaming each clip frame by frame.\"\"\"\n", + " model_fn = tf.function(model)\n", + "\n", + " def run(clips):\n", + " reset_buffers(model) # a new batch of clips: forget the previous frames\n", + " return np.stack([model_fn(clips[:, t]).numpy() for t in range(clips.shape[1])], 1)\n", + " return run\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "8-bit: 0it [00:00, ?it/s]W0000 00:00:1793122768.525840 3002715 loop_optimizer.cc:934] Skipping loop optimization for Merge node with control input: jester_video/convt_full_1_0/assert_less_equal/Assert/AssertGuard/branch_executed/_73\n", + "8-bit: 16it [00:14, 2.03it/s]W0000 00:00:1793122781.939407 3002715 loop_optimizer.cc:934] Skipping loop optimization for Merge node with control input: jester_video/convt_full_1_0/assert_less_equal/Assert/AssertGuard/branch_executed/_73\n", + "8-bit: 17it [00:20, 1.20s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "8-bit PTQ over 541 clips: clip accuracy 94.64%, frame accuracy 70.52%\n", + "Change vs float: -0.37 points (clip)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "import inspect\n", + "from jester_eval import quantized_frame_logits\n", + "\n", + "print(inspect.getsource(quantized_frame_logits))\n", + "quant_result = evaluate(quantized_frame_logits(quantized_model), dataset, desc='8-bit')\n", + "print(f\"\\n8-bit PTQ over {quant_result['n']} clips: clip accuracy {quant_result['clip_acc'] * 100:.2f}%, \"\n", + " f\"frame accuracy {quant_result['frame_acc'] * 100:.2f}%\")\n", + "print(f\"Change vs float: {(quant_result['clip_acc'] - float_result['clip_acc']) * 100:+.2f} points (clip)\")" + ] + }, + { + "cell_type": "markdown", + "id": "e502b1dc", + "metadata": {}, + "source": [ + "## Conversion to Akida\n", + "\n", + "`cnn2snn.convert` turns the quantized Keras model into an Akida model. Conversion changes\n", + "the representation, not the computation, so the Akida model should score the same as the\n", + "quantized model." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "cd1c4d70", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Model Summary \n", + "________________________________________________\n", + "Input shape Output shape Sequences Layers\n", + "================================================\n", + "[100, 100, 3] [1, 1, 27] 1 18 \n", + "________________________________________________\n", + "\n", + "_________________________________________________________________________\n", + "Layer (type) Output shape Kernel shape \n", + "\n", + "================== SW/input_conv-dequantizer (Software) =================\n", + "\n", + "input_conv (InputConv2D) [50, 50, 8] (3, 3, 3, 8) \n", + "_________________________________________________________________________\n", + "convt_full_1_0 (BufferTempConv) [50, 50, 20] (1, 1, 40, 20) \n", + "_________________________________________________________________________\n", + "convs_full_1_0 (Conv2D) [25, 25, 40] (3, 3, 20, 40) \n", + "_________________________________________________________________________\n", + "convt_full_2_0 (BufferTempConv) [25, 25, 80] (1, 1, 200, 80) \n", + "_________________________________________________________________________\n", + "convs_full_2_0 (Conv2D) [13, 13, 120] (3, 3, 80, 120) \n", + "_________________________________________________________________________\n", + "convt_full_3_0 (BufferTempConv) [13, 13, 160] (1, 1, 600, 160)\n", + "_________________________________________________________________________\n", + "convs_full_3_0 (Conv2D) [7, 7, 200] (3, 3, 160, 200)\n", + "_________________________________________________________________________\n", + "convt_dw_4_0 (DepthwiseBufferTempConv) [7, 7, 200] (1, 1, 5, 200) \n", + "_________________________________________________________________________\n", + "convt_pw_4_0 (Conv2D) [7, 7, 240] (1, 1, 200, 240)\n", + "_________________________________________________________________________\n", + "convs_dw_4_0 (DepthwiseConv2D) [4, 4, 240] (3, 3, 240, 1) \n", + "_________________________________________________________________________\n", + "convs_pw_4_0 (Conv2D) [4, 4, 280] (1, 1, 240, 280)\n", + "_________________________________________________________________________\n", + "convt_dw_5_0 (DepthwiseBufferTempConv) [4, 4, 280] (1, 1, 5, 280) \n", + "_________________________________________________________________________\n", + "convt_pw_5_0 (Conv2D) [4, 4, 320] (1, 1, 280, 320)\n", + "_________________________________________________________________________\n", + "convs_dw_5_0 (DepthwiseConv2D) [2, 2, 320] (3, 3, 320, 1) \n", + "_________________________________________________________________________\n", + "convs_pw_5_0 (Conv2D) [1, 1, 640] (1, 1, 320, 640)\n", + "_________________________________________________________________________\n", + "dense (Dense1D) [1, 1, 640] (640, 640) \n", + "_________________________________________________________________________\n", + "dense_1 (Dense1D) [1, 1, 27] (640, 27) \n", + "_________________________________________________________________________\n", + "dequantizer (Dequantizer) [1, 1, 27] N/A \n", + "_________________________________________________________________________\n" + ] + } + ], + "source": [ + "from cnn2snn import convert\n", + "\n", + "akida_model = convert(quantized_model)\n", + "akida_model.summary()" + ] + }, + { + "cell_type": "markdown", + "id": "4c8afe67", + "metadata": {}, + "source": [ + "### Streaming on Akida\n", + "\n", + "An `akida.Model` has no buffer reset: a new model built from the same layers starts with\n", + "empty buffers. So, as in BrainChip's `evaluate_bufferized_model`, each clip gets a new\n", + "model and each frame is its own `forward` call. Without the new model, a clip starts with\n", + "the end of the previous one:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "743b3133", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Same clip, fresh buffers == after another clip: False\n" + ] + } + ], + "source": [ + "import akida\n", + "from jester_eval import stream\n", + "\n", + "clip, previous = clips.numpy()[0], clips.numpy()[1] # (16, 100, 100, 3) each\n", + "fresh = stream(akida_model, clip)\n", + "continuing = akida.Model(layers=akida_model.layers)\n", + "for t in range(len(previous)):\n", + " continuing.forward(previous[t:t + 1])\n", + "after_previous = np.concatenate([continuing.forward(clip[t:t + 1]) for t in range(len(clip))])\n", + "print('Same clip, fresh buffers == after another clip:', np.array_equal(fresh, after_previous))" + ] + }, + { + "cell_type": "markdown", + "id": "e8971401", + "metadata": {}, + "source": [ + "So the Akida evaluation streams each clip one frame per call, on a new model. This runs\n", + "on the software backend and takes a couple of minutes." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "00cde223", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Akida: 541it [02:34, 3.51it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Akida over 541 clips: clip accuracy 94.64%, frame accuracy 70.52%\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "from jester_eval import akida_frame_logits\n", + "\n", + "akida_dataset, _ = get_data(data_dir, batch_size=1)\n", + "akida_result = evaluate(akida_frame_logits(akida_model), akida_dataset, desc='Akida')\n", + "print(f\"\\nAkida over {akida_result['n']} clips: clip accuracy {akida_result['clip_acc'] * 100:.2f}%, \"\n", + " f\"frame accuracy {akida_result['frame_acc'] * 100:.2f}%\")" + ] + }, + { + "cell_type": "markdown", + "id": "dce05bb6", + "metadata": {}, + "source": [ + "## Mapping onto Akida 2 devices\n", + "\n", + "Mapping is a software step, so you can check a model against a *virtual* device without the\n", + "hardware. `hw_only=True` makes the mapping fail rather than fall back to software for any\n", + "part of the model." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "10b24166", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6-node FPGA Minimal 44 NPs, 2 pass(es), 1 sequence(s)\n", + "6-node FPGA AllNps 45 NPs, 2 pass(es), 1 sequence(s)\n", + "6-node FPGA HwPr 96 NPs, 5 pass(es), 1 sequence(s)\n", + "12-node Minimal 44 NPs, 1 pass(es), 1 sequence(s)\n", + "12-node AllNps 49 NPs, 1 pass(es), 1 sequence(s)\n", + "12-node HwPr 184 NPs, 5 pass(es), 1 sequence(s)\n" + ] + } + ], + "source": [ + "from brainchip_utils.hardware_utils import get_mapping_stats\n", + "\n", + "devices = {'6-node FPGA': akida.SixNodesIPv2, '12-node': akida.TwelveNodesIPv2}\n", + "for name, make_device in devices.items():\n", + " for mode in ['Minimal', 'AllNps', 'HwPr']:\n", + " akida_model.map(make_device(), mode=getattr(akida.MapMode, mode), hw_only=True)\n", + " nps, passes, sequences = get_mapping_stats(akida_model)\n", + " print(f'{name:12} {mode:8} {nps:3d} NPs, {passes} pass(es), {sequences} sequence(s)')" + ] + }, + { + "cell_type": "markdown", + "id": "5c7ec46f", + "metadata": {}, + "source": [ + "On the FPGA, the model needs more than one pass even in Minimal mode, so the weights of\n", + "each pass are reloaded at every frame. The mapping summary also shows what is particular to\n", + "a temporal model: the buffered layers map onto `TNP_B` components, and each is allotted\n", + "external memory." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "6b3a51de", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Model Summary \n", + "_________________________________________________________________________________________\n", + "Input shape Output shape Sequences Layers NPs Skip DMAs External Memory (Bytes)\n", + "=========================================================================================\n", + "[100, 100, 3] [1, 1, 27] 1 18 43 5 892080 \n", + "_________________________________________________________________________________________\n", + "\n", + "_________________________\n", + "Component (type) Count\n", + "=========================\n", + "HRC 1 \n", + "_________________________\n", + "CNP1 22 \n", + "_________________________\n", + "FNP2 1 \n", + "_________________________\n", + "FNP3 1 \n", + "_________________________\n", + "SKIP_DMA_STORE 5 \n", + "_________________________\n", + "TNP_B 19 \n", + "_________________________\n", + "SKIP_DMA_LOAD 5 \n", + "_________________________\n", + "\n", + " External Memory Summary \n", + "_________________________________________________________________\n", + "Layer (type) External Memory (Bytes)\n", + "=================================================================\n", + "convt_full_1_0 (BufferTempConv) 120000 \n", + "_________________________________________________________________\n", + "convt_full_2_0 (BufferTempConv) 150000 \n", + "_________________________________________________________________\n", + "convt_full_3_0 (BufferTempConv) 121680 \n", + "_________________________________________________________________\n", + "convt_dw_4_0 (DepthwiseBufferTempConv) 58800 \n", + "_________________________________________________________________\n", + "convt_dw_5_0 (DepthwiseBufferTempConv) 26880 \n", + "_________________________________________________________________\n", + "dense (Dense1D) 414720 \n", + "_________________________________________________________________\n", + "\n", + "________________________________________________________________________________________________________________________\n", + "Layer (type) Output shape Kernel shape Components \n", + "\n", + "============================== HW/input_conv-dequantizer (Hardware) - size: 1794956 bytes ==============================\n", + "\n", + "input_conv (InputConv2D) [50, 50, 8] (3, 3, 3, 8) 1 HRC \n", + "________________________________________________________________________________________________________________________\n", + "convt_full_1_0 (BufferTempConv) [50, 50, 20] (1, 1, 40, 20) 2 TNP_B + 1 SKIP_DMA_STORE + 1 SKIP_DMA_LOAD \n", + "________________________________________________________________________________________________________________________\n", + "convs_full_1_0 (Conv2D) [25, 25, 40] (3, 3, 20, 40) 1 CNP1 \n", + "________________________________________________________________________________________________________________________\n", + "convt_full_2_0 (BufferTempConv) [25, 25, 80] (1, 1, 200, 80) 3 TNP_B + 1 SKIP_DMA_STORE + 1 SKIP_DMA_LOAD \n", + "________________________________________________________________________________________________________________________\n", + "convs_full_2_0 (Conv2D) [13, 13, 120] (3, 3, 80, 120) 2 CNP1 \n", + "________________________________________________________________________________________________________________________\n", + "convt_full_3_0 (BufferTempConv) [13, 13, 160] (1, 1, 600, 160) 12 TNP_B + 1 SKIP_DMA_STORE + 1 SKIP_DMA_LOAD\n", + "======================================================== pass 2 ========================================================\n", + "convs_full_3_0 (Conv2D) [7, 7, 200] (3, 3, 160, 200) 7 CNP1 \n", + "________________________________________________________________________________________________________________________\n", + "convt_dw_4_0 (DepthwiseBufferTempConv) [7, 7, 200] (1, 1, 5, 200) 1 TNP_B + 1 SKIP_DMA_STORE + 1 SKIP_DMA_LOAD \n", + "________________________________________________________________________________________________________________________\n", + "convt_pw_4_0 (Conv2D) [7, 7, 240] (1, 1, 200, 240) 1 CNP1 \n", + "________________________________________________________________________________________________________________________\n", + "convs_dw_4_0 (DepthwiseConv2D) [4, 4, 240] (3, 3, 240, 1) 1 CNP1 \n", + "________________________________________________________________________________________________________________________\n", + "convs_pw_4_0 (Conv2D) [4, 4, 280] (1, 1, 240, 280) 2 CNP1 \n", + "________________________________________________________________________________________________________________________\n", + "convt_dw_5_0 (DepthwiseBufferTempConv) [4, 4, 280] (1, 1, 5, 280) 1 TNP_B + 1 SKIP_DMA_STORE + 1 SKIP_DMA_LOAD \n", + "________________________________________________________________________________________________________________________\n", + "convt_pw_5_0 (Conv2D) [4, 4, 320] (1, 1, 280, 320) 2 CNP1 \n", + "________________________________________________________________________________________________________________________\n", + "convs_dw_5_0 (DepthwiseConv2D) [2, 2, 320] (3, 3, 320, 1) 1 CNP1 \n", + "________________________________________________________________________________________________________________________\n", + "convs_pw_5_0 (Conv2D) [1, 1, 640] (1, 1, 320, 640) 5 CNP1 \n", + "________________________________________________________________________________________________________________________\n", + "dense (Dense1D) [1, 1, 640] (640, 640) 1 FNP2 \n", + "________________________________________________________________________________________________________________________\n", + "dense_1 (Dense1D) [1, 1, 27] (640, 27) 1 FNP3 \n", + "________________________________________________________________________________________________________________________\n", + "dequantizer (Dequantizer) [1, 1, 27] N/A N/A \n", + "________________________________________________________________________________________________________________________\n" + ] + } + ], + "source": [ + "akida_model.map(akida.SixNodesIPv2(), mode=akida.MapMode.Minimal, hw_only=True)\n", + "akida_model.summary()" + ] + }, + { + "cell_type": "markdown", + "id": "ff0ae8c9", + "metadata": {}, + "source": [ + "## Activation sparsity\n", + "\n", + "Akida is event-driven: a zero activation generates no event and so no work. The sparsity is\n", + "measured by streaming one clip of each class through the Akida model, one frame per call,\n", + "each clip from empty buffers." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "8233cd21", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Layer Sparsity\n", + "---------------------------\n", + "input_conv 34.77%\n", + "convt_full_1_0 42.55%\n", + "convs_full_1_0 42.83%\n", + "convt_full_2_0 68.43%\n", + "convs_full_2_0 71.43%\n", + "convt_full_3_0 75.03%\n", + "convs_full_3_0 70.89%\n", + "convt_dw_4_0 60.03%\n", + "convt_pw_4_0 55.24%\n", + "convs_dw_4_0 47.18%\n", + "convs_pw_4_0 64.88%\n", + "convt_dw_5_0 47.56%\n", + "convt_pw_5_0 56.63%\n", + "convs_dw_5_0 38.70%\n", + "convs_pw_5_0 87.87%\n", + "dense 98.68%\n", + "dense_1 0.00%\n", + "---------------------------\n", + "Mean 56.63%\n", + "\n", + "Mean activation sparsity: 56.63%\n" + ] + } + ], + "source": [ + "from brainchip_utils.plot_utils import pretty_print_sparsity\n", + "from jester_eval import akida_sparsity\n", + "\n", + "per_layer, mean_sparsity = akida_sparsity(akida_model, data_dir)\n", + "pretty_print_sparsity(per_layer)\n", + "print(f'\\nMean activation sparsity: {mean_sparsity * 100:.2f}%')" + ] + }, + { + "cell_type": "markdown", + "id": "c1e00f83", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "Accuracy of each variant on the BrainChip Jester subset. The Akida model should match the\n", + "quantized model, since conversion changes the representation, not the computation; the\n", + "gap from float is the cost of 8-bit quantization." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "84dda02e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "BrainChip Jester subset, 541 clips (not the full validation split)\n", + " Float clip accuracy 95.01% frame accuracy 71.15%\n", + " 8-bit PTQ clip accuracy 94.64% frame accuracy 70.52%\n", + " Akida clip accuracy 94.64% frame accuracy 70.52%\n", + " mean activation sparsity: 56.63%\n" + ] + } + ], + "source": [ + "print(f\"BrainChip Jester subset, {akida_result['n']} clips (not the full validation split)\")\n", + "for name, r in [('Float', float_result), ('8-bit PTQ', quant_result), ('Akida', akida_result)]:\n", + " print(f\" {name:10} clip accuracy {r['clip_acc'] * 100:6.2f}% frame accuracy {r['frame_acc'] * 100:6.2f}%\")\n", + "print(f' mean activation sparsity: {mean_sparsity * 100:.2f}%')" + ] + }, + { + "cell_type": "markdown", + "id": "a5a5d3c6", + "metadata": {}, + "source": [ + "To measure the latency per frame on the Akida 2 FPGA, continue with\n", + "[jester_notebook_benchmark.ipynb](jester_notebook_benchmark.ipynb)." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/akida2/model_zoo/jester/jester_preprocessing.py b/akida2/model_zoo/jester/jester_preprocessing.py new file mode 100644 index 0000000..4f13375 --- /dev/null +++ b/akida2/model_zoo/jester/jester_preprocessing.py @@ -0,0 +1,88 @@ +#!/usr/bin/env python +# Copyright 2026 Brainchip Holdings Ltd. Apache 2.0 License +""" +Evaluation preprocessing for the Jester TENN example (Akida 2). + +A self-contained copy of the validation path of +``akida_models.tenn_spatiotemporal.jester_train.get_data``, so that what happens +to a clip before it reaches the model is documented in one readable place. +``jester_data.check_preprocessing`` asserts that this copy is bit-identical to +the ``akida_models`` implementation. + +Each Jester clip is stored in a GZIP TFRecord as a sequence of JPEG frames, 100 +pixels high and of varying width. For evaluation, a clip becomes a +``(16, 100, 100, 3)`` uint8 tensor: + +* **Frames:** 16 frames, taking every other frame from the first one (frames 0, + 2, 4, ..., 30). A clip shorter than 32 frames wraps around to its start. + Training uses the same stride from a random starting frame. +* **Size:** each frame is center-cropped (or zero-padded, if it is smaller) to + 100 x 100. Frames are not resized. +* **Values:** raw uint8 pixels in [0, 255]. **Do not normalize.** The model's + first layer is a ``Rescaling(1.)`` placeholder that only exists so the model + can take uint8 input, because this model was trained on unscaled pixels. + +The float model takes the whole 16-frame clip at once. The quantized and Akida +models take one ``(100, 100, 3)`` frame at a time, in order: see +``jester_eval.py``. +""" +import tensorflow as tf + +__all__ = ["FRAMES_PER_CLIP", "FRAME_STEP", "FRAME_SIZE", "parse_sequence_example", + "decode_clip"] + +FRAMES_PER_CLIP = 16 +FRAME_STEP = 2 +FRAME_SIZE = (100, 100) + + +def parse_sequence_example(example): + """Parses one serialized clip into (encoded frames, label, frame count). + + Args: + example (tf.Tensor): a serialized ``tf.train.SequenceExample``. + + Returns: + tuple: the JPEG-encoded frames (tf.string, shape (frame_count,)), the + integer label, and the clip's frame count. + """ + context, sequence = tf.io.parse_single_sequence_example( + example, + context_features={ + 'filename': tf.io.FixedLenFeature([], tf.string), + 'height': tf.io.FixedLenFeature([], tf.int64), + 'width': tf.io.FixedLenFeature([], tf.int64), + 'depth': tf.io.FixedLenFeature([], tf.int64), + 'frame_count': tf.io.FixedLenFeature([], tf.int64), + 'label': tf.io.FixedLenFeature([], tf.int64), + }, + sequence_features={'frames': tf.io.FixedLenSequenceFeature([], dtype=tf.string)}) + return sequence['frames'], context['label'], context['frame_count'] + + +def decode_clip(encoded_frames, frame_count, frames_per_clip=FRAMES_PER_CLIP, + step=FRAME_STEP, frame_size=FRAME_SIZE): + """Decodes the frames used for evaluation from one clip. + + Args: + encoded_frames (tf.Tensor): the clip's JPEG-encoded frames. + frame_count (tf.Tensor): the clip's number of frames. + frames_per_clip (int, optional): number of frames to keep. Defaults to 16. + step (int, optional): stride between kept frames. Defaults to 2. + frame_size (tuple, optional): output (height, width). Defaults to (100, 100). + + Returns: + tf.Tensor: uint8 tensor of shape (frames_per_clip, height, width, 3). + """ + total = tf.cast(frame_count, tf.int32) + # Every `step`-th frame from the first; a short clip wraps around to its start + indices = tf.math.floormod(tf.range(0, frames_per_clip * step, step), total) + frames = tf.TensorArray(tf.uint8, size=frames_per_clip) + for i in tf.range(frames_per_clip): + image = tf.io.decode_jpeg(tf.gather(encoded_frames, indices[i])) + # Center crop (or pad) without resizing. The float round trip matches the + # reference implementation, and is exact for uint8 pixels. + image = tf.image.convert_image_dtype(image, tf.float32) + image = tf.image.resize_with_crop_or_pad(image, frame_size[0], frame_size[1]) + frames = frames.write(i, tf.image.convert_image_dtype(image, tf.uint8)) + return frames.stack() diff --git a/akida2/model_zoo/jester/models/.gitignore b/akida2/model_zoo/jester/models/.gitignore new file mode 100644 index 0000000..647613e --- /dev/null +++ b/akida2/model_zoo/jester/models/.gitignore @@ -0,0 +1,4 @@ +# Git to Ignore everything in this directory +* +# Except this .gitignore file +!.gitignore \ No newline at end of file diff --git a/akida2/model_zoo/jester/pretrained_models/tenn_spatiotemporal_jester.h5 b/akida2/model_zoo/jester/pretrained_models/tenn_spatiotemporal_jester.h5 new file mode 100644 index 0000000..ca0916c --- /dev/null +++ b/akida2/model_zoo/jester/pretrained_models/tenn_spatiotemporal_jester.h5 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5950e4d188cbda893c19c47d0a6e9e5c6200f902bb72f64d155d3e7a6f85816f +size 5615064 diff --git a/akida2/model_zoo/jester/pretrained_models/tenn_spatiotemporal_jester_buffer_i8_w8_a8.fbz b/akida2/model_zoo/jester/pretrained_models/tenn_spatiotemporal_jester_buffer_i8_w8_a8.fbz new file mode 100644 index 0000000..d0b3e31 --- /dev/null +++ b/akida2/model_zoo/jester/pretrained_models/tenn_spatiotemporal_jester_buffer_i8_w8_a8.fbz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:058e6c8de86330f564730e62b4cf88813926becabfc5fef8abacdeff85972469 +size 1611021 diff --git a/akida2/model_zoo/jester/pretrained_models/tenn_spatiotemporal_jester_buffer_i8_w8_a8.h5 b/akida2/model_zoo/jester/pretrained_models/tenn_spatiotemporal_jester_buffer_i8_w8_a8.h5 new file mode 100644 index 0000000..4b46203 --- /dev/null +++ b/akida2/model_zoo/jester/pretrained_models/tenn_spatiotemporal_jester_buffer_i8_w8_a8.h5 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:388f0e312499190ed2cc839fb4c4e6c791e54e5ee4d35736f33fc36acae24015 +size 5527784 diff --git a/akida2/model_zoo/jester/update_readme.py b/akida2/model_zoo/jester/update_readme.py new file mode 100644 index 0000000..43296b9 --- /dev/null +++ b/akida2/model_zoo/jester/update_readme.py @@ -0,0 +1,15 @@ +#!/usr/bin/env python +# Copyright 2026 Brainchip Holdings Ltd. Apache 2.0 License +"""Regenerate README.md from README.md.template + metrics.json.""" +import json +import pathlib +import runpy + +here = pathlib.Path(__file__).parent +metrics = json.loads((here / "docs" / "metrics.json").read_text()) +template = (here / "docs" / "README.md.template").read_text() +(here / "README.md").write_text(template.format_map(metrics)) +print("README.md updated.") + +# Refresh the Akida 2 landing README, whose model zoo table reads this metrics.json. +runpy.run_path(str(here.parents[1] / "update_readme.py"), run_name="__main__") diff --git a/akida2/update_readme.py b/akida2/update_readme.py index ef17d47..54110ed 100644 --- a/akida2/update_readme.py +++ b/akida2/update_readme.py @@ -18,7 +18,7 @@ sys.path.insert(0, str(here.parent)) # brainchip_utils, without needing the package installed from brainchip_utils.zoo_table import domain_sections, html_table, load_cards, value # noqa: E402 -DOMAINS = ["Image", "Audio", "Time series"] +DOMAINS = ["Image", "Video", "Audio", "Time series"] MAPPINGS = {"minimal": "Minimal", "allnps": "AllNPs", "hwpr": "HwPr"} HEADERS = ["Task", "Category", "Dataset", "Variant", "Performance", "Mapping", "Latency @ 25 MHz FPGA (ms)", "Projected @ 1 GHz AKD2500 (ms)", "Notes"] diff --git a/test/test_models.py b/test/test_models.py index 0dadb54..bfb7d88 100644 --- a/test/test_models.py +++ b/test/test_models.py @@ -158,10 +158,14 @@ def test_float_model_quantize_sanity(float_spec): weight_quantization=4, activ_quantization=4) else: - quantized = quantizeml.models.quantize(model, num_samples=num_samples) + # Spatiotemporal TENNs refuse to calibrate without an explicit batch_size. + quantized = quantizeml.models.quantize(model, num_samples=num_samples, + batch_size=num_samples) rng = np.random.default_rng(0) - inputs = rng.uniform(0, 255, (num_samples, *model.input_shape[1:])).astype(np.float32) + # Quantization can change the input shape: a spatiotemporal TENN takes whole clips + # as a float model and single frames once its Conv3D layers become buffered. + inputs = rng.uniform(0, 255, (num_samples, *quantized.input_shape[1:])).astype(np.float32) outputs = quantized.predict(inputs, verbose=0) assert outputs.shape[0] == num_samples