sesr-m7-256x256-tiles-amdnpu

🚀 SESR-M7 on AMD AI PC NPU

Bhardwaj et al. (2022) introduced the Super-Efficient Super Resolution (SESR) model to solve a classic computer vision problem: to take a low-resolution input image and output a high-resolution image. The SESR model is based on a "linear overparameterization of CNNs and creates an efficient model architecture for [Single Image Super Resolution (SISR)]." The official code can be found on GitHub: https://github.com/ARM-software/sesr. One of the main ideas behind the model was to make it very computationally efficient.

This version of the model is the SESR-M7 (Small) version; it has been converted from PyTorch format to ONNX, and then quantized to INT8 to run on an AMD AI PC NPU with Ryzen AI software. The model in its current form operates on tile sizes of 256x256; however, because tiles can overlap across the image, the model accepts input of almost any size and will create a 2x super-resolution image as output (Figure 1).

Figure 1: Ice climber image upscaled by 2x with SESR-M7 model running on AMD AI PC NPU. Source: DIV2K dataset (DIV2K_valid_LR_bicubic\X4\0844x4.png).

⚡ Intended Use

How to Use

📐 Hardware Prerequisites

Before getting started, make sure you meet the minimum hardware and OS requirements:

Getting Started

1. Follow the instructions here to download necessary NPU drivers and Ryzen AI software: Ryzen AI SW Installation Instructions. Please allow for around 30 minutes to install all of the necessary components of Ryzen AI SW.

2. Activate the previously installed conda environment from Ryzen AI (RAI) SW, and set the RAI environment variable to your installation path. Substitute the correct RAI version number for v.v.v, such as 1.7.1.

conda activate ryzen-ai-v.v.v
$Env:RYZEN_AI_INSTALLATION_PATH = 'C:/Program Files/RyzenAI/v.v.v/'

1. Clone the Hugging Face model repository:

git clone https://hf.co/amd/sesr-m7-256x256-tiles-amdnpu

Alternatively, you can use the Hugging Face Hub API to download the files with Python:

from huggingface_hub import snapshot_download
snapshot_download("amd/sesr-m7-256x256-tiles-amdnpu")

1. Install the necessary packages into the existing conda environment:

pip install -r requirements.txt

This covers both inference and the accuracy evaluation further down, in the one environment. ONNX Runtime is not among the dependencies on purpose: the Ryzen AI environment already provides onnxruntime-vitisai, and installing plain onnxruntime over it removes the NPU execution provider without reporting an error. Nothing listed pulls it in, so the NPU stays available for evaluation runs as well as inference.

1. Data Preparation (optional: for evaluation). Download the EDSR benchmark dataset extract it into the datasets/ directory. Note that you will need to run this script twice, as it seems to fail on first attempt.

python download_edsr_benchmark.py

The datasets/ directory should look like this:

datasets/edsr_benchmark
    └── B100
          └── HR
            ├── 3096.png
            ├── ...
          └── LR_bicubic/X2
            ├── 3096x4.png
            ├── ...
    └── Set5
...

1. Run inference on a single image or a folder of images. For example:

python onnx_inference.py --onnx onnx-models/sesr_nhwc_int8_256x256.onnx --input datasets/edsr_benchmark/B100/HR/3096.png --out-dir outputs  --device npu

Arguments:

--onnx: The ONNX model file path.

--input: Accepts either a single image file path or a directory path. If it's a file, the script will process that image only. If it's a directory, the script will recursively scan for .png, .jpg, and .jpeg files and process all of them.

--out-dir: Output directory where the restored images will be saved.

--device: Accepts "npu" or "cpu". The NPU will attempt to use the VitisAIExecutionProvider; the CPU will attempt to use the CPUExecutionProvider. Note that to use the NPU, the updated NPU drivers and Ryzen AI SW must first be installed.

The model has already been compiled and cached under modelcachekey_sesr_nhwc_int8_256x256, but if this folder is not present, the model will be recompiled and then inference can be run.

1. Evaluate the accuracy of the model on benchmark datasets (optional).

Eval on Set14:

python onnx_eval.py --onnx onnx-models/sesr_nhwc_int8_256x256.onnx --hq-dir datasets/edsr_benchmark/Set14/HR --lq-dir datasets/edsr_benchmark/Set14/LR_bicubic/X2 --out-dir outputs/Set14 --device npu -clean

Additional arguments for onnx_eval.py: --max-samples: (Optional) Limit the number of samples to evaluate. Useful for debugging. If not specified, all samples will be evaluated. -clean: (Optional) If specified, the generated super-resolution images will be deleted after evaluation to save disk space.

The output is a set of accuracy metrics (PSNR, MS_SSIM, SSIM and FID) in a JSON file:

{
  "onnx": "onnx-models/sesr_nhwc_int8_256x256.onnx",
  "psnr": 30.857940673828125,
  "ms_ssim": 0.9930451083827904,
  "ssim": 0.8996079409948479,
  "fid": 18.409796542870254
}

The following are example scripts to run INT8 models for evaluation of the other datasets on the NPU:

Eval on Set5:

python onnx_eval.py --onnx onnx-models/sesr_nhwc_int8_256x256.onnx --hq-dir datasets/edsr_benchmark/Set5/HR --lq-dir datasets/edsr_benchmark/Set5/LR_bicubic/X2 --out-dir outputs/Set5 --device npu -clean

Eval on B100:

python onnx_eval.py --onnx onnx-models/sesr_nhwc_int8_256x256.onnx --hq-dir datasets/edsr_benchmark/B100/HR --lq-dir datasets/edsr_benchmark/B100/LR_bicubic/X2 --out-dir outputs/B100 --device npu -clean

Eval on Urban100

python onnx_eval.py --onnx onnx-models/sesr_nhwc_int8_256x256.onnx --hq-dir datasets/edsr_benchmark/Urban100/HR --lq-dir datasets/edsr_benchmark/Urban100/LR_bicubic/X2 --out-dir outputs/Urban100 --device npu -clean

🔧 Evaluation Data

Datasets: The AMD ONNX model results were evaluated with the EDSR datasets (Set5, Set14, BSD100, Urban100) on peak signal-to-noise ratio (PSNR), multi-scale structural similarity (MS-SSIM), structural similarity (SSIM), and Fréchet Inception Distance (FID). To draw direct comparisons to the original paper by Bhardwaj et al. (2022), we only show the results for PSNR and SSIM (Table 1).

📚 Training Data

The \(\times2\) SESR was trained for "300 epochs using ADAM optimizer with a constant learning rate of \(5 \times 10^{-4}\) and a batch size of 32 on DIV2K training set." (Bhardwaj et al., 2022). DIV2K is a training set of 800 2K-resolution images for image restoration tasks.

📝 Quantitative Analyses

The evaluation results for the AMD models for PSNR/SSIM (Table 1) show decent accuracy, even after quantization from FP32 to INT8.

Table 1: "PSNR/SSIM results on \(\times\)2 Super Resolution on several benchmark datasets. MACs are reported as the number of multiply-adds needed to convert an image to 720p (1280 \(\times\) 720) resolution via \(\times\)2 SISR." Highlights indicate best score within each regime. Table from Bhardwaj et al. (2022), with 2 AMD rows added for comparison.

The following are the performance results of 6 super-resolution models on the Strix machine NPU (Table 2).

Table 2: Performance metrics in frames per second (FPS) for AMD Super-Resolution models (higher is better).

⚓ Ethical Considerations

AMD is committed to conducting our business in a fair, ethical and honest manner and in compliance with all applicable laws, rules and regulations. You can find out more at the AMD Ethics and Compliance page.

⚠️ Caveats and Recommendations

The models here are for x2 super-resolution (not x4).

📌 Citation Details

@article{bhardwaj2022collapsible,
  title={Collapsible linear blocks for super-efficient super resolution},
  author={Bhardwaj, Kartikeya and Milosavljevic, Milos and O'Neil, Liam and Gope, Dibakar and Matas, Ramon and Chalfin, Alex and Suda, Naveen and Meng, Lingchuan and Loh, Danny},
  journal={Proceedings of machine learning and systems},
  volume={4},
  pages={529--547},
  year={2022}
}