TPU-MLIR量化及识别模型效果测试

https://github.com/sophgo/tpu-mlir 官方工程

建议查看官方文档，这里只是做下步骤记录

docker ps -a 
docker exec -it facrec /bin/bash  # 进入容器
# 编译环境
cd tpu-mlir/
source ./envsetup.sh
source ./build.sh
cd ..
cd facrec/workspace

量化步骤：

"run.sh"
model_transform.py \
    --model_name facrec \
    --model_def ../model.onnx \
    --input_shapes [[1,1,112,112]] \
    --mean 127.5 \
    --scale 0.0078431 \
    --keep_aspect_ratio \
    --pixel_format gray \
    --output_names output \
    --mlir 16/model_facrec_in_f32.mlir

run_calibration.py 16/model_facrec_in_f32.mlir \
  --dataset ../quant_data \
  --input_num 20 \
  -o 16/model_facrec_cali_table

model_deploy.py \
  --mlir 16/model_facrec_in_f32.mlir \
  --quantize INT8 \
  --calibration_table 16/model_facrec_cali_table \
  --chip cv181x \
  --tolerance 0.85,0.45 \
  --model 16/model_facrec_181x_int8.cvimodel

效果对比：

'demo.sh'
python facrec_pth_quant_compare.py \
        --model_def model_facrec_181x_int8.cvimodel \
        --model_onnx ../model_4.onnx \
        --img1 data/20p122.png \
        --img2 data/20p97.png

'facrec_pth_quant_compare.py'
import os, cv2, sys
import numpy as np
import argparse
from tools.model_runner import mlir_inference, model_inference, onnx_inference, caffe_inference

def l2norm(result):
    norm = np.linalg.norm(result, axis=1, keepdims=True)
    result = result / norm
    return result

def parse_args():
    parser = argparse.ArgumentParser(description='Inference xception network.')
    parser.add_argument("--model_def", type=str,
                        required=True, help="Model definition file")
    parser.add_argument("--model_onnx", type=str,
                        required=True, help="Model onnx definition file")
    parser.add_argument("--img1", type=str, required=True,
                        help="Input image for testing")
    parser.add_argument("--img2", type=str, required=True,
                        help="Output image after classification")
    args = parser.parse_args()
    return args    

def cv_onnx_pred(image, args):
    image = np.array(image)
    image = image.astype(np.float16)
    image /= 255.0
    image = (image-0.5)/0.5
    image = np.expand_dims(image, 0)
    
    input_data_batch = np.expand_dims(image, 0)
    input_data_batch = np.ascontiguousarray(input_data_batch)
    
    data = {"data": input_data_batch}# input name from model
    output, output_onnx = dict(), dict()
    if args.model_def.endswith('.prototxt') and args.model_data.endswith('.caffemodel'):
        output = caffe_inference(data, args.model_def, args.model_data, False)
    elif args.model_def.endswith('.mlir'):
        output = mlir_inference(data, args.model_def, False)
    elif args.model_def.endswith(".bmodel"):
        output = model_inference(data, args.model_def)
    elif args.model_def.endswith(".cvimodel"):
        output = model_inference(data, args.model_def, False)
    elif args.model_def.endswith(".onnx"):
        output_onnx = onnx_inference(data, args.model_def)
    else:
        raise RuntimeError("not support modle file:{}".format(args.model_def))
    if args.model_onnx.endswith(".onnx"):
        output_onnx = onnx_inference(data, args.model_onnx)
        
    return output, output_onnx

def l2norm(result):
    norm = np.linalg.norm(result, keepdims=True)
    result = result / norm
    return result

def main():
    args = parse_args()
    image = cv2.imread(args.img1, 0)  # RGB HWC
    output, output_onnx = cv_onnx_pred(image, args)
    
    image2 = cv2.imread(args.img2, 0)  # RGB HWC
    output2, output_onnx2 = cv_onnx_pred(image2, args)
    
    # print(output['output_Conv_f32'])
    # print(output_onnx.keys(), output_onnx['output_Conv'], len(output['output_Conv_f32']), len(output_onnx['output_Conv']))
    # print(output_onnx['output_Conv'][0], len(output_onnx['output_Conv'][0]), output_onnx['output_Conv'][0][0])    
    # print(output['output_Conv_f32'].squeeze())
    
    img1_cv = output['output_Conv_f32'].squeeze()
    img1_onnx = output_onnx['output_Conv'].squeeze()
    # 标准化向量 x 和 y
    img1_cvn = l2norm(img1_cv)#(img1_cv - np.mean(img1_cv)) / np.std(img1_cv)
    img1_onnxn = l2norm(img1_onnx)#(img1_onnx - np.mean(img1_onnx)) / np.std(img1_onnx)

    # 计算标准化后的向量 x' 和 y' 的欧氏距离
    distance = np.linalg.norm(img1_cvn - img1_onnxn)
    print("img1量化后与onnx距离：", distance)
    img2_cv = output2['output_Conv_f32'].squeeze()
    img2_onnx = output_onnx2['output_Conv'].squeeze()
    
    img2_cvn = l2norm(img2_cv)#(img2_cv - np.mean(img2_cv)) / np.std(img2_cv)
    img2_onnxn = l2norm(img2_onnx)#(img2_onnx - np.mean(img2_onnx)) / np.std(img2_onnx)
    distance = np.linalg.norm(img2_cvn - img2_onnxn)
    print("img2量化后与onnx距离：", distance)
    
    distance = np.linalg.norm(img1_onnxn - img2_onnxn)
    print("img1 img2 onnx的距离：", distance)
    distance = np.linalg.norm(img2_cvn - img1_cvn)
    print("img1 img2 量化后距离：", distance)

if __name__ == '__main__':
    main()