单模型单设备样例

下面样例介绍如何在单个后摩设备上推理一个ResNet50网络模型。样例使用单线程、单个stream（默认stream）、1个batch对模型进行推理。示例展示关键步骤代码，仅供参考，不可以直接拷贝运行。有关TCIM API详情，参看 《TCIM开发者手册》。

4.6.3.1. C++ API

使用C++ API推理模型，主要步骤如下：

1. 调用 tcim::Module::LoadFromFile 加载编译模型 TCIM_PATH/inferences/resnet50/resnet50.hmm。

auto module = tcim::Module::LoadFromFile("resnet50.hmm");

2. 准备模型输入。调用 tcim::Module::GetInputNum 获取输入数据的数量。对每个输入：

   1. 调用 tcim::Module::GetInputName 获取输入名称。

   2. 调用 tcim::Module::GetInputInfo 获取输入信息，并调用 TensorInfo::AsContiguous 创建 TensorInfo 对象，将张量的内存布局更改为连续。

   3. 调用 tcim::Tensor::CreateHostTensor 为输入数据分配CPU内存。

   4. 定义一个 input_map，存入输入名称与输入数据的对应关系。

std::map<std::string, tcim::Tensor> input_map;
// Get the total number of inputs
int input_num = module.GetInputNum();
std::cout << "Count of Input: " << input_num << std::endl;
// For each input:
for (int idx = 0; idx < input_num; idx++) {
  // Get the name of the input
  auto input_name = module.GetInputName(idx);
  // Get input data information
  auto input_info = module.GetInputInfo(input_name).AsContiguous();
  std::cout << "Input[" << input_name << "] " << input_info << std::endl;
  // Allocate memory on host CPU for storing input data
  auto input_tensor = tcim::Tensor::CreateHostTensor(input_info);
  // Create a map between input name and input tensor
  input_map.insert(std::pair<std::string, tcim::Tensor>(input_name, input_tensor));
}

3. 图像预处理。示例将 snake.png 图片调整为：

   • 图像格式从BGR转为YUV420SP。

   • 图像大小调整为 224 x 224 x 3。

cv::Mat img_rgb;
cv::Mat img_yuv;
// Load the image
img_rgb = cv::imread("../../data/snake.png");
// Convert BGR to RGB
ImageProc::BgrToRgb((int8_t *)(img_rgb.data), img_rgb.rows, img_rgb.cols);
// Resize the RGB image to (224, 224)
cv::resize(img_rgb, img_rgb, {224, 224});
// Convert RGB to YUV420P
cv::cvtColor(img_rgb, img_yuv, cv::COLOR_RGB2YUV_I420);
// Calculate the size of the YUV image
int size = 224*224*3;
// Convert image format to YUV420SP and store the result in the input_map at "input.1"
ImageProc::I420To420sp((uint8_t *)input_map.at("input.1").Data(), (uint8_t *)img_yuv.data, size);

4. 准备模型输出。调用 tcim::Module::GetOutputNum 获取输出数据数量。对每个输出：

   1. 调用 tcim::Module::GetOutputName 获取输出名称。

   2. 调用 tcim::Module::GetOutputInfo 获取输出信息，并调用 TensorInfo::AsContiguous 创建 TensorInfo 对象，将张量的内存布局更改为连续。

   3. 调用 tcim::Tensor::CreateHostTensor 为输出数据分配CPU内存。

   4. 定义 output_map，插入输出名称与输出数据的对应关系。

// Create a map to store output data
std::map<std::string, tcim::Tensor> output_map;
// Get total number of outputs
int output_num = module.GetOutputNum();
std::cout << "Count of Output: " << output_num << std::endl;
//For each output:
for (int idx = 0; idx < output_num; idx++) {
  // Get the name of the output
  auto output_name = module.GetOutputName(idx);
  // Get the information of the output
  auto output_info = module.GetOutputInfo(output_name).AsContiguous();
  std::cout << "Output[" << output_name << "] " << output_info << std::endl;
  // Allocate memory on host CPU for storing output data
  auto output_tensor = tcim::Tensor::CreateHostTensor(output_info);
  // Insert the output name and tensor into the output map
  output_map.insert(std::pair<std::string, tcim::Tensor>(output_name, output_tensor));
}

5. 调用 tcim::Module::SetInput 设置输入。

// Loop through each key-value pair in the input_map
for (const auto& input : input_map) {
  // Set each input with the key-value pair from the input_map
  module.SetInput(input.first, input.second);
}

6. 分别调用 tcim::Module::Run 和 tcim::Module::Sync 推理和同步模型。

module.Run();
module.Sync();

7. 调用 tcim::Module::GetOutput 获取推理输出数据。

// Loop through each key-value pair in the output_map
for (auto& output : output_map) {
  // Get each output with the key-value pair from the output_map
  module.GetOutput(output.first, output.second);
}

8. 预测结果展示，包括conf（置信度）和label（目标类别）等。

// Initialize top1 to store the index of the top-ranked result
int top1 = 0;
// Iterate through each output in the output_map
for (auto& output : output_map) {
  // Create a vector to store pairs of confidence scores and their corresponding indices
  std::vector<std::pair<float, int>> sort_pairs;
  // Set sort_pairs with confidence scores and the corresponding indices
  for (int i = 0; i < 1000; ++i) {
    // Extract confidence score at index i and pair it with its index
    sort_pairs.emplace_back(static_cast<float*>(output.second.Data())[i], i);
  }
  // Sort sort_pairs in descending order based on confidence scores
  std::sort(sort_pairs.begin(), sort_pairs.end(),
            [](const std::pair<float, int>& a, const std::pair<float, int>& b) {
            return a.first > b.first;
            });
  // Specify the topk (top k) results to display
  const int topk = 5;
  // Return the topk results with their index, confidence score, and corresponding label
  for (int i = 0; i < topk; ++i) {
    std::cout << "top" << (i + 1) << ": Index="
              << sort_pairs[i].second << " Conf=" << sort_pairs[i].first
              << ", Label=[" << Imagenet::GetLabel(sort_pairs[i].second) << "]" << std::endl;
  }
  // Check result, modify it when you change model or data
  if (sort_pairs[0].second != 65) {
    std::cout << "top1 != 65" << std::endl;
    exit(-1);
  }
}

代码详情，参看 TCIM_PATH/inferences/resnet50/resnet50.cc。

4.6.3.2. Python API

使用Python API推理模型，主要步骤如下：

注意

引入外部库时，必须先引入PyTorch库（import torch）再引入TCIM（import tcim_lite as tcim），否则会导致报错。

1. 调用 load 加载已编译的模型文件 resnet50.hmm。

module = tcim.runtime.load("resnet50.hmm")

2. 模型预处理。示例将 snake.png 图像调整为：

   • 图像格式从BGR转为YUV420SP。

   • 图像大小调整为 224 x 224 x 3。

# Load the image
input_data = cv2.imread("../../data/snake.png")
# Resize the image to (224, 224)
input_data = cv2.resize(input_data, (224, 224))
# Transpose the image dimensions to channel first
input_data = np.transpose(input_data, (2, 0, 1))
# Add a batch dimension
input_data = np.expand_dims(input_data, axis=0)
# Convert to torch tensor and ensure data type is float32
input_data = torch.tensor(input_data.astype(np.float32))
# Remove the batch dimension added earlier
input_data = torch.squeeze(input_data, 0)
# Conver image format from BGR to YUV420
from transform import BGR2YUV
rgb2yuv_func = BGR2YUV(fmt='YUV420')
# Apply the RGB to YUV transformation and convert back to numpy array
input_data = torch.unsqueeze(rgb2yuv_func(input_data), 0).numpy()
# Convert data type to uint8
input_data = input_data.astype(np.uint8)

3. 准备模型输入并设置输入数据。调用 get_num_inputs 获取输入数据的数量。对每个输入：

   1. 调用 get_input_name 获取输入名称。

   2. 调用 get_input_info 获取输入信息。

   3. 调用 set_input 设置输入。

# Get the total number of inputs
input_num = module.get_num_inputs()
# For each input
for id in range(0, input_num):
    # Get the input name
    input_name = module.get_input_name(id)
    # Get the information about input data
    input_info = module.get_input_info(input_name).ascontiguous()
    print("input[{}] shape = {}, dtype = {}, format = {}".format(input_name, input_info.shape, input_info.dtype, input_info.format.name))
    # Set input data to the module with the given input name
    module.set_input(input_name, input_data)

4. 分别调用 run 和 sync 推理和同步模型。

module.run()
module.sync()

5. 准备模型输出，并获取输出数据。调用 get_num_outputs 获取输出数据的数量。对每个输出：

   1. 调用 get_output_name 获取输出名称。

   2. 调用 get_output_info 获取输出信息。

   3. 调用 get_output 获取输出数据。

   4. 调用 astype 将输出数据转为float32类型tensor。

   5. 调用 numpy 获取反量化后tensor数据，并设置为输出数据。

result_check = True
# Get the total number of outputs
output_num = module.get_num_outputs()
# For each output:
for id in range(0, output_num):
    # Get the output name
    output_name = module.get_output_name(id)
    # Get the information about output data
    output_info = module.get_output_info(output_name).ascontiguous().astype(np.float32)
    print("output[{}] shape = {}, dtype = {}, format = {}".format(output_name, output_info.shape, output_info.dtype,
                                                                output_info.format.name))
    # Get the output data
    output_data = module.get_output(output_name).astype(np.float32).numpy()

6. 预测结果展示，包括prob（置信度）和cls（目标类别ID）等。

from postprocess import softmax
# Convert output data into probabilities
output_data = softmax(output_data)
topk = 5
# Sort the output data in descending order and select the top topk predictions
pred_list = np.argsort(-output_data, axis=1, kind="quicksort").flatten()[0:topk]
prob_list = output_data.flatten()
# Iterate through the top predictions
for i, id in enumerate(pred_list):
    print("top{}: predict cls = {}, prob = {:.6f}".format(i+1, id, prob_list[id]))

# Check result, modify it when you change model or data
assert(pred_list[0] == 65)

代码详情参看 TCIM_PATH/inferences/resnet50/resnet50.py。