附录Ⅱ. 特殊模型转换要点

void FillInputData(MI_FLOAT* pfData, MI_IPU_TensorVector_t& InputTensorVector, MI_IPU_SubNet_InputOutputDesc_t& desc)
{
    const MI_U32 H = desc.astMI_InputTensorDescs[0].u32TensorShape[1];
    const MI_U32 W = desc.astMI_InputTensorDescs[0].u32TensorShape[2];
    const MI_U32 C = desc.astMI_InputTensorDescs[0].u32TensorShape[3];
    MI_FLOAT* pTensorData = (MI_FLOAT*)InputTensorVector.astArrayTensors[0].ptTensorData[0];
    if (desc.astMI_InputTensorDescs[0].eElmFormat == MI_IPU_FORMAT_FP32)
    {
        memcpy(pTensorData, pfData, H * W * C * sizeof(MI_FLOAT));
    }
}

#define CLIP3(x, min, max) ((x) < (min) ? (min) : ((x) > (max) ? (max) : (x)))

void FillInputData(MI_FLOAT* pfData, MI_IPU_TensorVector_t& InputTensorVector, MI_IPU_SubNet_InputOutputDesc_t& desc)
{
    const MI_U32 H = desc.astMI_InputTensorDescs[0].u32TensorShape[1];
    const MI_U32 W = desc.astMI_InputTensorDescs[0].u32TensorShape[2];
    const MI_U32 C = desc.astMI_InputTensorDescs[0].u32TensorShape[3];
    const MI_FLOAT Scale = desc.astMI_InputTensorDescs[0].fScalar;
    const MI_S64 ZeroPoint = desc.astMI_InputTensorDescs[0].s64ZeroPoint;
    MI_S16* pData = (MI_S16*)InputTensorVector.astArrayTensors[0].ptTensorData[0];
    for (MI_U32 i = 0; i < H * W * C; i++)
    {
        *(pData + i) = (MI_S16)CLIP3(pfData[i] / Scale + ZeroPoint, -32768 , 32767);
    }
    MI_SYS_FlushInvCache(pData, desc.astMI_InputTensorDescs[0].s32AlignedBufSize);
}

python3 ~/SGS_IPU_SDK/Scripts/examples/caffe_faster_rcnn/faster_rcnn_calibrator.py \
-i ~/SGS_Models/resource/detection/voc_calibration_set32/ \
-m0 faster_rcnn_main_float.sim \
-m1 faster_rcnn_stage2_float.sim \
--input_config0 input_config.ini \
--input_config1 input_config_stage2.ini

class Net(calibrator_custom.SIM_Calibrator):
    def __init__(self, main_model_path, main_input_config, second_model_path, second_input_config):
        super().__init__()
        self.main_model = calibrator_custom.calibrator(main_model_path, main_input_config)
        self.second_model = calibrator_custom.calibrator(second_model_path, second_input_config)
        self.rpn = rpn.ProposalLayer()
    def forward(self, x):
        out_details = self.main_model.get_output_details()
        input_data, im_scale = fill_inputImg2main(x)
        self.main_model.set_input(0, input_data)
        self.main_model.invoke()
        result_list = []
        for idx, _ in enumerate(out_details):
            result = self.main_model.get_output(idx)
            result_list.append(result)
        im_info = np.array([x.shape[0], x.shape[1], im_scale]).reshape(1, 3)
        bottom = [result_list[0], result_list[1], im_info]
        roi = self.rpn.forward(bottom)
        out2_details = self.second_model.get_output_details()
        self.second_model.set_input(0, result_list[2])
        self.second_model.set_input(1, roi)
        self.second_model.invoke()
        second_result = []
        for idx, _ in enumerate(out2_details):
            result = self.second_model.get_output(idx)
            second_result.append(result)
        return second_result

net = Net()
net.convert(img_gen, num_process=num_subsets, fix_model=[out_main_model, out_second_model])

python3 ~/SGS_IPU_SDK/Scripts/examples/caffe_faster_rcnn/faster_rcnn_simulator.py \
-i ~/SGS_Models/resource/detection/004545.jpg \
-m0 faster_rcnn_main_float.sim \
-m1 faster_rcnn_stage2_float.sim \
-t Float

class Net(calibrator_custom.SIM_Simulator):
    def __init__(self, main_model_path, second_model_path, phase):
        super().__init__()
        if phase == 'Float':
            self.main_model = calibrator_custom.float_simulator(main_model_path)
            self.second_model = calibrator_custom.float_simulator(second_model_path)
            self.norm = True
        elif phase == 'Fixed':
            self.main_model = calibrator_custom.fixed_simulator(main_model_path)
            self.second_model = calibrator_custom.fixed_simulator(second_model_path)
            self.norm = False
        else:
            self.main_model = calibrator_custom.offline_simulator(main_model_path)
            self.second_model = calibrator_custom.offline_simulator(second_model_path)
            self.norm = False
        self.rpn = rpn.ProposalLayer()
    def forward(self, x):
        # Run main model
        out_details = self.main_model.get_output_details()
        input_data, im_scale = fill_inputImg2main(x, norm=norm)
        self.main_model.set_input(0, input_data)
        self.main_model.invoke()
        def forward(self, x):
            out_details = self.main_model.get_output_details()
            input_data, im_scale = fill_inputImg2main(x)
            self.main_model.set_input(0, input_data)
            self.main_model.invoke()
            result_list = []
            for idx, _ in enumerate(out_details):
                result = self.main_model.get_output(idx)
                result_list.append(result)
            im_info = np.array([x.shape[0], x.shape[1], im_scale]).reshape(1, 3)
            bottom = [result_list[0], result_list[1], im_info]
            roi = self.rpn.forward(bottom)
            out2_details = self.second_model.get_output_details()
            self.second_model.set_input(0, result_list[2])
            if self.norm:
                self.second_model.set_input(1, roi)
            else:
                self.second_model.set_input(1, roi)
            self.second_model.invoke()
            second_result = []
            for idx, _ in enumerate(out2_details):
                result = self.second_model.get_output(idx)
                second_result.append(result)
            return second_result

net = Net()
results = net(img_gen, num_process=num_subsets)

import tensorflow as tf
import numpy as np

SHAPE_DIMS = 256

input_np0 = np.random.rand(1, SHAPE_DIMS).astype(np.float32)
input_np1 = np.random.rand(1, SHAPE_DIMS).astype(np.float32)

input_0 = tf.placeholder(dtype=tf.float32, shape=(1, SHAPE_DIMS), name='input0')
input_1 = tf.placeholder(dtype=tf.float32, shape=(1, SHAPE_DIMS), name='input1')
out = tf.matmul(input_0, tf.reshape(input_1, (SHAPE_DIMS, 1)), name='output')

with tf.Session() as sess:
    results = sess.run(out, feed_dict={input_0: input_np0, input_1: input_np1})

    # Convert .pb
    output_graph_def = tf.graph_util.convert_variables_to_constants(
        sess,
        sess.graph_def,
        ['output']
    )
    with tf.gfile.GFile('matmul.pb', 'wb') as f:
        f.write(output_graph_def.SerializeToString())
    print('matmul.pb Saved!')

# convert to .tflite
tflite_model = tf.lite.TFLiteConverter.from_frozen_graph(
    'matmul.pb',
    ['input0', 'input1'],
    ['output']
)
tflite_model = tflite_model.convert()
with open('matmul.tflite', 'wb') as f:
    f.write(tflite_model)
print('matmul.tflite Saved!')

[INPUT_CONFIG]
inputs=input0,input1;
input_formats=RAWDATA_F32_NHWC,RAWDATA_F32_NHWC;
quantization=TRUE,TRUE;

[OUTPUT_CONFIG]
outputs=output;
dequantization=TRUE;

cd ~/SGS_IPU_SDK
source cfg_env.sh

python3 ~/SGS_IPU_SDK/Scripts/ConvertTool/ConvertTool.py tflite \
--model_file /path/to/matmul.tflite \
--input_config /path/to/input_config.ini \
--output_file /path/to/matmul_float.sim

# -*- coding: utf-8 -*-

import calibrator_custom
import os
import sys
import numpy as np
import argparse
from calibrator_custom import utils

class Net(calibrator_custom.SIM_Calibrator):
    def __init__(self, model_path, input_config):
        super().__init__()
        self.model = calibrator_custom.calibrator(model_path, input_config)

    def forward(self, x, y):
        out_details = self.model.get_output_details()
        self.model.set_input(0, x)
        self.model.set_input(1, y)
        self.model.invoke()
        result_list = []
        for idx in range(len(out_details)):
            result = self.model.get_output(idx)
            result_list.append(result)
        return result_list

def arg_parse():
    parser = argparse.ArgumentParser(description='Calibrator Tool')
    parser.add_argument('-m', '--model', type=str, required=True,
                        help='Model path.')
    parser.add_argument('--input_config', type=str, required=True,
                        help='Input config path.')
    parser.add_argument('--quant_level', type=str, default='L5',
                        choices=['L1', 'L2', 'L3', 'L4', 'L5'],
                        help='Indicate Quantilization level. The higher the level,\
                        the slower the speed and the higher the accuracy.')
    parser.add_argument('--num_process', default=10, type=int,
                        help='Amount of processes run at same time.')
    parser.add_argument('-o', '--output', default=None, type=str,
                        help='Output path for fixed model.')

    return parser.parse_args()

def data_gen():
    calibrator_data = np.random.rand(100, 1, 256).astype(np.float32)
    bench_data = np.random.rand(100, 1, 256).astype(np.float32)
    for i, j in zip(calibrator_data, bench_data):
        yield [i, j]

def main():
    args = arg_parse()
    model_path = args.model
    input_config = args.input_config
    quant_level = args.quant_level
    num_subsets = args.num_process
    output = args.output

    if not os.path.exists(model_path):
        raise FileNotFoundError('No such {} model'.format(model_path))

    if not os.path.exists(input_config):
        raise FileNotFoundError('input_config.ini file not found.')

    net = Net(model_path, input_config)
    print(net)

    # random generate data
    # must change real data when using
    img_gen = data_gen()
    print('\033[31m[WARNING] random generate data,\
          must change real data when using!\033[0m',
          file=sys.stderr)

    out_model = utils.get_out_model_name(model_path, output)
    net.convert(img_gen, num_process=num_subsets,
                quant_level=quant_level, fix_model=[out_model])

if __name__ == '__main__':
    main()

python3 matmul_calibrator.py \
-m /path/to/matmul_float.sim \
--input_config /path/to/input_config.ini

class Net(calibrator_custom.SIM_Simulator):
    def __init__(self, model_path, phase):
        super().__init__()
        if phase == 'Float':
            self.model = calibrator_custom.float_simulator(model_path)
        elif phase == 'Fixed':
            self.model = calibrator_custom.fixed_simulator(model_path)
        else:
            self.model = calibrator_custom.offline_simulator(model_path)

    def forward(self, x, y):
        out_details = self.model.get_output_details()
        self.model.set_input(0, x)
        self.model.set_input(1, y)
        self.model.invoke()
        result_list = []
        for idx, _ in enumerate(out_details):
            result = self.model.get_output(idx)
            result_list.append(result)
        return result_list

// input0
MI_FLOAT* pData0 = (MI_FLOAT*)InputTensorVector.astArrayTensors[0].ptTensorData[0];
// input1
MI_FLOAT* pData1 = (MI_FLOAT*)InputTensorVector.astArrayTensors[1].ptTensorData[0];