tensorflow/lite/micro/kernels/depthwise_conv_common.cc - 3p/tensorflow/tflite-micro - Git at Google

 /* Copyright 2021 The TensorFlow Authors. All Rights Reserved.

 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at

     http://www.apache.org/licenses/LICENSE-2.0

 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 ==============================================================================*/

 #include "tensorflow/lite/c/builtin_op_data.h"
 #include "tensorflow/lite/c/common.h"
 #include "tensorflow/lite/kernels/internal/common.h"
 #include "tensorflow/lite/kernels/internal/quantization_util.h"
 #include "tensorflow/lite/kernels/internal/reference/depthwiseconv_float.h"
 #include "tensorflow/lite/kernels/internal/reference/integer_ops/depthwise_conv.h"
 #include "tensorflow/lite/kernels/internal/tensor_ctypes.h"
 #include "tensorflow/lite/kernels/kernel_util.h"
 #include "tensorflow/lite/kernels/padding.h"
 #include "tensorflow/lite/micro/kernels/depthwise_conv.h"
 #include "tensorflow/lite/micro/kernels/kernel_util.h"

 namespace tflite {

 const int kDepthwiseConvInputTensor = 0;
 const int kDepthwiseConvWeightsTensor = 1;
 const int kDepthwiseConvBiasTensor = 2;
 const int kDepthwiseConvOutputTensor = 0;

 // DepthwiseConv is quantized along dimension 3:
 // https://www.tensorflow.org/lite/performance/quantization_spec
 const int kDepthwiseConvQuantizedDimension = 3;

 // Returns a DepthwiseParams struct with all the parameters needed for a
 // float computation.
 DepthwiseParams DepthwiseConvParamsFloat(
     const TfLiteDepthwiseConvParams& params, const OpDataConv& data) {
   DepthwiseParams op_params;
   CalculateActivationRange(params.activation, &op_params.float_activation_min,
                            &op_params.float_activation_max);
   op_params.padding_type = tflite::micro::RuntimePaddingType(params.padding);
   op_params.padding_values.width = data.padding.width;
   op_params.padding_values.height = data.padding.height;
   op_params.stride_width = params.stride_width;
   op_params.stride_height = params.stride_height;
   op_params.dilation_width_factor = params.dilation_width_factor;
   op_params.dilation_height_factor = params.dilation_height_factor;
   op_params.depth_multiplier = params.depth_multiplier;
   return op_params;
 }

 // Returns a DepthwiseParams struct with all the parameters needed for a
 // quantized computation.
 DepthwiseParams DepthwiseConvParamsQuantized(
     const TfLiteDepthwiseConvParams& params, const OpDataConv& data) {
   DepthwiseParams op_params;
   op_params.input_offset = -data.input_zero_point;
   op_params.weights_offset = -data.filter_zero_point;
   op_params.output_offset = data.output_zero_point;
   op_params.output_multiplier = data.output_multiplier;
   op_params.output_shift = -data.output_shift;
   op_params.padding_type = tflite::micro::RuntimePaddingType(params.padding);
   op_params.padding_values.height = data.padding.height;
   op_params.padding_values.width = data.padding.width;
   op_params.stride_height = params.stride_height;
   op_params.stride_width = params.stride_width;
   op_params.dilation_height_factor = params.dilation_height_factor;
   op_params.dilation_width_factor = params.dilation_width_factor;
   op_params.depth_multiplier = params.depth_multiplier;
   op_params.quantized_activation_min = data.output_activation_min;
   op_params.quantized_activation_max = data.output_activation_max;
   return op_params;
 }

 TfLiteStatus CalculateOpDataDepthwiseConv(
     TfLiteContext* context, TfLiteNode* node,
     const TfLiteDepthwiseConvParams& params, int width, int height,
     int filter_width, int filter_height, int out_width, int out_height,
     const TfLiteType data_type, OpDataConv* data) {
   bool has_bias = node->inputs->size == 3;
   // Check number of inputs/outputs
   TF_LITE_ENSURE(context, has_bias || node->inputs->size == 2);
   TF_LITE_ENSURE_EQ(context, node->outputs->size, 1);

   // Matching GetWindowedOutputSize in TensorFlow.
   auto padding = params.padding;
   data->padding = ComputePaddingHeightWidth(
       params.stride_height, params.stride_width, params.dilation_height_factor,
       params.dilation_width_factor, height, width, filter_height, filter_width,
       padding, &out_height, &out_width);

   MicroContext* micro_context = GetMicroContext(context);

   TfLiteTensor* input =
       micro_context->AllocateTempInputTensor(node, kConvInputTensor);
   TF_LITE_ENSURE(context, input != nullptr);
   TfLiteTensor* filter =
       micro_context->AllocateTempInputTensor(node, kConvWeightsTensor);
   TF_LITE_ENSURE(context, filter != nullptr);
   TfLiteTensor* bias =
       micro_context->AllocateTempInputTensor(node, kConvBiasTensor);
   TfLiteTensor* output =
       micro_context->AllocateTempOutputTensor(node, kConvOutputTensor);
   TF_LITE_ENSURE(context, output != nullptr);

   // Note that quantized inference requires that all tensors have their
   // parameters set. This is usually done during quantized training.
   if (data_type != kTfLiteFloat32) {
     int output_channels = filter->dims->data[kDepthwiseConvQuantizedDimension];

     TF_LITE_ENSURE_STATUS(tflite::PopulateConvolutionQuantizationParams(
         context, input, filter, bias, output, params.activation,
         &data->output_multiplier, &data->output_shift,
         &data->output_activation_min, &data->output_activation_max,
         data->per_channel_output_multiplier, data->per_channel_output_shift,
         output_channels));
   }

   data->input_zero_point = input->params.zero_point;
   data->filter_zero_point = filter->params.zero_point;
   data->output_zero_point = output->params.zero_point;

   micro_context->DeallocateTempTfLiteTensor(input);
   micro_context->DeallocateTempTfLiteTensor(filter);
   micro_context->DeallocateTempTfLiteTensor(bias);
   micro_context->DeallocateTempTfLiteTensor(output);

   return kTfLiteOk;
 }

 TfLiteStatus DepthwiseConvPrepare(TfLiteContext* context, TfLiteNode* node) {
   TFLITE_DCHECK(node->user_data != nullptr);
   TFLITE_DCHECK(node->builtin_data != nullptr);

   OpDataConv* data = static_cast<OpDataConv*>(node->user_data);
   const auto& params =
       *(static_cast<const TfLiteDepthwiseConvParams*>(node->builtin_data));
   MicroContext* micro_context = GetMicroContext(context);

   TfLiteTensor* output =
       micro_context->AllocateTempOutputTensor(node, kDepthwiseConvOutputTensor);
   TF_LITE_ENSURE(context, output != nullptr);
   TfLiteTensor* input =
       micro_context->AllocateTempInputTensor(node, kDepthwiseConvInputTensor);
   TF_LITE_ENSURE(context, input != nullptr);
   TfLiteTensor* filter =
       micro_context->AllocateTempInputTensor(node, kDepthwiseConvWeightsTensor);
   TF_LITE_ENSURE(context, filter != nullptr);

   const int input_width = input->dims->data[2];
   const int input_height = input->dims->data[1];
   const int filter_width = filter->dims->data[2];
   const int filter_height = filter->dims->data[1];
   const int output_width = output->dims->data[2];
   const int output_height = output->dims->data[1];

   // Dynamically allocate per-channel quantization parameters.
   const int num_channels = filter->dims->data[kDepthwiseConvQuantizedDimension];
   data->per_channel_output_multiplier =
       static_cast<int32_t*>(context->AllocatePersistentBuffer(
           context, num_channels * sizeof(int32_t)));
   data->per_channel_output_shift =
       static_cast<int32_t*>(context->AllocatePersistentBuffer(
           context, num_channels * sizeof(int32_t)));

   // All per-channel quantized tensors need valid zero point and scale arrays.
   if (input->type == kTfLiteInt8) {
     TF_LITE_ENSURE_EQ(context, filter->quantization.type,
                       kTfLiteAffineQuantization);

     const auto* affine_quantization =
         static_cast<TfLiteAffineQuantization*>(filter->quantization.params);
     TFLITE_DCHECK(affine_quantization != nullptr);
     TFLITE_DCHECK(affine_quantization->scale != nullptr);
     TFLITE_DCHECK(affine_quantization->zero_point != nullptr);

     TF_LITE_ENSURE(
         context, affine_quantization->scale->size == 1 ||
                      affine_quantization->scale->size ==
                          filter->dims->data[kDepthwiseConvQuantizedDimension]);

     TF_LITE_ENSURE_EQ(context, affine_quantization->scale->size,
                       affine_quantization->zero_point->size);
   }

   TF_LITE_ENSURE_MSG(
       context,
       input->type == filter->type ||
           (input->type == kTfLiteInt8 &&
            (filter->type == kTfLiteInt4 || filter->type == kTfLiteInt8)) ||
           (input->type == kTfLiteInt16 && filter->type == kTfLiteInt8),
       "Hybrid models are not supported on TFLite Micro.");

   if (filter->type == kTfLiteInt4) {
     int filter_size =
         RuntimeShape(filter->dims->size,
                      reinterpret_cast<const int32_t*>(filter->dims->data))
             .FlatSize();
     context->RequestScratchBufferInArena(context, filter_size,
                                          &data->filter_buffer_index);
   }

   TF_LITE_ENSURE_STATUS(CalculateOpDataDepthwiseConv(
       context, node, params, input_width, input_height, filter_width,
       filter_height, output_width, output_height, input->type, data));

   micro_context->DeallocateTempTfLiteTensor(output);
   micro_context->DeallocateTempTfLiteTensor(input);
   micro_context->DeallocateTempTfLiteTensor(filter);

   return kTfLiteOk;
 }

 }  // namespace tflite
	/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.

	Licensed under the Apache License, Version 2.0 (the "License");
	you may not use this file except in compliance with the License.
	You may obtain a copy of the License at

	http://www.apache.org/licenses/LICENSE-2.0

	Unless required by applicable law or agreed to in writing, software
	distributed under the License is distributed on an "AS IS" BASIS,
	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	See the License for the specific language governing permissions and
	limitations under the License.
	==============================================================================*/

	#include "tensorflow/lite/c/builtin_op_data.h"
	#include "tensorflow/lite/c/common.h"
	#include "tensorflow/lite/kernels/internal/common.h"
	#include "tensorflow/lite/kernels/internal/quantization_util.h"
	#include "tensorflow/lite/kernels/internal/reference/depthwiseconv_float.h"
	#include "tensorflow/lite/kernels/internal/reference/integer_ops/depthwise_conv.h"
	#include "tensorflow/lite/kernels/internal/tensor_ctypes.h"
	#include "tensorflow/lite/kernels/kernel_util.h"
	#include "tensorflow/lite/kernels/padding.h"
	#include "tensorflow/lite/micro/kernels/depthwise_conv.h"
	#include "tensorflow/lite/micro/kernels/kernel_util.h"

	namespace tflite {

	const int kDepthwiseConvInputTensor = 0;
	const int kDepthwiseConvWeightsTensor = 1;
	const int kDepthwiseConvBiasTensor = 2;
	const int kDepthwiseConvOutputTensor = 0;

	// DepthwiseConv is quantized along dimension 3:
	// https://www.tensorflow.org/lite/performance/quantization_spec
	const int kDepthwiseConvQuantizedDimension = 3;

	// Returns a DepthwiseParams struct with all the parameters needed for a
	// float computation.
	DepthwiseParams DepthwiseConvParamsFloat(
	const TfLiteDepthwiseConvParams& params, const OpDataConv& data) {
	DepthwiseParams op_params;
	CalculateActivationRange(params.activation, &op_params.float_activation_min,
	&op_params.float_activation_max);
	op_params.padding_type = tflite::micro::RuntimePaddingType(params.padding);
	op_params.padding_values.width = data.padding.width;
	op_params.padding_values.height = data.padding.height;
	op_params.stride_width = params.stride_width;
	op_params.stride_height = params.stride_height;
	op_params.dilation_width_factor = params.dilation_width_factor;
	op_params.dilation_height_factor = params.dilation_height_factor;
	op_params.depth_multiplier = params.depth_multiplier;
	return op_params;
	}

	// Returns a DepthwiseParams struct with all the parameters needed for a
	// quantized computation.
	DepthwiseParams DepthwiseConvParamsQuantized(
	const TfLiteDepthwiseConvParams& params, const OpDataConv& data) {
	DepthwiseParams op_params;
	op_params.input_offset = -data.input_zero_point;
	op_params.weights_offset = -data.filter_zero_point;
	op_params.output_offset = data.output_zero_point;
	op_params.output_multiplier = data.output_multiplier;
	op_params.output_shift = -data.output_shift;
	op_params.padding_type = tflite::micro::RuntimePaddingType(params.padding);
	op_params.padding_values.height = data.padding.height;
	op_params.padding_values.width = data.padding.width;
	op_params.stride_height = params.stride_height;
	op_params.stride_width = params.stride_width;
	op_params.dilation_height_factor = params.dilation_height_factor;
	op_params.dilation_width_factor = params.dilation_width_factor;
	op_params.depth_multiplier = params.depth_multiplier;
	op_params.quantized_activation_min = data.output_activation_min;
	op_params.quantized_activation_max = data.output_activation_max;
	return op_params;
	}

	TfLiteStatus CalculateOpDataDepthwiseConv(
	TfLiteContext* context, TfLiteNode* node,
	const TfLiteDepthwiseConvParams& params, int width, int height,
	int filter_width, int filter_height, int out_width, int out_height,
	const TfLiteType data_type, OpDataConv* data) {
	bool has_bias = node->inputs->size == 3;
	// Check number of inputs/outputs
	TF_LITE_ENSURE(context, has_bias \|\| node->inputs->size == 2);
	TF_LITE_ENSURE_EQ(context, node->outputs->size, 1);

	// Matching GetWindowedOutputSize in TensorFlow.
	auto padding = params.padding;
	data->padding = ComputePaddingHeightWidth(
	params.stride_height, params.stride_width, params.dilation_height_factor,
	params.dilation_width_factor, height, width, filter_height, filter_width,
	padding, &out_height, &out_width);

	MicroContext* micro_context = GetMicroContext(context);

	TfLiteTensor* input =
	micro_context->AllocateTempInputTensor(node, kConvInputTensor);
	TF_LITE_ENSURE(context, input != nullptr);
	TfLiteTensor* filter =
	micro_context->AllocateTempInputTensor(node, kConvWeightsTensor);
	TF_LITE_ENSURE(context, filter != nullptr);
	TfLiteTensor* bias =
	micro_context->AllocateTempInputTensor(node, kConvBiasTensor);
	TfLiteTensor* output =
	micro_context->AllocateTempOutputTensor(node, kConvOutputTensor);
	TF_LITE_ENSURE(context, output != nullptr);

	// Note that quantized inference requires that all tensors have their
	// parameters set. This is usually done during quantized training.
	if (data_type != kTfLiteFloat32) {
	int output_channels = filter->dims->data[kDepthwiseConvQuantizedDimension];

	TF_LITE_ENSURE_STATUS(tflite::PopulateConvolutionQuantizationParams(
	context, input, filter, bias, output, params.activation,
	&data->output_multiplier, &data->output_shift,
	&data->output_activation_min, &data->output_activation_max,
	data->per_channel_output_multiplier, data->per_channel_output_shift,
	output_channels));
	}

	data->input_zero_point = input->params.zero_point;
	data->filter_zero_point = filter->params.zero_point;
	data->output_zero_point = output->params.zero_point;

	micro_context->DeallocateTempTfLiteTensor(input);
	micro_context->DeallocateTempTfLiteTensor(filter);
	micro_context->DeallocateTempTfLiteTensor(bias);
	micro_context->DeallocateTempTfLiteTensor(output);

	return kTfLiteOk;
	}

	TfLiteStatus DepthwiseConvPrepare(TfLiteContext* context, TfLiteNode* node) {
	TFLITE_DCHECK(node->user_data != nullptr);
	TFLITE_DCHECK(node->builtin_data != nullptr);

	OpDataConv* data = static_cast<OpDataConv*>(node->user_data);
	const auto& params =
	(static_cast<const TfLiteDepthwiseConvParams>(node->builtin_data));
	MicroContext* micro_context = GetMicroContext(context);

	TfLiteTensor* output =
	micro_context->AllocateTempOutputTensor(node, kDepthwiseConvOutputTensor);
	TF_LITE_ENSURE(context, output != nullptr);
	TfLiteTensor* input =
	micro_context->AllocateTempInputTensor(node, kDepthwiseConvInputTensor);
	TF_LITE_ENSURE(context, input != nullptr);
	TfLiteTensor* filter =
	micro_context->AllocateTempInputTensor(node, kDepthwiseConvWeightsTensor);
	TF_LITE_ENSURE(context, filter != nullptr);

	const int input_width = input->dims->data[2];
	const int input_height = input->dims->data[1];
	const int filter_width = filter->dims->data[2];
	const int filter_height = filter->dims->data[1];
	const int output_width = output->dims->data[2];
	const int output_height = output->dims->data[1];

	// Dynamically allocate per-channel quantization parameters.
	const int num_channels = filter->dims->data[kDepthwiseConvQuantizedDimension];
	data->per_channel_output_multiplier =
	static_cast<int32_t*>(context->AllocatePersistentBuffer(
	context, num_channels * sizeof(int32_t)));
	data->per_channel_output_shift =
	static_cast<int32_t*>(context->AllocatePersistentBuffer(
	context, num_channels * sizeof(int32_t)));

	// All per-channel quantized tensors need valid zero point and scale arrays.
	if (input->type == kTfLiteInt8) {
	TF_LITE_ENSURE_EQ(context, filter->quantization.type,
	kTfLiteAffineQuantization);

	const auto* affine_quantization =
	static_cast<TfLiteAffineQuantization*>(filter->quantization.params);
	TFLITE_DCHECK(affine_quantization != nullptr);
	TFLITE_DCHECK(affine_quantization->scale != nullptr);
	TFLITE_DCHECK(affine_quantization->zero_point != nullptr);

	TF_LITE_ENSURE(
	context, affine_quantization->scale->size == 1 \|\|
	affine_quantization->scale->size ==
	filter->dims->data[kDepthwiseConvQuantizedDimension]);

	TF_LITE_ENSURE_EQ(context, affine_quantization->scale->size,
	affine_quantization->zero_point->size);
	}

	TF_LITE_ENSURE_MSG(
	context,
	input->type == filter->type \|\|
	(input->type == kTfLiteInt8 &&
	(filter->type == kTfLiteInt4 \|\| filter->type == kTfLiteInt8)) \|\|
	(input->type == kTfLiteInt16 && filter->type == kTfLiteInt8),
	"Hybrid models are not supported on TFLite Micro.");

	if (filter->type == kTfLiteInt4) {
	int filter_size =
	RuntimeShape(filter->dims->size,
	reinterpret_cast<const int32_t*>(filter->dims->data))
	.FlatSize();
	context->RequestScratchBufferInArena(context, filter_size,
	&data->filter_buffer_index);
	}

	TF_LITE_ENSURE_STATUS(CalculateOpDataDepthwiseConv(
	context, node, params, input_width, input_height, filter_width,
	filter_height, output_width, output_height, input->type, data));

	micro_context->DeallocateTempTfLiteTensor(output);
	micro_context->DeallocateTempTfLiteTensor(input);
	micro_context->DeallocateTempTfLiteTensor(filter);

	return kTfLiteOk;
	}

	} // namespace tflite