正点原子i.MX93开发板】eIQ图像分类测试

maskmoo

正点原子i.MX93开发板】eIQ图像分类测试 [复制链接]

NXP 提供了一部分学习机器学习的例程（NXP 将其称为 eIQ Demos），默认存放在/usr/bin/eiq-examples-git目录。

 

其中dms为人脸关键点例程，face_recognition是人脸识别例程，gesture_detection是手势识别例程，image_classification图像分类例程，object_detection目标检测例程。

测试前需要将预先训练好的模型传到开发板上，模型在【正点原子】DLIMX93开发板资料（A盘）-基础资料\01、程序源码\06、AI例程源码\01、例程源码\03、eIQ Demos\models.zip

 

解压到/usr/bin/eiq-examples-git目录

cd /usr/bin/eiq-examples-git
unzip models.zip

 

 

CPU进行推理

进到/usr/bin/eiq-examples-git/image_classification 下的目录，执行以下命令测试模型

python3 label_image.py -i grace_hopper.bmp

其中grace_hopper.bmp 是用于测试推理的图片，label_image.py 是用于图像分类推理的python程序，labels.txt 是类别标签。

推理结果显示87.84％的概率为军装。

 

测试图片如下所示：

  Python代码如下，这段代码是用于使用TensorFlow Lite（TFLite）模型对图像进行分类的脚本，并输出结果和推理时间。其主要步骤包括：

• 导入必要的库：加载处理图像、命令行参数、数组操作和TFLite解释器的库。
• 定义加载标签的函数：从指定的标签文件中读取标签。
• 解析命令行参数：获取图像文件、模型文件、标签文件、委托路径、输入均值和标准差，以及线程数。
• 加载并初始化模型：根据是否提供委托路径，加载TFLite模型并分配张量。
• 获取输入和输出细节：获取模型的输入和输出张量信息，检查输入数据类型。
• 预处理图像：调整图像大小并进行必要的归一化处理。
• 执行模型推理：设置输入张量数据并调用模型进行推理，获取输出数据。
• 处理和显示结果：找出概率最高的前五个分类，加载标签文件并输出分类结果和推理时间。

python 代码里指定了模型的路径以及标签文件，如果需要更换别的模型，需要修改 python 代码里的路径和模型以及标签文件。

# Copyright 2018 The TensorFlow Authors. All Rights Reserved.
#
# 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.
# ==============================================================================
"""label_image for tflite."""

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import argparse
import time

import numpy as np
from PIL import Image
import tflite_runtime.interpreter as tflite


def load_labels(filename):
  with open(filename, 'r') as f:
    return [line.strip() for line in f.readlines()]


if __name__ == '__main__':
  parser = argparse.ArgumentParser()
  parser.add_argument(
      '-i',
      '--image',
      default='grace_hopper.bmp',
      help='image to be classified')
  parser.add_argument(
      '-m',
      '--model_file',
      default='../models/mobilenet_v1_1.0_224_quant.tflite',
      help='.tflite model to be executed')
  parser.add_argument(
      '-l',
      '--label_file',
      default='labels.txt',
      help='name of file containing labels')
  parser.add_argument(
      '-d',
      '--delegate',
      default='',
      help='delegate path')
  parser.add_argument(
      '--input_mean',
      default=127.5, type=float,
      help='input_mean')
  parser.add_argument(
      '--input_std',
      default=127.5, type=float,
      help='input standard deviation')
  parser.add_argument(
      '--num_threads', default=None, type=int, help='number of threads')
  args = parser.parse_args()

  if(args.delegate):
      ext_delegate = [tflite.load_delegate(args.delegate)]
      interpreter = tflite.Interpreter(model_path=args.model_file, experimental_delegates=ext_delegate)
  else:
      interpreter = tflite.Interpreter(model_path=args.model_file)
  interpreter.allocate_tensors()

  input_details = interpreter.get_input_details()
  output_details = interpreter.get_output_details()

  # check the type of the input tensor
  floating_model = input_details[0]['dtype'] == np.float32

  # NxHxWxC, H:1, W:2
  height = input_details[0]['shape'][1]
  width = input_details[0]['shape'][2]
  img = Image.open(args.image).resize((width, height))

  # add N dim
  input_data = np.expand_dims(img, axis=0)

  if floating_model:
    input_data = (np.float32(input_data) - args.input_mean) / args.input_std

  interpreter.set_tensor(input_details[0]['index'], input_data)

  start_time = time.time()
  interpreter.invoke()
  stop_time = time.time()

  output_data = interpreter.get_tensor(output_details[0]['index'])
  results = np.squeeze(output_data)

  top_k = results.argsort()[-5:][::-1]
  labels = load_labels(args.label_file)
  for i in top_k:
    if floating_model:
      print('{:08.6f}: {}'.format(float(results[i]), labels[i]))
    else:
      print('{:08.6f}: {}'.format(float(results[i] / 255.0), labels[i]))

  print('time: {:.3f}ms'.format((stop_time - start_time) * 1000))

 

NPU进行推理

 

默认情况下使用的CPU进行推理，如果想使用IMX93的NPU进行推理，则需要通过 vela 工具将模型编译成可以使 NPU 进行推理的 vela 模型并且调用推理脚本是使用通过-d 来指定委托（使用npu 的推理动态库/usr/lib/libethosu_delegate.so）。

 

 vela 工具编译模型

使用 vela 工具编译 models 目录下 mobilenet_v1_1.0_224_quant.tflite 模型，并使用--output-dir 参数指定 vela_models 目录

mkdir vela_models
vela models/mobilenet_v1_1.0_224_quant.tflite --output-dir vela_models/

 

编译完成进入到 vela_models 目录可以看到生成的 mobilenet_v1_1.0_224_quant_vela.tflite 模型和 mobilenet_v1_1.0_224_quant_summary_internal-default.csv 性能评估两个文件，mo
bilenet_v1_1.0_224_quant_vela.tflite 就是我们要用于推理的 vela 模型。

 

执行 python 脚本，-m 指定编译后的vela_models 目录下的 mobilenet_v1_1.0_224_quant_vela.tflite 模型文件，通过-d 来指定 npu 的推理动态库/usr/lib/libethosu_delegate.so作为委托。

python3 label_image.py -i grace_hopper.bmp -m ../vela_models/mobilenet_v1_1.0_224_quant_vela.tflite -d /usr/lib/libethosu_delegate.so

 

从推理结果可以发现NPU的推理时间推理时间只有 4ms 左右，与前面的 CPU 推理时间的 64ms 相比大大缩短。