Publish via hf-publish-experiment (6b90bfc5d6b6e56b6f85627641280de6f0fa7756)

.gitattributes

@@ -35,3 +35,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
 deit_raspberry_executorch_fp32.pte filter=lfs diff=lfs merge=lfs -text
 deit_raspberry_executorch_optimized.pte filter=lfs diff=lfs merge=lfs -text
+deit_raspberry_executorch_original.pte filter=lfs diff=lfs merge=lfs -text
+sample_input.jpg filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,8 +1,8 @@
 ---
 library_name: executorch
-license: apache-2.0
 base_model: facebook/deit-tiny-patch16-224
 base_model_relation: quantized
+license: apache-2.0
 tags:
   - image-classification
   - deit
@@ -12,7 +12,7 @@ tags:
   - arm
   - executorch
   - edge-ai
-  - imagenet
+  - imagenet-1k
 pipeline_tag: image-classification
 datasets:
   - imagenet-1k
@@ -32,195 +32,185 @@ model-index:
             evaluation_samples: 50000
         metrics:
           - type: accuracy
-            value: 67.62
-            name: Top-1 Accuracy (INT8)
+            value: 71.36
+            name: Top-1 Accuracy (ExecuTorch)
           - type: accuracy
-            value: 88.48
-            name: Top-5 Accuracy (INT8)
+            value: 90.74
+            name: Top-5 Accuracy (ExecuTorch)
 ---
 
 # DeiT-Tiny INT8 (ExecuTorch + XNNPACK)
 
-This is an INT8 symmetric post-training quantized version of [facebook/deit-tiny-patch16-224](https://huggingface.co/facebook/deit-tiny-patch16-224), exported to the ExecuTorch `.pte` format and accelerated with the XNNPACK delegate for deployment on ARM-based edge devices. The model was calibrated on 1,000 ImageNet samples and evaluated on the full 50,000-image ImageNet-1K validation set.
+This is an INT8-quantized version of [facebook/deit-tiny-patch16-224](https://huggingface.co/facebook/deit-tiny-patch16-224) optimized for edge deployment on ARM devices using [ExecuTorch](https://github.com/pytorch/executorch) with the XNNPACK backend. The model was quantized using PT2E static symmetric per-channel quantization and exported to the `.pte` format for efficient inference on ARM Cortex-A processors (Raspberry Pi, mobile ARM, embedded).
 
 ## Key Highlights
 
-- **3.32x smaller** — model file reduced from 22.00 MB (FP32) to 6.62 MB (INT8)
-- **1.34x faster on Raspberry Pi** — latency drops from 34.57 ms to 25.71 ms per image
-- **-1.34 pp Top-1 accuracy** — 67.62% INT8 vs 68.96% FP32 on ImageNet-1K val (50,000 images)
+Compared to the FP32 baseline:
+
+- **3.32x smaller** — 22.00 MB to 6.62 MB (.pte)
+- **1.34x faster** — 35.41 ms to 26.47 ms on Raspberry Pi
+- **Minimal accuracy loss** — -0.78 pp Top-1 Accuracy
 
 ## Model Details
 
 ### Model Description
 
-DeiT-Tiny is a compact Data-efficient Image Transformer trained entirely on ImageNet without extra data. This variant applies INT8 symmetric static quantization via the PT2E (PyTorch 2 Export) pipeline and lowers the quantized graph to ExecuTorch with the XNNPACK delegate. XNNPACK covers 27.70% of operators and accounts for 63.81% of wall-clock inference time on the target device.
+Quantized version of DeiT-Tiny (Data-efficient Image Transformer), a compact vision transformer model trained on ImageNet-1K using knowledge distillation. This INT8 version is optimized for efficient edge inference via PT2E static quantization and the ExecuTorch runtime.
 
-- **Base model developed by:** Meta (FAIR)
-- **Quantized/exported artifact prepared by:** Marvik AI
-- **Model type:** Vision Transformer (ViT/DeiT) — image classification
-- **Base model:** [facebook/deit-tiny-patch16-224](https://huggingface.co/facebook/deit-tiny-patch16-224)
-- **Quantization:** INT8 symmetric, static, post-training (PT2E)
-- **Runtime:** ExecuTorch with XNNPACK delegate
-- **Target hardware:** ARM-based devices (Raspberry Pi, Android, Graviton, embedded)
-- **License:** Apache 2.0
+- **Developed by:** Meta
+- **Model type:** Image Classification
+- **License:** Apache-2.0
+- **Base model:** [facebook/deit-tiny-patch16-224](https://huggingface.co/facebook/deit-tiny-patch16-224) — quantized, not finetuned
 
 ### Model Sources
 
-- **Base model:** https://huggingface.co/facebook/deit-tiny-patch16-224
-- **Original paper:** [Training data-efficient image transformers & distillation through attention (Touvron et al., 2021)](https://arxiv.org/abs/2012.12877)
+- **Repository:** https://huggingface.co/facebook/deit-tiny-patch16-224
 
-## How to Get Started
+## How to Get Started with the Model
 
-### 1. Install dependencies
+### Install dependencies
 
 ```bash
-pip install executorch torchvision pillow
+pip install executorch torch torchvision pillow numpy
 ```
 
-### 2. Download the model
+### Download the model
 
-Download `deit_raspberry_executorch_optimized.pte` and `imagenet_classes.json` from the **Files** tab of this repository, then place them alongside `example.py`.
+```python
+from huggingface_hub import hf_hub_download
+
+model_path = hf_hub_download(
+    repo_id="your-org/deit-tiny-patch16-224-int8-executorch",
+    filename="optimized.pte",
+)
+```
 
-### 3. Run inference
+### Run inference
 
 ```bash
 python example.py
 ```
 
-### Inline example
+Or use the core inference loop directly:
 
 ```python
-"""Minimal inference example for DeiT-Tiny INT8 using ExecuTorch."""
-
-import json
-from pathlib import Path
-
-import torch
 from executorch.runtime import Runtime
 from PIL import Image
 from torchvision import transforms
 
-MODEL_PATH = "deit_raspberry_executorch_optimized.pte"
-IMAGE_PATH = "sample_input.jpg"
-INPUT_SIZE = (224, 224)
-MEAN = [0.485, 0.456, 0.406]
-STD = [0.229, 0.224, 0.225]
-TOP_K = 5
-
-def load_model(pte_path):
-    runtime = Runtime.get()
-    program = runtime.load_program(pte_path)
-    return program.load_method("forward")
-
-def preprocess(image_path):
-    transform = transforms.Compose([
-        transforms.Resize(256),
-        transforms.CenterCrop(INPUT_SIZE),
-        transforms.ToTensor(),
-        transforms.Normalize(mean=MEAN, std=STD),
-    ])
-    image = Image.open(image_path).convert("RGB")
-    return transform(image).unsqueeze(0)
-
-def run_inference(method, input_tensor):
-    outputs = method.execute([input_tensor])
-    return outputs[0]
-
-def postprocess(raw_output, labels):
-    logits = raw_output.squeeze(0)
-    probabilities = torch.softmax(logits, dim=-1)
-    top_probs, top_indices = torch.topk(probabilities, TOP_K)
-    return [{"class": labels[str(idx)], "probability": prob}
-            for prob, idx in zip(top_probs.tolist(), top_indices.tolist())]
-
-def main():
-    script_dir = Path(__file__).parent
-    with open(script_dir / "imagenet_classes.json") as f:
-        labels = json.load(f)
-    method = load_model(str(script_dir / MODEL_PATH))
-    input_tensor = preprocess(str(script_dir / IMAGE_PATH))
-    raw_output = run_inference(method, input_tensor)
-    results = postprocess(raw_output, labels)
-    for i, r in enumerate(results, 1):
-        print(f"  {i}. {r['class']} ({r['probability']*100:.1f}%)")
-
-if __name__ == "__main__":
-    main()
+# Load model
+runtime = Runtime.get()
+program = runtime.load_program("optimized.pte")
+method = program.load_method("forward")
+
+# Preprocess: resize to 256, center-crop 224x224, normalize with ImageNet mean/std
+transform = transforms.Compose([
+    transforms.Resize(256, interpolation=transforms.InterpolationMode.BICUBIC),
+    transforms.CenterCrop((224, 224)),
+    transforms.ToTensor(),
+    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+])
+image = Image.open("input.jpg").convert("RGB")
+input_tensor = transform(image).unsqueeze(0)  # [1, 3, 224, 224]
+
+# Run inference
+outputs = method.execute([input_tensor])
+
+# outputs[0] shape: [1, 1000] — raw class logits
+# Apply softmax for probabilities, then top-k for predictions
+# See example.py for full postprocessing
 ```
 
 ## Evaluation
 
-### Testing Data and Metrics
+### Testing Data, Factors & Metrics
+
+#### Testing Data
+
+Evaluated on 50,000 images from ImageNet-1K val (validation split).
+
+#### Metrics
 
-- **Dataset:** ImageNet-1K validation set
-- **Evaluation samples:** 50,000 images (full validation split)
-- **Calibration samples:** 1,000 ImageNet validation images (random shuffle)
-- **Metrics:** Top-1 Accuracy, Top-5 Accuracy, model file size, on-device latency (Raspberry Pi), peak memory usage
+- **Top-1 Accuracy** — percentage of images where the highest-probability predicted class matches the ground truth label
+- **Top-5 Accuracy** — percentage of images where the ground truth label appears among the top 5 predicted classes
 
 ### Results
 
 #### Accuracy
 
-| Metric | FP32 | INT8 | Delta |
-|---|---|---|---|
-| Top-1 Accuracy | 68.96% | 67.62% | -1.34 pp |
-| Top-5 Accuracy | 89.17% | 88.48% | -0.70 pp |
+| Metric | FP32 (Original) | INT8 (Optimized) | Delta |
+|:---|:---:|:---:|:---:|
+| Top-1 Accuracy (ExecuTorch) | 72.13% | 71.36% | -0.78 pp |
+| Top-5 Accuracy (ExecuTorch) | 91.13% | 90.74% | -0.40 pp |
+| Top-1 Accuracy (PyTorch) | 72.13% | 71.33% | -0.80 pp |
+| Top-5 Accuracy (PyTorch) | 91.13% | 90.76% | -0.37 pp |
 
-#### Efficiency (Raspberry Pi)
+#### Efficiency
 
-| Metric | FP32 | INT8 | Improvement |
-|---|---|---|---|
-| Model size (.pte) | 22.00 MB | 6.62 MB | 3.32x smaller |
-| Inference latency | 34.57 ms | 25.71 ms | 1.34x faster |
-| Peak memory | 33.58 MB | 18.47 MB | 1.82x lower |
+| Metric | FP32 (Original) | INT8 (Optimized) | Improvement |
+|:---|:---:|:---:|:---:|
+| Model Size (.pte) | 22.00 MB | 6.62 MB | **3.32x smaller** |
+| Raspberry Pi Latency (mean) | 35.41 ms | 26.47 ms | **1.34x faster** |
+| Raspberry Pi Latency (p50) | 35.34 ms | 26.40 ms | **1.34x faster** |
+| Raspberry Pi Latency (p90) | 35.48 ms | 26.60 ms | **1.33x faster** |
+| Raspberry Pi Peak Memory (USS) | 31.16 MB | 18.38 MB | **1.70x less** |
+| Raspberry Pi Median Memory (USS) | 31.02 MB | 16.14 MB | **1.92x less** |
 
 ## Technical Specifications
 
 ### Objective
 
-Reduce model size and inference latency of DeiT-Tiny for deployment on resource-constrained ARM devices while preserving ImageNet classification accuracy within an acceptable margin.
+1000-class image classification on ImageNet using a compact vision transformer (ViT) architecture trained with knowledge distillation.
 
 ### Quantization
 
-- **Method:** Post-training static quantization (PTQ), INT8 symmetric
-- **Framework:** PT2E (PyTorch 2 Export) quantization pipeline
-- **Calibration:** 1,000 randomly sampled ImageNet validation images
-- **Granularity:** Per-channel for weights, per-tensor for activations
-- **Layers kept in FP32:** `patch_embeddings` on the current ExecuTorch/XNNPACK recipe
-- **Delegate:** XNNPACK (covers 27.70% of operators, 63.81% of wall-clock time)
+- **Method**: PT2E Static Quantization via XNNPACKQuantizer
+- **Precision**: INT8 symmetric, per-channel
+- **Backend**: XNNPACK
+- **Layers kept in FP32**: patch embeddings (`patch_embeddings`) — quantized patch-embedding attention patterns produce static transpose nodes that XNNPACK cannot compile
+- **Calibration**: 1,000 images from ImageNet-1K val
 
 ### Export Pipeline
 
-1. The FP32 model is captured via `torch.export` to produce a portable FX graph.
-2. XNNPACK-aware observers are inserted and calibrated on 1,000 ImageNet validation samples.
-3. Observers are converted to INT8 quantize/dequantize (Q/DQ) pairs.
-4. The quantized graph is lowered to ExecuTorch `.pte` format with the XNNPACK delegate.
+1. Load pretrained FP32 DeiT-Tiny model from HuggingFace
+2. Wrap model to produce a single logits tensor output
+3. Capture model graph via `torch.export` (with `aten.linear` kept intact for XNNPACK delegation)
+4. Insert quantization observers (XNNPACKQuantizer, per-op mode, skip patch embeddings)
+5. Calibrate with representative data
+6. Convert observers to Q/DQ pairs
+7. Export to ExecuTorch `.pte` with XNNPACK backend
 
 ### Preprocessing
 
-Inputs must be preprocessed before being passed to the model:
-
-| Step | Parameters |
+| Property | Value |
 |---|---|
-| Resize (shorter side) | 256 px |
-| Center crop | 224 × 224 px |
-| To tensor | Scales pixel values to [0.0, 1.0] |
-| Normalize | mean = [0.485, 0.456, 0.406], std = [0.229, 0.224, 0.225] |
+| Input shape | `[1, 3, 224, 224]` (BCHW) |
+| Data type | float32 |
+| Value range | [0.0, 1.0] |
+| Color space | RGB |
+
+**Steps**:
+1. Resize shortest edge to 256 px (bicubic interpolation)
+2. Center-crop to 224×224
+3. Convert to tensor (`ToTensor()`: [0–255] uint8 → [0, 1] float32)
+4. Normalize with ImageNet mean `[0.485, 0.456, 0.406]` and std `[0.229, 0.224, 0.225]`
 
-- **Input shape:** `[1, 3, 224, 224]` (batch × channels × height × width)
-- **Input dtype:** `float32`
+**Normalization**: ImageNet mean/std normalization is required.
 
 ### Postprocessing
 
-The model outputs raw class logits of shape `[1, 1000]` (one logit per ImageNet class). To obtain class probabilities:
+| Property | Value |
+|---|---|
+| Output shape | `[1, 1000]` |
+| Output format | Raw class logits (unnormalized) |
 
-1. Apply `softmax` along the class dimension.
-2. Take `top-k` (k = 5) to retrieve the most likely classes.
+**Steps**:
+1. Squeeze batch dimension: `[1000]` logit vector
+2. Apply softmax to obtain class probabilities
+3. Take top-k (default: 5) predicted classes by probability
 
 ## Known Limitations
 
-- **Fixed input resolution:** The model expects exactly 224 × 224 inputs. Images of different sizes must be resized and cropped prior to inference.
-- **ImageNet classes only:** The model was trained and evaluated on ImageNet-1K (1,000 classes). It is not suitable for out-of-distribution domains without fine-tuning.
-- **Latency figures are Raspberry Pi-specific:** The speedup of 1.34x was measured on a Raspberry Pi using the ExecuTorch XNNPACK runtime. Results on other ARM devices (Android, AWS Graviton, embedded MCUs) may differ.
-- **INT8 accuracy drop:** A -1.34 pp Top-1 regression is typical for static PTQ on ViT-family models. Tasks requiring higher accuracy may benefit from quantization-aware training (QAT) or a larger DeiT variant.
-- **XNNPACK coverage:** 27.70% of operators are delegated to XNNPACK. Remaining operators run on the ExecuTorch portable kernel, which may limit speedup compared to a fully delegated CNN.
+- Evaluated on the full 50,000-image ImageNet-1K validation set
+- Fixed input size of 224×224 — images are resized without preserving aspect ratio
+- XNNPACK operator coverage is 27.7% (by operator count); attention and layer norm operations fall back to the ExecuTorch portable kernel

benchmarks/deit-tiny-raspberrypi5-fp32.yaml

@@ -2,29 +2,32 @@
 # Pairs with `deit-tiny-raspberrypi5-int8.yaml` to demonstrate the
 # baseline-comparison join documented in `docs/header-and-generic.md`.
 #
-# Source: Marvik delivery package `deit_raspberry_executorch.zip`, `report.json`
-# `original` fields (the un-quantised baseline measured under identical
-# target / runtime / dataset / benchmark conditions to the optimised record).
+# Source: Marvik delivery package `deit_raspberry_executorch_v2.zip`,
+# `report.json` `original` fields (the un-quantised baseline measured under
+# identical target / runtime / dataset / benchmark conditions to the
+# optimised record). Refreshed from v1 after a preprocessing fix on Marvik's
+# side (bicubic + ImageNet mean/std, replacing bilinear + 0.5/0.5) restored
+# the FP32 baseline to the paper-reported ~72.13% Top-1.
 #
 # Same target / runtime / dataset / benchmark as the INT8 record —
 # disambiguator is `weight_dtype`, and (once published) `model.id`.
 #
-# Known unknowns (Marvik pipeline does not currently surface these):
-#   - context.benchmark.num_runs            — required by schema; placeholder used
-#   - context.benchmark.warmup_runs         — optional
-#   - context.runtime.version               — optional but worth recording
-#   - context.target.os_version             — optional
-#   - context.runtime.config.n_threads      — optional
-#   - context.model.baseline_checksum       — optional
+# Hand-curated rather than redelivered: Marvik's pipeline only emits the
+# optimised YAML, so this file is reconstructed from `report.json` on each
+# refresh. Inline annotations here are durable.
+#
+# Outstanding unknowns:
+#   - context.runtime.config.n_threads      — in flight, Marvik working on it (2026-05)
+#   - performance.end_to_end_latency_ms.p99 — in flight, Marvik working on it (2026-05)
+#   - context.model.baseline_checksum       — optional; not yet surfaced, no ETA
 #   - context.model.base_model_revision     — not yet a schema field; pinning
 #                                             this artefact to a HF revision SHA
 #                                             would close the last reproducibility
 #                                             gap on the baseline.
-#   - performance.end_to_end_latency_ms.p99 — optional; only p50/p90 reported
 
 version: 1.0.0
 task: vision-classification
-created_at: '2026-04-22T22:43:46Z'
+created_at: '2026-05-04T16:01:20Z'
 context:
   model:
     id: facebook/deit-tiny-patch16-224
@@ -43,30 +46,33 @@ context:
     cpu_clock_ghz: 2.4
     system_memory_gb: 8
     os: linux
+    os_version: Raspberry Pi OS
   runtime:
     name: executorch
     execution_backend: cpu
+    version: 1.1.0
     config:
       optimisations:
-      - XNNPACK
-      - KleidiAI
+        - XNNPACK
+        - KleidiAI
   dataset:
-    name: imagenet-1k
-    version: '1.0'
-    slice: validation
+    name: ImageNet-1k
+    slice: val
     sample_count: 50000
-    reference_url: https://image-net.org
+    reference_url: https://www.image-net.org/
   benchmark:
     batch_size: 1
     input_resolution: 224x224
-    num_runs: 1  # PLACEHOLDER — not surfaced by Marvik pipeline; schema requires this field
+    num_runs: 100
+    warmup_runs: 10
 performance:
   end_to_end_latency_ms:
-    p50: 34.54
-    p90: 34.67
-  peak_memory_mb: 33.58
-  average_memory_mb: 31.08
-  cold_start_time_ms: 52.39
+    p50: 35.34
+    p90: 35.48
+  peak_memory_mb: 31.156
+  average_memory_mb: 31.016
+  cold_start_time_ms: 56.41
+  model_load_time_ms: 19.27
 accuracy:
-  top_1_accuracy_pct: 68.96
-  top_5_accuracy_pct: 89.17
+  top_1_accuracy_pct: 72.132
+  top_5_accuracy_pct: 91.134

benchmarks/deit-tiny-raspberrypi5-int8.yaml

@@ -1,34 +1,12 @@
-# Real measurement record — DeiT-Tiny INT8 on Raspberry Pi 5 via ExecuTorch + XNNPACK.
-# Source: Marvik delivery package `deit_raspberry_executorch.zip`, files
-#   - report.json (machine-readable metrics)
-#   - metadata.yaml (Marvik's portal metadata, now superseded by these schemas)
-#   - huggingface/README.md (recipe prose)
-#
-# Known unknowns (Marvik pipeline does not currently surface these):
-#   - context.benchmark.num_runs            — required by schema; placeholder used
-#   - context.benchmark.warmup_runs         — optional
-#   - context.runtime.version               — optional but worth recording
-#   - context.target.os_version             — optional
-#   - context.runtime.config.n_threads      — optional
-#   - context.model.baseline_checksum       — optional
-#   - performance.end_to_end_latency_ms.p99 — optional; only p50/p90 reported
-#
-# Mapping notes:
-#   - cold_start_time_ms holds Marvik's "Time To First Inference" (37.39 ms — process
-#     start to first output completing). Marvik separately reports "Cold Start" (21.84 ms,
-#     process startup before any inference); this is not a separate schema field.
-#   - base_model_id and id are identical here because the artefact is not yet uploaded
-#     under arm/<slug>. Once published, id becomes the arm/* identifier and base_model_id
-#     remains facebook/deit-tiny-patch16-224.
-
 version: 1.0.0
 task: vision-classification
-created_at: '2026-04-22T22:43:46Z'
+created_at: '2026-05-04T16:01:20Z'
 context:
   model:
     id: facebook/deit-tiny-patch16-224
     base_model_id: facebook/deit-tiny-patch16-224
     weight_dtype: int8
+    profile: Arm-Optimized
     quantization:
       method: PTQ-static
       weight_bits: 8
@@ -37,12 +15,11 @@ context:
       mode: static
       weight_granularity: per-channel
       fp32_layers:
-      - patch_embeddings
+        - patch_embeddings
     calibration:
-      dataset_name: imagenet-1k
+      dataset_name: ImageNet-1k
       sample_count: 1000
       selection: random
-    profile: Arm-Optimized
     model_size_mb: 6.62
     parameter_count: 5717416
     format: pte
@@ -55,32 +32,35 @@ context:
     cpu_clock_ghz: 2.4
     system_memory_gb: 8
     os: linux
+    os_version: Raspberry Pi OS
   runtime:
     name: executorch
     execution_backend: cpu
+    version: 1.1.0
     config:
       optimisations:
-      - XNNPACK
-      - KleidiAI
+        - XNNPACK
+        - KleidiAI
   dataset:
-    name: imagenet-1k
-    version: '1.0'
-    slice: validation
+    name: ImageNet-1k
+    slice: val
     sample_count: 50000
-    reference_url: https://image-net.org
+    reference_url: https://www.image-net.org/
   benchmark:
     batch_size: 1
     input_resolution: 224x224
-    num_runs: 1  # PLACEHOLDER — not surfaced by Marvik pipeline; schema requires this field
+    num_runs: 100
+    warmup_runs: 10
 performance:
   end_to_end_latency_ms:
-    p50: 25.65
-    p90: 25.84
-  peak_memory_mb: 18.47
-  delegation_pct: 63.81
-  average_memory_mb: 16.21
-  cold_start_time_ms: 37.39
-  frames_per_second: 38.90
+    p50: 26.40
+    p90: 26.60
+  peak_memory_mb: 18.375
+  delegation_pct: 64.02
+  average_memory_mb: 16.14
+  cold_start_time_ms: 40.64
+  model_load_time_ms: 22.71
+  frames_per_second: 37.78
 accuracy:
-  top_1_accuracy_pct: 67.62
-  top_5_accuracy_pct: 88.48
+  top_1_accuracy_pct: 71.356
+  top_5_accuracy_pct: 90.738

config.yaml

@@ -3,9 +3,9 @@ input:
   dtype: float32
   range: [0.0, 1.0]
   preprocessing:
-    - resize: 256
+    - resize: 256          # bicubic interpolation (shortest edge)
     - center_crop: [224, 224]
-    - to_tensor
+    - to_tensor            # [0-255] uint8 -> [0.0, 1.0] float32
     - normalize:
         mean: [0.485, 0.456, 0.406]
         std: [0.229, 0.224, 0.225]

deit_raspberry_executorch_optimized.pte

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:c749ec3bb0ffabdf4b0364ef6020b28e5b4ea3897706a45f7fff24d571890205
+oid sha256:4656bb08f25ceafd3945debd69d27fd4cbeff5b9be04828e6d057f1c24fcc0d0
 size 6941472

deit_raspberry_executorch_original.pte

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a2f06e1355d83b6d38c11bd7423cdd847e17a7c36b6d41128a1613ef347dc2cc
+size 23073184

example.py

@@ -1,4 +1,8 @@
-"""Minimal inference example for DeiT-Tiny INT8 using ExecuTorch."""
+"""Minimal inference example for DeiT-Tiny INT8 using ExecuTorch.
+
+Loads a quantized .pte model and runs inference on a single image,
+printing the top-5 ImageNet class predictions with probabilities.
+"""
 
 import json
 from pathlib import Path
@@ -8,75 +12,103 @@ from executorch.runtime import Runtime
 from PIL import Image
 from torchvision import transforms
 
-# Configuration
-MODEL_PATH = "deit_raspberry_executorch_optimized.pte"
+
+# ── Configuration ──────────────────────────────────────────────────────────────
+MODEL_PATH = "optimized.pte"
 IMAGE_PATH = "sample_input.jpg"
 INPUT_SIZE = (224, 224)
+RESIZE_SIZE = 256  # resize shorter edge before center crop
 MEAN = [0.485, 0.456, 0.406]
 STD = [0.229, 0.224, 0.225]
 TOP_K = 5
 
 
+# ── Model Loading ──────────────────────────────────────────────────────────────
 def load_model(pte_path: str):
+    """Load ExecuTorch .pte model and return the forward method."""
     runtime = Runtime.get()
     program = runtime.load_program(pte_path)
     return program.load_method("forward")
 
 
+# ── Preprocessing ──────────────────────────────────────────────────────────────
 def preprocess(image_path: str) -> torch.Tensor:
-    transform = transforms.Compose([
-        transforms.Resize(256),
-        transforms.CenterCrop(INPUT_SIZE),
-        transforms.ToTensor(),
-        transforms.Normalize(mean=MEAN, std=STD),
-    ])
+    """Load and preprocess image for model input.
+
+    Pipeline:
+      1. Resize shortest edge to 256 px (bicubic)
+      2. Center-crop to 224x224
+      3. Convert to float32 tensor in [0, 1]
+      4. Normalize with ImageNet mean/std
+    """
+    transform = transforms.Compose(
+        [
+            transforms.Resize(
+                RESIZE_SIZE, interpolation=transforms.InterpolationMode.BICUBIC
+            ),
+            transforms.CenterCrop(INPUT_SIZE),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=MEAN, std=STD),
+        ]
+    )
     image = Image.open(image_path).convert("RGB")
     tensor = transform(image)
-    return tensor.unsqueeze(0)
+    return tensor.unsqueeze(0)  # [1, 3, 224, 224]
 
 
+# ── Inference ──────────────────────────────────────────────────────────────────
 def run_inference(method, input_tensor: torch.Tensor) -> torch.Tensor:
+    """Run forward pass and return the raw logits tensor."""
     outputs = method.execute([input_tensor])
     return outputs[0]
 
 
+# ── Postprocessing ─────────────────────────────────────────────────────────────
 def postprocess(raw_output: torch.Tensor, labels: dict) -> list[dict]:
-    logits = raw_output.squeeze(0)
+    """Convert raw logits to top-k class predictions.
+
+    Applies softmax over the 1000-class logit vector, then returns the
+    top-k (class name, probability) pairs sorted by descending probability.
+    """
+    logits = raw_output.squeeze(0)  # [1000]
     probabilities = torch.softmax(logits, dim=-1)
     top_probs, top_indices = torch.topk(probabilities, TOP_K)
-    results = []
-    for prob, idx in zip(top_probs.tolist(), top_indices.tolist()):
-        results.append({
-            "class": labels[str(idx)],
-            "probability": prob,
-        })
-    return results
+    return [
+        {"class": labels[str(idx.item())], "probability": round(prob.item(), 6)}
+        for prob, idx in zip(top_probs, top_indices, strict=False)
+    ]
 
 
+# ── Save Results ───────────────────────────────────────────────────────────────
 def save_results(results: list[dict], script_dir: Path) -> None:
+    """Save top-k predictions to predictions.json in the script's directory."""
     output_path = script_dir / "predictions.json"
     with open(output_path, "w") as f:
         json.dump(results, f, indent=2)
+    print(f"Saved predictions to {output_path}")
 
 
+# ── Main ───────────────────────────────────────────────────────────────────────
 def main() -> None:
     script_dir = Path(__file__).parent
 
+    # Load ImageNet class labels
     labels_path = script_dir / "imagenet_classes.json"
     with open(labels_path) as f:
         labels = json.load(f)
 
+    # Load model, run inference, decode results
     method = load_model(str(script_dir / MODEL_PATH))
     input_tensor = preprocess(str(script_dir / IMAGE_PATH))
     raw_output = run_inference(method, input_tensor)
     results = postprocess(raw_output, labels)
 
-    print("Top-5 predictions:")
+    # Print top-k predictions
+    print(f"Top-{TOP_K} predictions:")
     for i, r in enumerate(results, 1):
-        print(f"  {i}. {r['class']} ({r['probability'] * 100:.1f}%)")
+        print(f"  {i}. {r['class']} ({r['probability'] * 100:.2f}%)")
 
     save_results(results, script_dir)
-    print(f"Saved predictions.json to {script_dir / 'predictions.json'}")
 
 
 if __name__ == "__main__":

metadata.yaml

@@ -0,0 +1,80 @@
+# AI Portal Model Discovery Metadata
+# Generated by ARM Model Optimization Pipeline
+# Commented fields require manual input.
+
+hardware:
+  # device: <hardware platform, e.g. Raspberry Pi, Graviton>
+  # arm_ip: <Arm IP, e.g. SME, NGP>
+  # classification: <Mobile, IoT, Server, GPU>
+  # mlia_profile: <MLIA configuration for the hardware>
+  # memory: <available memory on device, e.g. 4GB>
+
+model_metadata:
+  origin: "https://huggingface.co/facebook/deit-tiny-patch16-224"
+  name: "Deit Tiny Patch16 224"
+  organisation: "Meta"
+  display_name: "facebook/deit-tiny-patch16-224"
+  filepath: "optimized.pte"
+  model_use_case: "Vision"
+  model_runtime: "ExecuTorch"
+  library: "transformers"
+  model_size: 6619903
+  vendor: "Meta"
+  precision: "INT8"
+  model_framework: "PyTorch"
+  base_model_relationship: "Quantised"
+  training_dataset: "ImageNet-1K"
+  training_dataset_license: "ImageNet Terms of Access"
+  # base_model: <base model this artefact is derived from>
+  # license: <SPDX ID, e.g. Apache-2.0>
+  # license_url: <URL to license if non-standard>
+  # deployment_license: <SPDX ID for production deployment>
+  # language: <supported language(s)>
+  # short_description: <summary for UI grid>
+  # long_description: <full model description>
+
+model_performance:
+  analyser_type: "Hardware"
+  device: "Raspberry Pi"
+  compatible: true
+  # device: <hardware profile used during testing>
+  # analyser: <tool used to analyse the model>
+  # average_cpu_utilisation: <CPU utilisation % during inference>
+  # tosa_compliance: <TOSA compliance score>
+  # energy: <energy consumption in W>
+
+latency:
+  # single_inference_latency: <latency in ms>
+  # single_inference_throughput: <throughput in inf/s>
+  # batch_size: <batch size used in analysis>
+  # batch_latency: <batch inference latency in ms>
+  # batch_throughput: <batch throughput in inf/s>
+  # max_throughput_batch_size: <batch size achieving peak throughput>
+  # max_throughput_latency: <latency at max throughput in ms>
+  # max_throughput: <maximum throughput in inf/s>
+  # sustained_batch_size: <batch size under sustained load>
+  # sustained_batch_latency: <latency under sustained load in ms>
+  # sustained_batch_throughput: <sustained throughput in inf/s>
+
+memory:
+  model_weight_memory: 6.62
+  # runtime_overhead: <runtime memory overhead in MB>
+  # runtime_overhead_power: <runtime power usage in W>
+  # peak_activation_memory: <peak activation memory in MB>
+  # peak_activation_power: <peak power usage in W>
+  # idle_state_memory: <memory usage when idle in MB>
+  # idle_state_power: <power usage when idle in W>
+  # average_memory: <average runtime memory in MB>
+  # average_power: <average runtime power in W>
+
+model_accuracy:
+  - name: "ImageNet"
+    url: "https://image-net.org"
+    value: 71.36
+    evaluation_criteria: "Top-1 Accuracy"
+    base_accuracy: 72.13
+  - name: "ImageNet"
+    url: "https://image-net.org"
+    value: 90.74
+    evaluation_criteria: "Top-5 Accuracy"
+    base_accuracy: 91.13

predictions.json

@@ -1,22 +1,22 @@
 [
   {
-    "class": "sea slug, nudibranch",
-    "probability": 0.17416588962078094
+    "class": "vault",
+    "probability": 0.686802
   },
   {
-    "class": "goldfish, Carassius auratus",
-    "probability": 0.17416588962078094
+    "class": "altar",
+    "probability": 0.027809
   },
   {
-    "class": "flatworm, platyhelminth",
-    "probability": 0.10024614632129669
+    "class": "monastery",
+    "probability": 0.026528
   },
   {
-    "class": "conch",
-    "probability": 0.041422367095947266
+    "class": "church, church building",
+    "probability": 0.026528
   },
   {
-    "class": "hammerhead, hammerhead shark",
-    "probability": 0.032009851187467575
+    "class": "dome",
+    "probability": 0.010829
   }
 ]