init model

README.md

@@ -0,0 +1,67 @@
+---
+license: apache-2.0
+datasets:
+- imagenet-1k
+metrics:
+- accuracy
+tags:
+- RyzenAI
+- vision
+- classification
+- pytorch
+---
+
+# Inception_v4
+Quantized Inception_v4 model that could be supported by [AMD Ryzen AI](https://ryzenai.docs.amd.com/en/latest/).
+
+
+## Model description
+Inception_v4 was first introduced in the paper [Inception-v4, Inception-ResNet and the Impact of Residual Connections on Learning](https://arxiv.org/abs/1602.07261). 
+
+The model implementaion is from [TensorFlow-Slim](https://github.com/tensorflow/models/tree/master/research/slim).
+
+
+## How to use
+
+### Installation
+
+Follow [Ryzen AI Installation](https://ryzenai.docs.amd.com/en/latest/inst.html) to prepare the environment for Ryzen AI.
+Run the following script to install pre-requisites for this model.
+
+```bash
+pip install -r requirements.txt
+```
+
+### Data Preparation
+
+Follow [imagenet-1k](https://huggingface.co/datasets/imagenet-1k) to download dataset. 
+
+Download [ImageNet validation synset labels file](https://github.com/tensorflow/models/blob/master/research/slim/datasets/imagenet_2012_validation_synset_labels.txt).
+
+Create validation image list:
+```bash
+python create_image_list.py imagenet_2012_validation_synset_labels.txt
+```
+
+### Model Evaluation
+
+```python
+python eval_onnx.py --onnx_model inception_v4_int8.onnx --ipu --provider_config Path\To\vaip_config.json --val_data_dir /Path/To/Your/Validation/Data --val_image_list val.txt
+```
+
+### Performance
+
+|Metric |Accuracy on IPU|
+| :----:  | :----: |
+|Top1/Top5| 79.92% / 95.02%|
+
+
+```bibtex
+@article{Szegedy2016Inceptionv4IA,
+  title={Inception-v4, Inception-ResNet and the Impact of Residual Connections on Learning},
+  author={Christian Szegedy and Sergey Ioffe and Vincent Vanhoucke and Alexander A. Alemi},
+  journal={arXiv:1602.07261},
+  year={2016},
+}
+
+```

create_image_list.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python
+r"""Create a list containing image names and their corresponding class indices
+for ImageNet validation data.
+
+The directory structure of the original ImageNet validation data set is
+expected to be:
+
+ data_dir/ILSVRC2012_val_00000001.JPEG
+ data_dir/ILSVRC2012_val_00000002.JPEG
+ ...
+ date_dir/ILSVRC2012_val_00050000.JPEG
+
+This script generate a list like:
+ ILSVRC2012_val_00000001.JPEG 65
+ ILSVRC2012_val_00000002.JPEG 970
+ ...
+ ILSVRC2012_val_00050000.JPEG 355
+
+Usage:
+  Download https://github.com/tensorflow/models/blob/master/research/slim/datasets/imagenet_2012_validation_synset_labels.txt and then,
+  ./create_image_labels.py imagenet_2012_validation_synset_labels.txt
+"""
+
+import sys
+
+if __name__ == '__main__':
+  if len(sys.argv) < 2:
+    print('Usage: ./create_image_labels.py <labels file>')
+    sys.exit(-1)
+  labels_file = sys.argv[1]
+
+  labels = [l.strip() for l in open(labels_file).readlines()]
+  sorted_labels = sorted(labels)
+  class_idx = 0
+  label_to_class_idx = {}
+  for label in sorted_labels:
+    if label not in label_to_class_idx:
+      label_to_class_idx[label] = class_idx
+      class_idx += 1
+
+  image_list_file = 'val.txt'
+  with open(image_list_file, 'w') as f:
+    for i, label in enumerate(labels):
+      image_name = 'ILSVRC2012_val_000%.5d.JPEG' % (i + 1)
+      f.write(f'{image_name} {label_to_class_idx[label]}\n')
+  print(f'Output image list file: {image_list_file}')

eval_onnx.py

@@ -0,0 +1,161 @@
+#!/usr/bin/env python
+
+import argparse
+import math
+import numpy as np
+import os
+import time
+
+import tensorflow.compat.v1 as tf
+tf.disable_v2_behavior()
+
+import onnxruntime as ort
+
+parser = argparse.ArgumentParser()
+parser.add_argument(
+    "--onnx_model", default="inceptionv4_int8.onnx", help="Input onnx model")
+parser.add_argument(
+    "--val_data_dir",
+    default="/workspace/dataset/imagenet/val",
+    help="Data directory of validation set")
+parser.add_argument(
+    "--val_image_list",
+    default="/workspace/dataset/imagenet/val.txt",
+    help="Validation images list")
+parser.add_argument(
+    "--subset_len",
+    default=50000,
+    type=int,
+    help="Subset length of validation set to use")
+parser.add_argument(
+    "--batch_size", default=1, type=int, help="Validation batch size")
+parser.add_argument(
+    "--ipu",
+    action="store_true",
+    help="Use IPU for inference.",
+)
+parser.add_argument(
+    "--provider_config",
+    type=str,
+    default="vaip_config.json",
+    help="Path of the config file for seting provider_options.",
+)
+args = parser.parse_args()
+
+class DataLoader(object):
+
+  def __init__(self, height=224, width=224):
+    self.output_height = height
+    self.output_width = width
+
+  def _inception_preprocess(self,
+                            image,
+                            central_fraction=0.875,
+                            central_crop=True):
+    image = tf.image.convert_image_dtype(image, dtype=tf.float32)
+    # Crop the central region of the image with an area containing 87.5% of
+    # the original image.
+    if central_crop and central_fraction:
+      image = tf.image.central_crop(image, central_fraction=central_fraction)
+
+    if self.output_height and self.output_width:
+      image = tf.expand_dims(image, 0)
+      image = tf.image.resize_bilinear(
+          image, [self.output_height, self.output_width], align_corners=False)
+    image = tf.subtract(image, 0.5)
+    image = tf.multiply(image, 2.0)
+    return image
+
+  def _build_placeholder(self):
+    input_image_path = tf.placeholder(
+        tf.string, shape=(None), name="input_image_path")
+    image = tf.io.read_file(input_image_path)
+    image = tf.image.decode_jpeg(image, channels=3)
+    return image, input_image_path
+
+  def build_preprocess(self):
+    """Returns image tensor used to read image."""
+    image, input_image_path = self._build_placeholder()
+    image = self._inception_preprocess(image)
+    return image, input_image_path
+
+def main():
+  input_shape = (299, 299, 3)
+  label_offset = 0
+
+  with tf.Session() as tf_session:
+    loader = DataLoader(input_shape[0], input_shape[1])
+    image, image_path = loader.build_preprocess()
+    in_image = tf.placeholder(
+        tf.float32, shape=(None,) + input_shape, name='in_image')
+    in_label = tf.placeholder(tf.int64, shape=(None, 1), name='in_label')
+    num_classes = 1001 - label_offset
+    logits = tf.placeholder(
+        tf.float32, shape=(None, num_classes), name='logits')
+    top1, top1_update = tf.metrics.recall_at_k(
+        in_label, logits, 1, name="precision_top1")
+    top5, top5_update = tf.metrics.recall_at_k(
+        in_label, logits, 5, name="precision_top5")
+
+    var_list = tf.get_collection(
+        tf.GraphKeys.LOCAL_VARIABLES, scope="precision")
+    vars_initializer = tf.variables_initializer(var_list=var_list)
+    tf_session.run(vars_initializer)
+
+    with open(args.val_image_list, 'r') as fr:
+      lines = fr.readlines()
+    if args.subset_len > len(lines):
+      raise ValueError(
+          "subset_len(%d) should be less or equal than total images(%d)." %
+          (args.subset_len, len(lines)))
+    eval_steps = math.ceil(args.subset_len / args.batch_size)
+    start_t = time.time()
+
+    if args.ipu:
+      providers = ["VitisAIExecutionProvider"]
+      provider_options = [{"config_file": args.provider_config}]
+    else:
+      providers = ['CUDAExecutionProvider', 'CPUExecutionProvider']
+      provider_options = None
+    ort_session = ort.InferenceSession(
+        args.onnx_model, providers=providers, provider_options=provider_options)
+
+    for step in range(eval_steps):
+      print(f'Eval step {step} / {eval_steps}')
+      batch_images = []
+      batch_labels = []
+      for i in range(args.batch_size):
+        index = step * args.batch_size + i
+        if index >= args.subset_len:
+          break
+
+        img_path, label = lines[index].strip().split(" ")
+        img_path = os.path.join(args.val_data_dir, img_path)
+        # Run session to get image from feeded image path.
+        image_val = tf_session.run(image, feed_dict={image_path: img_path})
+        batch_images.append(image_val)
+
+        label = int(label) + 1 - label_offset
+        label = np.array([label], dtype=np.int64)
+        batch_labels.append(label)
+
+      batch_images = batch_images[0] if args.batch_size == 1 else np.squeeze(
+          batch_images)
+      ort_inputs = {ort_session.get_inputs()[0].name: batch_images}
+      outputs = ort_session.run(None, ort_inputs)
+
+      # Update top1/5 metric.
+      tf_session.run([top1_update, top5_update],
+                     feed_dict={
+                         in_image: batch_images,
+                         in_label: batch_labels,
+                         logits: outputs[0]
+                     })
+    end_t = time.time()
+    top1_val, top5_val = tf_session.run([top1, top5])
+    print('Recall_1 = [%s]' % str(top1_val))
+    print('Recall_5 = [%s]' % str(top5_val))
+    print('Use_time = [%s]' % str(end_t - start_t))
+
+if __name__ == "__main__":
+  main()

inceptionv4_int8.onnx

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

requirements.txt

@@ -0,0 +1,3 @@
+tensorflow==2.15.0
+numpy
+# onnxruntime