AIoT应用创新大赛-基于TencentOS Tiny & Yolo v3的濒危动物野外目标识别跟踪系统

converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.representative_dataset = representative_data_gen
# Ensure that if any ops can't be quantized, the converter throws an error
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
# Set the input and output tensors to uint8 (APIs added in r2.3)
converter.inference_input_type = tf.int8
converter.inference_output_type = tf.int8
tflite_model_quant = converter.convert()

# Save the model.
with open('xxx.tflite', 'wb') as f:
    f.write(tflite_model_quant)

/* 从sd卡中获取tflite模型 */
int fatfs_get_model(void* pModel, uint32_t size)
{
	DIR DirInfo;
	FILINFO FilInfo;
	FIL File;
	FRESULT error;
	UINT bytesRead;
	UINT bytesModel = 0;
	char name[64];

    if(f_opendir(&DirInfo, (const TCHAR*)"/") == FR_OK)	/* 打开文件夹目录成功，目录信息已经在dir结构体中保存 */
    {
        while(f_readdir(&DirInfo, &FilInfo) == FR_OK)  	/* 读文件信息到文件状态结构体中 */
        {
            if(!FilInfo.fname[0])
            	break; 									/* 如果文件名为‘\0'，说明读取完成结束 */

			if(strstr(FilInfo.fname, "tflite") != NULL)
			{
				printf("-> %s | %lu KB <-\r\n", FilInfo.fname, FilInfo.fsize / 1024);
				break;
			}
        }

        bytesModel = FilInfo.fsize;
        strncpy(name, FilInfo.fname, sizeof(name));
        f_closedir(&DirInfo);
    }

    if(bytesModel > size)
    {
    	printf("\tmodel size error\r\n");
    	return -1;
    }

	error = f_open(&File, name, FA_READ);
	if (error)
	{
		printf("\tOpen file failed.\r\n");
		return -1;
	}

	error = f_read(&File, pModel, FilInfo.fsize, &bytesRead);
	if (error)
	{
		printf("\tRead file failed. \r\n");
		return -1;
	}

	if(bytesRead != FilInfo.fsize)
	{
		printf("\tRead size %lu %d.\r\n", FilInfo.fsize, bytesRead);
		return -1;
	}

	printf("\tRead model file ok. \r\n");

	return 0;
}

void setup(void* pModel) {
  // Set up logging. Google style is to avoid globals or statics because of
  // lifetime uncertainty, but since this has a trivial destructor it's okay.
  // NOLINTNEXTLINE(runtime-global-variables)
  static tflite::MicroErrorReporter micro_error_reporter;
  error_reporter = &micro_error_reporter;

  // Map the model into a usable data structure. This doesn't involve any
  // copying or parsing, it's a very lightweight operation.
  model = tflite::GetModel(pModel);
  if (model->version() != TFLITE_SCHEMA_VERSION) {
    TF_LITE_REPORT_ERROR(error_reporter,
                         "Model provided is schema version %d not equal "
                         "to supported version %d",
                         model->version(), TFLITE_SCHEMA_VERSION);
    return;
  }

  // This pulls in all the operation implementations we need.
  // NOLINTNEXTLINE(runtime-global-variables)
  static tflite::AllOpsResolver resolver;

  // Build an interpreter to run the model with.
  static tflite::MicroInterpreter static_interpreter(
      model, resolver, tensor_arena, kTensorArenaSize, error_reporter);
  interpreter = &static_interpreter;

  // Allocate memory from the tensor_arena for the model's tensors.
  TfLiteStatus allocate_status = interpreter->AllocateTensors();
  if (allocate_status != kTfLiteOk) {
    TF_LITE_REPORT_ERROR(error_reporter, "AllocateTensors() failed");
    return;
  }

  // Obtain pointers to the model's input and output tensors.
  input = interpreter->input(0);

  /* yolo 有多个输出层 */
  for(uint32_t i = 0; i < interpreter->outputs_size(); i++) {
	  output[i] = interpreter->output(i);
  }
}

/* 模型输出结果的处理关键部分 */
for(uint32_t i = 0; i < interpreter->outputs_size(); i++) {
	printf("[output %ld]\r\n", i);

	uint32_t len_x = output[i]->dims->data[1];
	uint32_t len_y = output[i]->dims->data[2];
	uint32_t len_z = output[i]->dims->data[3];

	for(uint32_t i_x = 0; i_x < len_x; i_x++) {
		for(uint32_t i_y = 0; i_y < len_y; i_y++) {
			for(uint32_t i_z = 0; i_z < len_z; i_z++) {
				if(i_z % 6 == 4) {
					uint32_t grid_size = input->dims->data[1] / len_x;
					uint32_t k = (i_x*len_y + i_y)*len_z + i_z;
					float conf = sigmoid(((float)output[i]->data.int8[k] - output[i]->params.zero_point) * output[i]->params.scale);
					if(conf > 0.7) {
						float anchor_x = anchor[i][i_z/6][0];
						float anchor_y = anchor[i][i_z/6][1];
						int32_t pos_x = grid_size * (i_y + sigmoid((output[i]->data.int8[k-3] - output[i]->params.zero_point) * output[i]->params.scale));
						int32_t pos_y = grid_size * (i_x + sigmoid((output[i]->data.int8[k-4] - output[i]->params.zero_point) * output[i]->params.scale));
						int32_t pos_w = anchor_x * expf((output[i]->data.int8[k-2] - output[i]->params.zero_point) * output[i]->params.scale);
						int32_t pos_h = anchor_y * expf((output[i]->data.int8[k-1] - output[i]->params.zero_point) * output[i]->params.scale);
						printf("[conf %.2f] [%ld  %ld  %ld  %ld]\r\n", conf, pos_x, pos_y, pos_w, pos_h);
						push_top_n(conf, pos_x - pos_w/2, pos_y - pos_w/2, pos_x + pos_w/2, pos_y + pos_w/2, i);
					}
				}
			}
		}
	}
}

/* Non-Maximum Suppression */
int nms(float threshold, uint32_t* frame)
{
	int cnt = 0;

	for(uint32_t i = 0; i < TOP_N_SIZE; i++) {
		if(top[i].conf < 0.01)
			continue;
		for(uint32_t n = i + 1; n < TOP_N_SIZE; n++) {
			if(top[n].conf < 0.01)
				break;

			float iou = IoU(top[i].x_1, top[i].y_1, top[i].x_2, top[i].y_2,
							top[n].x_1, top[n].y_1, top[n].x_2, top[n].y_2);
			if(iou > threshold) {
				top[n].conf = 0;
			}
		}
	}

	for(uint32_t i = 0; i < TOP_N_SIZE; i++) {
		if(top[i].conf < 0.01)
			continue;

		uint32_t color;
		if(top[i].layer == 0)
			color = 0x00ff0000;		// 5*5	 红色
		else if(top[i].layer == 1)
			color = 0x0000ff00;		// 10*10 绿色
		else
			color = 0x000000ff;		// 20*20 蓝色
		cnt++;
		display_draw_rect(top[i].x_1, top[i].y_1, top[i].x_2, top[i].y_2, frame, color);
		display_print(frame, top[i].x_1 + 3, top[i].y_1 + 3,  color, "%.2f", top[i].conf);
	}

	return cnt;
}