Sync model repo (text/metadata)

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+sample_output.png filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,210 @@
+---
+library_name: executorch
+display_name: ESRGAN x4 INT8 — ExecuTorch + XNNPACK
+license: apache-2.0
+base_model: kadirnar/RRDB_PSNR_x4
+base_model_relation: quantized
+tags:
+  - image-to-image
+  - esrgan
+  - int8
+  - quantized
+  - xnnpack
+  - arm
+  - executorch
+  - edge-ai
+  - urban100
+  - super-resolution
+pipeline_tag: image-to-image
+datasets:
+  - urban100
+metrics:
+  - psnr
+model-index:
+  - name: esrgan-int8-xnnpack-executorch-graviton-g4
+    results:
+      - task:
+          type: image-to-image
+          name: Super Resolution
+        dataset:
+          type: urban100
+          name: Urban100
+          split: validation
+          args:
+            evaluation_samples: 100
+        metrics:
+          - type: psnr
+            value: 26.81
+            name: PSNR (dB)
+---
+
+# ESRGAN x4 INT8 (ExecuTorch + XNNPACK)
+
+This is an INT8-quantized version of [ESRGAN RRDBNet](https://github.com/xinntao/ESRGAN) 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 (AWS Graviton, mobile ARM, embedded).
+
+The PSNR-oriented weights (`RRDB_PSNR_x4.pth`) from [kadirnar/RRDB_PSNR_x4](https://huggingface.co/kadirnar/RRDB_PSNR_x4) are used — the L1-trained high-PSNR variant whose metrics are directly comparable to standard SR benchmark figures.
+
+## Key Highlights
+
+Compared to the FP32 baseline:
+
+- **2.76x smaller** — 64.07 MB to 23.18 MB
+- **2.44x faster** — 1763 ms to 724 ms on AWS Graviton (Neoverse-V2)
+- **Minimal quality loss** — −0.22 dB PSNR on Urban100
+
+## Model Details
+
+### Model Description
+
+Quantized version of ESRGAN (Enhanced Super-Resolution Generative Adversarial Network) with a 23-block RRDBNet backbone. The model performs 4x bicubic super-resolution on urban scene images, optimized for efficient edge inference via INT8 quantization and the ExecuTorch runtime.
+
+- **Developed by:** Xintao Wang et al. (ESRGAN), Marvik AI (quantization & optimization)
+- **Model type:** Super Resolution (4x upscaling)
+- **License:** Apache-2.0
+- **Base model:** [ESRGAN RRDBNet](https://github.com/xinntao/ESRGAN) — quantized, not finetuned
+
+### Model Sources
+
+- **Repository:** https://github.com/xinntao/ESRGAN
+- **Pretrained weights:** https://huggingface.co/kadirnar/RRDB_PSNR_x4
+
+## How to Get Started with the Model
+
+### Install dependencies
+
+```bash
+pip install executorch torch torchvision pillow numpy
+```
+
+### Download the model
+
+```python
+from huggingface_hub import hf_hub_download
+
+model_path = hf_hub_download(
+    repo_id="Arm/esrgan-int8-xnnpack-executorch-graviton-g4",
+    filename="esrgan-x4-int8-executorch.pte",
+)
+```
+
+### Run inference
+
+```bash
+python example.py
+```
+
+Or use the core inference loop directly:
+
+```python
+from executorch.runtime import Runtime
+from PIL import Image
+from torchvision import transforms
+
+# Load model
+runtime = Runtime.get()
+program = runtime.load_program("esrgan-x4-int8-executorch.pte")
+method = program.load_method("forward")
+
+# Preprocess (no normalization — model expects raw [0, 1] values)
+image = Image.open("input.jpg").convert("RGB")
+to_tensor = transforms.ToTensor()
+input_tensor = to_tensor(image).unsqueeze(0)  # [1, 3, H, W]
+
+# Run a single 128x128 tile
+tile = input_tensor[:, :, :128, :128]
+outputs = method.execute([tile])
+# outputs[0] shape: [1, 3, 512, 512] — the 4x super-resolved tile
+# See example.py for full tiled inference on arbitrary-size images
+```
+
+## Evaluation
+
+### Testing Data, Factors & Metrics
+
+#### Testing Data
+
+Evaluated on 100 images from Urban100 (validation split). Urban100 is a standard super-resolution benchmark consisting of urban scenes with repetitive structures, specifically chosen to challenge SR models on fine detail reconstruction.
+
+#### Metrics
+
+- **PSNR (Peak Signal-to-Noise Ratio, dB)** — measures pixel-level fidelity between the super-resolved output and the ground-truth high-resolution image; higher is better
+- **SSIM (Structural Similarity Index)** — measures perceived structural similarity; higher is better
+
+### Results
+
+#### Quality
+
+| Metric | FP32 (Original) | INT8 (Optimized) | Delta |
+|:---|:---:|:---:|:---:|
+| PSNR (dB) | 27.03 | 26.81 | −0.22 dB |
+| SSIM | 0.8176 | 0.8109 | −0.007 |
+
+#### Efficiency
+
+| Metric | FP32 (Original) | INT8 (Optimized) | Improvement |
+|:---|:---:|:---:|:---:|
+| Model Size (.pte) | 64.07 MB | 23.18 MB | **2.76x smaller** |
+| Graviton Latency (mean) | 1763 ms | 724 ms | **2.44x faster** |
+| Graviton Latency (p50) | 1763 ms | 704 ms | **2.50x faster** |
+| Graviton Latency (p90) | 1765 ms | 780 ms | **2.26x faster** |
+| Graviton Cold Start | 66.3 ms | 36.7 ms | **1.81x faster** |
+
+*Latency measured on AWS Graviton G4 (Neoverse-V2, 16 cores) with ExecuTorch 1.1.0, XNNPACK + KleidiAI backend, batch size 1, 10 warmup runs + 100 measurement runs.*
+
+## Technical Specifications
+
+### Objective
+
+4x single-image super-resolution from bicubic-degraded low-resolution inputs, targeting urban scenes with repetitive structures.
+
+### Quantization
+
+- **Method**: PT2E Static Quantization via XNNPACKQuantizer
+- **Precision**: INT8 symmetric, per-channel
+- **Backend**: XNNPACK
+- **Layers kept in FP32**: upsampling layers (`upconv1`, `upconv2`, `HRconv`, `conv_last`) and the first 3 RRDB body blocks (`body.0`–`body.2`) to preserve output fidelity
+- **Calibration**: 100 images from Urban100 (random subset, patch mode)
+
+### Export Pipeline
+
+1. Load pretrained FP32 RRDBNet with PSNR-oriented weights from HuggingFace (`kadirnar/RRDB_PSNR_x4`)
+2. Capture model graph via `torch.export` at fixed 128×128 tile size
+3. Insert quantization observers (XNNPACKQuantizer, skipping upsampling + first 3 body blocks)
+4. Calibrate with 100 Urban100 patches
+5. Convert observers to Q/DQ pairs
+6. Post-quantization graph surgery (remove spurious Q/DQ pairs from `cat` nodes in FP32 body blocks)
+7. Export to ExecuTorch `.pte` with XNNPACK backend
+
+### Preprocessing
+
+| Property | Value |
+|---|---|
+| Input shape | `[1, 3, 128, 128]` (BCHW, single tile) |
+| Data type | float32 |
+| Value range | [0.0, 1.0] |
+| Color space | RGB |
+
+**Steps**:
+1. Convert PIL image to float32 tensor via `ToTensor()` (maps [0, 255] → [0, 1])
+2. For images larger than 128×128: split into overlapping 128×128 tiles with 8-pixel overlap; each tile is processed independently
+
+**Normalization**: None required — the model expects raw [0, 1] pixel values.
+
+### Postprocessing
+
+| Property | Value |
+|---|---|
+| Output shape | `[1, 3, 512, 512]` per tile (4x upscaled) |
+| Output format | Float32 RGB tensor, values may exceed [0, 1] before clamping |
+
+**Steps**:
+1. Clamp output tensor to [0, 1]
+2. For tiled inputs: accumulate tile outputs into a full-resolution canvas, averaging overlapping regions
+3. Convert to uint8 for saving (`* 255`, round, cast)
+
+## Known Limitations
+
+- Evaluated on 100 images from Urban100 — a benchmark focused on urban/architectural scenes; performance on natural landscapes or faces may differ
+- Fixed tile size of 128×128: images must be at least 128×128; the tiling inference handles arbitrary sizes automatically
+- Input images are not aspect-ratio padded — tiles are extracted at stride `tile_size - overlap` with edge tiles placed at the image boundary
+- XNNPACK operator coverage is approximately 49%: upsampling, LeakyReLU, and some transpose operations fall back to non-XNNPACK kernels; latency figures reflect this mixed execution

benchmarks/esrgan-graviton-g4-fp32.yaml

@@ -0,0 +1,35 @@
+version: 1.0.0
+report_type: image-to-image
+profile: Baseline
+created_at: '2026-07-09T19:02:52Z'
+context:
+  target_ref: aws-graviton-g4-16-core
+  runtime:
+    name: executorch
+    execution_backend: cpu
+    config:
+      optimisations:
+      - XNNPACK
+      - KleidiAI
+    version: 1.1.0
+  dataset:
+    name: urban100
+    sample_count: 100
+  benchmark:
+    batch_size: 1
+    input_resolution: 128x128x3
+    num_runs: 100
+    warmup_runs: 10
+performance:
+  end_to_end_latency_ms:
+    p50: 1762.73
+    p90: 1764.721
+    p99: 1771.111
+  model_load_time_ms: 66.291
+  time_to_first_inference_ms: 1968.651
+  peak_memory_mb: 799.74
+  average_memory_mb: 797.35
+  frames_per_second: 0.57
+accuracy:
+  psnr_db: 27.03
+  ssim: 0.8176

benchmarks/esrgan-graviton-g4-int8.yaml

@@ -0,0 +1,36 @@
+version: 1.0.0
+report_type: image-to-image
+profile: Arm-Optimized
+created_at: '2026-06-02T23:36:48Z'
+context:
+  target_ref: aws-graviton-g4-16-core
+  runtime:
+    name: executorch
+    execution_backend: cpu
+    config:
+      optimisations:
+      - XNNPACK
+      - KleidiAI
+    version: 1.1.0
+  dataset:
+    name: urban100
+    sample_count: 100
+  benchmark:
+    batch_size: 1
+    input_resolution: 128x128x3
+    num_runs: 100
+    warmup_runs: 10
+performance:
+  end_to_end_latency_ms:
+    p50: 704.416
+    p90: 779.704
+    p99: 819.723
+  model_load_time_ms: 36.666
+  time_to_first_inference_ms: 906.879
+  peak_memory_mb: 795.07
+  average_memory_mb: 754.93
+  frames_per_second: 1.42
+  delegation_pct: 97.62
+accuracy:
+  psnr_db: 26.81
+  ssim: 0.8109

config.yaml

@@ -0,0 +1,17 @@
+input:
+  shape: [1, 3, 128, 128]
+  dtype: float32
+  range: [0.0, 1.0]
+  color_space: RGB
+  preprocessing:
+    - to_tensor           # PIL RGB -> [0, 1] float32 tensor
+    - tile_size: [128, 128]  # model processes 128x128 tiles; larger images are tiled automatically
+
+output:
+  shape: [1, 3, 512, 512]   # 4x upscaled (128 * 4 = 512)
+  dtype: float32
+  range: [0.0, 1.0]
+  postprocessing:
+    - clamp: [0.0, 1.0]     # raw output clamped to valid pixel range
+    - scale: 4              # spatial upscale factor
+    - tiling_overlap: 8     # pixel overlap between adjacent tiles (blended by averaging)

example.py

@@ -0,0 +1,139 @@
+"""Minimal inference example for ESRGAN 4x Super-Resolution using ExecuTorch.
+
+Loads a quantized .pte model and runs super-resolution inference on a single image.
+The model upscales the input image by 4x. For images larger than 128x128, the
+input is automatically split into overlapping tiles, each tile is super-resolved,
+and the results are blended and stitched into the final output.
+"""
+
+import json
+from pathlib import Path
+
+import numpy as np
+import torch
+from executorch.runtime import Runtime
+from PIL import Image
+from torchvision import transforms
+
+# ── Configuration ──────────────────────────────────────────────────────────────
+MODEL_PATH = "esrgan-x4-int8-executorch.pte"
+IMAGE_PATH = "sample_input.jpg"
+TILE_SIZE = 128       # model was exported with 128x128 input tiles
+SCALE = 4             # 4x upscaling factor
+TILE_OVERLAP = 8      # pixel overlap between tiles for seamless blending
+
+
+# ── 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) -> tuple[torch.Tensor, tuple[int, int]]:
+    """Load and preprocess image for model input.
+
+    The model expects [0, 1] float32 RGB tensors — no normalization is applied.
+    Returns the input tensor and the original image size for reference.
+    """
+    image = Image.open(image_path).convert("RGB")
+    original_size = (image.width, image.height)
+    to_tensor = transforms.ToTensor()  # converts [0-255] uint8 -> [0, 1] float32
+    input_tensor = to_tensor(image).unsqueeze(0)  # [1, 3, H, W]
+    return input_tensor, original_size
+
+
+# ── Tiled Inference ────────────────────────────────────────────────────────────
+def run_tiled_inference(method, input_tensor: torch.Tensor) -> torch.Tensor:
+    """Run super-resolution inference with overlapping tile stitching.
+
+    Splits the input into overlapping 128x128 tiles, runs each through the
+    model, and blends overlapping regions using pixel-level averaging.
+    """
+    _, _, h, w = input_tensor.shape
+    out_h, out_w = h * SCALE, w * SCALE
+
+    output = torch.zeros(1, 3, out_h, out_w)
+    weights = torch.zeros(1, 1, out_h, out_w)
+
+    stride = TILE_SIZE - TILE_OVERLAP
+
+    y_positions = list(range(0, max(1, h - TILE_SIZE + 1), stride))
+    if not y_positions or y_positions[-1] + TILE_SIZE < h:
+        y_positions.append(max(0, h - TILE_SIZE))
+
+    x_positions = list(range(0, max(1, w - TILE_SIZE + 1), stride))
+    if not x_positions or x_positions[-1] + TILE_SIZE < w:
+        x_positions.append(max(0, w - TILE_SIZE))
+
+    for y in y_positions:
+        for x in x_positions:
+            tile = input_tensor[:, :, y:y + TILE_SIZE, x:x + TILE_SIZE].contiguous()
+            sr_tile = method.execute([tile])[0]
+
+            oy, ox = y * SCALE, x * SCALE
+            oh, ow = TILE_SIZE * SCALE, TILE_SIZE * SCALE
+            output[:, :, oy:oy + oh, ox:ox + ow] += sr_tile
+            weights[:, :, oy:oy + oh, ox:ox + ow] += 1.0
+
+    return output / weights.clamp(min=1.0)
+
+
+# ── Postprocessing ─────────────────────────────────────────────────────────────
+def postprocess(raw_output: torch.Tensor) -> np.ndarray:
+    """Clamp output to [0, 1] and convert to uint8 numpy array (H, W, 3)."""
+    sr_tensor = raw_output.clamp(0.0, 1.0).squeeze(0)  # [3, H*4, W*4]
+    sr_array = (sr_tensor.permute(1, 2, 0).numpy() * 255.0).round().astype(np.uint8)
+    return sr_array
+
+
+# ── Save Results ──────────────────────────────────────────────────────────────
+def save_results(sr_array: np.ndarray, original_size: tuple[int, int]) -> None:
+    """Save the super-resolved image and a JSON summary to the script directory."""
+    script_dir = Path(__file__).parent
+
+    # Save super-resolved image
+    output_image = Image.fromarray(sr_array)
+    output_path = script_dir / "sample_output.png"
+    output_image.save(output_path)
+    print(f"Super-resolved image saved to: {output_path}")
+
+    # Save JSON summary
+    summary = {
+        "input_size": {"width": original_size[0], "height": original_size[1]},
+        "output_size": {"width": sr_array.shape[1], "height": sr_array.shape[0]},
+        "scale_factor": SCALE,
+    }
+    json_path = script_dir / "super_resolution.json"
+    with open(json_path, "w") as f:
+        json.dump(summary, f, indent=2)
+    print(f"Summary saved to: {json_path}")
+
+
+# ── Main ───────────────────────────────────────────────────────────────────────
+def main():
+    script_dir = Path(__file__).parent
+    model_path = script_dir / MODEL_PATH
+    image_path = script_dir / IMAGE_PATH
+
+    print(f"Loading model from: {model_path}")
+    method = load_model(str(model_path))
+
+    print(f"Preprocessing image: {image_path}")
+    input_tensor, original_size = preprocess(str(image_path))
+    _, _, h, w = input_tensor.shape
+    print(f"  Input size: {w}x{h} -> output will be {w * SCALE}x{h * SCALE}")
+
+    print("Running tiled super-resolution inference...")
+    raw_output = run_tiled_inference(method, input_tensor)
+
+    sr_array = postprocess(raw_output)
+    print(f"  Output shape: {sr_array.shape[1]}x{sr_array.shape[0]} (WxH)")
+
+    save_results(sr_array, original_size)
+
+
+if __name__ == "__main__":
+    main()

metadata.yaml

@@ -0,0 +1,23 @@
+schema_version: 1.0.0
+report_type: image-to-image
+task_type: image-to-image
+title: ESRGAN x4 INT8 — ExecuTorch + XNNPACK
+id: Arm/esrgan-int8-xnnpack-executorch-graviton-g4
+filename: esrgan-x4-int8-executorch.pte
+base_model_id: kadirnar/RRDB_PSNR_x4
+profile: Arm-Optimized
+weight_dtype: int8
+model_size_mb: 23.176
+parameter_count: 16697987
+format: pte
+quantization:
+  method: PTQ-static
+  weight_bits: 8
+  activation_bits: 8
+  symmetric: true
+  mode: static
+  weight_granularity: per-channel
+calibration:
+  dataset_name: urban100
+  sample_count: 100
+  selection: random

super_resolution.json

@@ -0,0 +1,11 @@
+{
+  "input_size": {
+    "width": 256,
+    "height": 161
+  },
+  "output_size": {
+    "width": 1024,
+    "height": 644
+  },
+  "scale_factor": 4
+}