init model

EfficientNet_int.onnx

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

README.md

@@ -0,0 +1,109 @@
+---
+license: apache-2.0
+tags:
+- RyzenAI
+- image-classification
+- onnx
+datasets:
+- imagenet-1k
+---
+
+# EfficientNet
+
+The EfficientNet model was proposed in [EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks](https://arxiv.org/abs/1905.11946) by Mingxing Tan and Quoc V. Le. EfficientNets are a family of image classification models, which achieve state-of-the-art accuracy, yet being an order-of-magnitude smaller and faster than previous models. The specific version of EfficientNet here is EfficientNet-ES (EdgeTPU-Small).
+
+We develop a modified version that could be supported by [AMD Ryzen AI](https://ryzenai.docs.amd.com/en/latest/).
+
+## Model description
+
+The abstract from the paper is the following:
+
+*Convolutional Neural Networks (ConvNets) are commonly developed at a fixed resource budget, and then scaled up for better accuracy if more resources are available. In this paper, we systematically study model scaling and identify that carefully balancing network depth, width, and resolution can lead to better performance. Based on this observation, we propose a new scaling method that uniformly scales all dimensions of depth/width/resolution using a simple yet highly effective compound coefficient. We demonstrate the effectiveness of this method on scaling up MobileNets and ResNet. To go even further, we use neural architecture search to design a new baseline network and scale it up to obtain a family of models, called EfficientNets, which achieve much better accuracy and efficiency than previous ConvNets. In particular, our EfficientNet-B7 achieves state-of-the-art 84.3% top-1 accuracy on ImageNet, while being 8.4x smaller and 6.1x faster on inference than the best existing ConvNet. Our EfficientNets also transfer well and achieve state-of-the-art accuracy on CIFAR-100 (91.7%), Flowers (98.8%), and 3 other transfer learning datasets, with an order of magnitude fewer parameters.*
+
+The original code can be found [here](https://github.com/tensorflow/tpu/tree/master/models/official/efficientnet).
+
+## Intended uses & limitations
+
+You can use the raw model for image classification. See the [model hub](https://huggingface.co/models?sort=trending&search=efficientnet) to look for fine-tuned versions on a task that interests you.
+
+## How to use
+
+### Installation
+
+1. Follow [Ryzen AI Installation](https://ryzenai.docs.amd.com/en/latest/inst.html) to prepare the environment for Ryzen AI.
+
+2. Run the following script to install pre-requisites for this model.
+
+   ```shell
+   pip install -r requirements.txt 
+   ```
+
+### Test & Evaluation
+
+- Inference one image (Image Classification):
+
+  ```python
+  import onnxruntime
+  import argparse
+  from PIL import Image 
+  import torchvision.transforms as transforms 
+
+  parser = argparse.ArgumentParser()
+  parser.add_argument('--onnx_path', type=str, default="EfficientNet_int.onnx", required=False)
+  parser.add_argument('--image_path', type=str, required=True)
+
+  args = parser.parse_args()
+
+  def read_image():
+    # Read a PIL image 
+    image = Image.open(args.image_path)
+    normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+    
+    transform = transforms.Compose([
+      transforms.ToTensor(),
+      transforms.Resize((224, 224)),
+      normalize,
+    ])
+    img_tensor = transform(image).unsqueeze(0)
+    return img_tensor.numpy()
+
+
+  def main():
+    so = onnxruntime.SessionOptions()
+    ort_session = onnxruntime.InferenceSession(
+      args.onnx_path, so, providers=['CUDAExecutionProvider'])
+    ort_inputs = {
+      "WrapModel::input_0": read_image()
+    }
+    output = ort_session.run(None, ort_inputs)[0]
+    print("class id =", output[0].argmax())
+
+
+  if __name__ == "__main__":
+    main()
+  ```
+
+- Evaluate ImageNet validation dataset(50,000 images), using `eval_onnx.py` .
+
+  ```shell
+  python eval_onnx.py --onnx_model EfficientNet_int.onnx --ipu --provider_config Path\To\vaip_config.json --data_dir /Path/To/Your/Dataset
+  ```
+
+### Performance
+
+​	Dataset: ImageNet validation dataset (50,000 images).
+
+|       Metric        | Accuracy on IPU  |
+| :-----------------: | :-------------: |
+| top1& top5 accuracy | 77.72% / 93.78% |
+
+## Citation
+
+```bibtex
+@article{EfficientNet,
+ author       = {Mingxing Tan and Quoc V. Le},
+  title       = {Searching for MobileNetV3},
+  year        = {2019},
+  url         = {https://arxiv.org/abs/1905.11946},
+}
+```

eval_onnx.py

@@ -0,0 +1,164 @@
+#!/usr/bin/env python
+
+from typing import Tuple
+
+import argparse
+import onnxruntime
+import os
+import sys
+import time
+import torch
+import torchvision.datasets as datasets
+import torchvision.transforms as transforms
+
+from torch.utils.data import DataLoader
+from tqdm import tqdm
+
+parser = argparse.ArgumentParser()
+parser.add_argument(
+    "--onnx_model", default="model.onnx", help="Input onnx model")
+parser.add_argument(
+    "--data_dir",
+    default="/workspace/dataset/imagenet",
+    help="Directory of dataset")
+parser.add_argument(
+    "--batch_size", default=1, type=int, help="Evaluation 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 AverageMeter(object):
+  """Computes and stores the average and current value"""
+
+  def __init__(self, name, fmt=':f'):
+    self.name = name
+    self.fmt = fmt
+    self.reset()
+
+  def reset(self):
+    self.val = 0
+    self.avg = 0
+    self.sum = 0
+    self.count = 0
+
+  def update(self, val, n=1):
+    self.val = val
+    self.sum += val * n
+    self.count += n
+    self.avg = self.sum / self.count
+
+  def __str__(self):
+    fmtstr = '{name} {val' + self.fmt + '} ({avg' + self.fmt + '})'
+    return fmtstr.format(**self.__dict__)
+
+def accuracy(output: torch.Tensor,
+             target: torch.Tensor,
+             topk: Tuple[int] = (1,)) -> Tuple[float]:
+  """Computes the accuracy over the k top predictions for the specified values of k.
+  Args:
+    output: Prediction of the model.
+    target: Ground truth labels.
+    topk: Topk accuracy to compute.
+
+  Returns:
+    Accuracy results according to 'topk'.
+  """
+
+  with torch.no_grad():
+    maxk = max(topk)
+    batch_size = target.size(0)
+
+    _, pred = output.topk(maxk, 1, True, True)
+    pred = pred.t()
+    correct = pred.eq(target.view(1, -1).expand_as(pred))
+
+    res = []
+    for k in topk:
+      correct_k = correct[:k].contiguous().view(-1).float().sum(0, keepdim=True)
+      res.append(correct_k.mul_(100.0 / batch_size))
+    return res
+
+def prepare_data_loader(data_dir: str,
+                        batch_size: int = 100,
+                        workers: int = 8) -> torch.utils.data.DataLoader:
+  """Returns a validation data loader of ImageNet by given `data_dir`.
+
+  Args:
+    data_dir: Directory where images stores. There must be a subdirectory named
+      'validation' that stores the validation set of ImageNet.
+    batch_size: Batch size of data loader.
+    workers: How many subprocesses to use for data loading.
+
+  Returns:
+    An object of torch.utils.data.DataLoader.
+  """
+
+  valdir = os.path.join(data_dir, 'validation')
+
+  normalize = transforms.Normalize(
+      mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+  val_dataset = datasets.ImageFolder(
+      valdir,
+      transforms.Compose([
+          transforms.Resize(256),
+          transforms.CenterCrop(224),
+          transforms.ToTensor(),
+          normalize,
+      ]))
+
+  return torch.utils.data.DataLoader(
+      val_dataset,
+      batch_size=batch_size,
+      shuffle=False,
+      num_workers=workers,
+      pin_memory=True)
+
+def val_imagenet():
+  """Validate ONNX model on ImageNet dataset."""
+  print(f'Current onnx model: {args.onnx_model}')
+
+  if args.ipu:
+    providers = ["VitisAIExecutionProvider"]
+    provider_options = [{"config_file": args.provider_config}]
+  else:
+    providers = ['CUDAExecutionProvider', 'CPUExecutionProvider']
+    provider_options = None
+  ort_session = onnxruntime.InferenceSession(
+      args.onnx_model, providers=providers, provider_options=provider_options)
+
+  val_loader = prepare_data_loader(args.data_dir, args.batch_size)
+
+  top1 = AverageMeter('Acc@1', ':6.2f')
+  top5 = AverageMeter('Acc@5', ':6.2f')
+
+  start_time = time.time()
+  val_loader = tqdm(val_loader, file=sys.stdout)
+  with torch.no_grad():
+    for batch_idx, (images, targets) in enumerate(val_loader):
+      inputs, targets = images.numpy(), targets
+      ort_inputs = {ort_session.get_inputs()[0].name: inputs}
+
+      outputs = ort_session.run(None, ort_inputs)
+      outputs = torch.from_numpy(outputs[0])
+
+      acc1, acc5 = accuracy(outputs, targets, topk=(1, 5))
+      top1.update(acc1, images.size(0))
+      top5.update(acc5, images.size(0))
+
+    current_time = time.time()
+    print('Test Top1 {:.2f}%\tTop5 {:.2f}%\tTime {:.2f}s\n'.format(
+        float(top1.avg), float(top5.avg), (current_time - start_time)))
+
+  return top1.avg, top5.avg
+
+if __name__ == '__main__':
+  val_imagenet()

infer_onnx.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python3
+# -*- coding:utf-8 -*-
+
+# Copyright 2023 Advanced Micro Devices, Inc. on behalf of itself and its subsidiaries and affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Copyright (c) Megvii, Inc. and its affiliates.
+
+import onnxruntime
+import argparse
+from PIL import Image 
+import torchvision.transforms as transforms 
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--onnx_path', type=str, default="EfficientNet_int.onnx", required=False)
+parser.add_argument('--image_path', type=str, required=True)
+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()
+
+
+def read_image():
+  # Read a PIL image 
+  image = Image.open(args.image_path)
+  normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+  
+  transform = transforms.Compose([
+    transforms.ToTensor(),
+    transforms.Resize((224, 224)),
+    normalize,
+  ])
+  img_tensor = transform(image).unsqueeze(0)
+  return img_tensor.numpy()
+
+
+def main():
+  if args.ipu:
+    providers = ["VitisAIExecutionProvider"]
+    provider_options = [{"config_file": args.provider_config}]
+  else:
+    providers = ['CUDAExecutionProvider', 'CPUExecutionProvider']
+    provider_options = None
+  ort_session = onnxruntime.InferenceSession(
+    args.onnx_path, providers=providers, provider_options=provider_options)
+  ort_inputs = {
+    ort_session.get_inputs()[0].name: read_image()
+  }
+  output = ort_session.run(None, ort_inputs)[0]
+  print("class id =", output[0].argmax())
+
+
+if __name__ == "__main__":
+  main()

requirements.txt

@@ -0,0 +1,6 @@
+torch==1.12.0
+torchsummary==1.5.1
+torchvision==0.13.0
+Pillow==9.4.0
+timm==0.9.8
+tqdm==4.64.0