PaddleLite模型使用
PaddleLite使用流程基本上和TensorflowLite大体类似，只不过输入Tensor的shape信息需要用户自行分配，否则输入和输出Tensor的shape信息全都是默认值0

1、配置 Config 信息：创建 MobileConfig ，用于配置模型路径、运行设备环境等相关信息
2、通过 set_model_from_file 接口配置模型路径

  paddle::lite_api::MobileConfig config;
  config.set_model_from_file(model_path);
  config.set_threads(CPU_THREAD_NUM);
  config.set_power_mode(CPU_POWER_MODE);

3、通过 CreatePaddlePredictor 接口创建 Predictor 对像，完成模型解析和环境初始化。

p->predictor = paddle::lite_api::CreatePaddlePredictor<paddle::lite_api::MobileConfig>(config);

4、推理之前需要向输入 Tensor 中填充数据。即通过 predictor->GetInput(num) 接口获取第 num 个输入 tensor，也可以通过name来获取，获取输入Tensor后先做 Resize 处理，给 tensor 分配相应的空间；然后通过获取 input_tensor->mutable_data<Dtype>() 输入数据地址进行赋值处理

const std::vector<int64_t> INPUT_SHAPE = {1, 426, 640, 3};// NHWC格式
std::unique_ptr<paddle::lite_api::Tensor> input_tensor(
      std::move(predictor->GetInput(0)));
input_tensor->Resize(INPUT_SHAPE);

auto *input_data = input_tensor->mutable_data<float>();//这里模型输入类型fp32
uint8_t *image_data = reinterpret_cast<uint8_t *>(resize_image.data);
cv::Mat out_img = cv::Mat::ones(input_height, input_width, CV_8UC3);
for (int i = 0; i < input_height; ++i) {
    for (int j = 0; j < input_width; ++j) {
        float r = image_data[(i * input_width + j) * 3 + 0];
        float g = image_data[(i * input_width + j) * 3 + 1];
        float b = image_data[(i * input_width + j) * 3 + 2];
        float rr = std::max(-1.0f, std::min(r / 127.5f - 1.0f, 1.0f));//具体模型处理不同
        float gg = std::max(-1.0f, std::min(g / 127.5f - 1.0f, 1.0f));
        float bb = std::max(-1.0f, std::min(b / 127.5f - 1.0f, 1.0f));
        *input_data++ = rr;
        *input_data++ = gg;
        *input_data++ = bb;
        out_img.at<cv::Vec3b>(i, j)[0] = (uint8_t) (r * 255);
        out_img.at<cv::Vec3b>(i, j)[1] = (uint8_t) (g * 255);
        out_img.at<cv::Vec3b>(i, j)[2] = (uint8_t) (b * 255);
    }
}
cv::imwrite("../input.png", out_img);

5、使用 Predictor 对像的成员函数 Run 进行模型推理

predictor->Run();

6、推理执行结束后，通过 predictor->GetOutput(num) 接口获取第 num 个输出 tensor

std::unique_ptr<const paddle::lite_api::Tensor> output_tensor(
      std::move(predictor->GetOutput(0)));  
const float *output_data = output_tensor->mutable_data<float>();
// NHWC
int h = output_tensor->shape().at(1);
int w = output_tensor->shape().at(2);
int c = output_tensor->shape().at(3);
static uint8_t *s_texbuf = nullptr;//纹理内存
if (s_texbuf == nullptr) {
    s_texbuf = (uint8_t *) calloc(1, w * h * 4);
}
uint8_t *d = s_texbuf; 
for (int y = 0; y < h; y++) {
    for (int x = 0; x < w; x++) {
        float r = *output_data++;
        float g = *output_data++;
        float b = *output_data++;
        r = (uint8_t) ((r + 1.0f) / 2.0f * 255);//具体模型处理这里不同
        g = (uint8_t) ((g + 1.0f) / 2.0f * 255);
        b = (uint8_t) ((b + 1.0f) / 2.0f * 255);
        r = std::min(255.0f, r);
        g = std::min(255.0f, g);
        b = std::min(255.0f, b);
        *d++ = r;
        *d++ = g;
        *d++ = b;
        *d++ = 0xFF; 
    }
} 

使用过程遇到问题
如何确定模型预处理和后处理所做的操作
PaddleHub项目提供的待优化的模型压缩包python脚本包含了图像预处理和后处理过程，只需要将python代码中必须的代码转化为c++版本即可，以animegan_v2_shinkai_33模型为例，解压后的目录格式

animegan_v2_shinkai_33                                              
│   ├── animegan_v2_shinkai_33                                       
│   │   ├── __model__
│   │   ├── generator_G_MODEL_A_Conv_1_weights
│   │   ├── generator_G_MODEL_A_Conv_2_weights
│   │   ├── generator_G_MODEL_A_Conv_weights
│   │   ├── generator_G_MODEL_A_LayerNorm_1_beta
│   │   ├── generator_G_MODEL_A_LayerNorm_1_gamma
│   │   └── ......
    └── model.py
    └── module.py
    └── processor.py

module.py脚本中推断逻辑

加载数据处理器

processor = Processor(
    images, 
    paths,  
    output_dir, 
    min_size, 
    max_size
)

# 模型预测
outputs = self.model.predict(processor.input_datas)

# 结果后处理
results = processor.postprocess(outputs, visualization)

# 返回结果
return results

processor.py中预处理和后处理逻辑

    # 数据预处理函数
    def preprocess(self):
        input_datas = []

        # 数据预处理
        for i, img in enumerate(self.datas):
            # 格式转换
            img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
            
            # 缩放图片
            h, w = img.shape[:2]
            if max(h,w)>self.max_size:
                img = cv2.resize(img, (self.max_size, int(h/w*self.max_size))) if h<w else cv2.resize(img, (int(w/h*self.max_size), self.max_size))
            elif min(h,w)<self.min_size:
                img = cv2.resize(img, (self.min_size, int(h/w*self.min_size))) if h>w else cv2.resize(img, (int(w/h*self.min_size), self.min_size))

            # 裁剪图片
            h, w = img.shape[:2]
            img = img[:h-(h%32), :w-(w%32), :]

            # 归一化
            img = img/127.5 - 1.0

            # 新建维度
            img = np.expand_dims(img, axis=0).astype('float32')

            # 加入输入数据列表
            input_datas.append(img)

        # 数据按batch_size切分
        input_datas = np.concatenate(input_datas, 0)
        split_num = len(self.datas)//self.batch_size+1 if len(self.datas)%self.batch_size!=0 else len(self.datas)//self.batch_size
        input_datas = np.array_split(input_datas, split_num)   

        # 返回预处理完成的数据
        return input_datas
    
    # 后处理函数
    def postprocess(self, outputs, visualization):
        results = []

        for im_id, output in enumerate(outputs):
            # 反归一化
            image = (output.squeeze() + 1.) / 2 * 255

            # 限幅
            image = np.clip(image, 0, 255).astype(np.uint8)

            # 格式转换
            image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

            # 可视化
            if visualization:
                # 检查输出目录
                check_dir(self.output_dir)

                # 写入输出图片
                cv2.imwrite(os.path.join(self.output_dir, '%d_%d.jpg' % (im_id, time.time())), image)

            results.append(image)

        # 返回结果
        return results

CUDA和OpenCL支持问题

PaddleLite CUDA和OpenCL支持的op不是很完善，PaddleLite不像TensorflowLite完善，目前没找到什么方式可以在不支持的op情况下自动切换到CPU方式，在加载模型这一步就会出错，提示有不支持的op，并且在模型转化为nb模型这一步如果出现不支持的op就会报错，必须添加对应架构下的op实现，并重新编译PaddleLite和opt导出工具