| /* Copyright 2019 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/kernels/internal/reference/pooling.h" |
| |
| #include "tensorflow/lite/c/builtin_op_data.h" |
| #include "tensorflow/lite/kernels/internal/reference/integer_ops/pooling.h" |
| #include "tensorflow/lite/kernels/internal/tensor_ctypes.h" |
| #include "tensorflow/lite/kernels/kernel_util.h" |
| #include "tensorflow/lite/kernels/padding.h" |
| |
| namespace tflite { |
| namespace ops { |
| namespace micro { |
| namespace pooling { |
| |
| namespace { |
| |
| constexpr int kInputTensor = 0; |
| constexpr int kOutputTensor = 0; |
| |
| struct OpData { |
| TfLitePaddingValues padding; |
| }; |
| |
| TfLiteStatus CalculateOpData(const TfLiteContext* context, |
| const TfLitePoolParams* params, |
| const TfLiteTensor* input, |
| const TfLiteTensor* output, OpData* data) { |
| // input: batch, height, width, channel |
| int height = SizeOfDimension(input, 1); |
| int width = SizeOfDimension(input, 2); |
| |
| int out_height, out_width; |
| |
| data->padding = ComputePaddingHeightWidth( |
| params->stride_height, params->stride_width, |
| /*dilation_rate_height=*/1, |
| /*dilation_rate_width=*/1, height, width, params->filter_height, |
| params->filter_width, params->padding, &out_height, &out_width); |
| |
| return kTfLiteOk; |
| } |
| |
| void AverageEvalFloat(const TfLiteContext* context, const TfLiteNode* node, |
| const TfLitePoolParams* params, const OpData* data, |
| const TfLiteTensor* input, TfLiteTensor* output) { |
| float activation_min, activation_max; |
| CalculateActivationRange(params->activation, &activation_min, |
| &activation_max); |
| |
| PoolParams op_params; |
| op_params.stride_height = params->stride_height; |
| op_params.stride_width = params->stride_width; |
| op_params.filter_height = params->filter_height; |
| op_params.filter_width = params->filter_width; |
| op_params.padding_values.height = data->padding.height; |
| op_params.padding_values.width = data->padding.width; |
| op_params.float_activation_min = activation_min; |
| op_params.float_activation_max = activation_max; |
| reference_ops::AveragePool( |
| op_params, GetTensorShape(input), GetTensorData<float>(input), |
| GetTensorShape(output), GetTensorData<float>(output)); |
| } |
| |
| void AverageEvalQuantized(TfLiteContext* context, const TfLiteNode* node, |
| const TfLitePoolParams* params, const OpData* data, |
| const TfLiteTensor* input, TfLiteTensor* output) { |
| TFLITE_DCHECK(input->type == kTfLiteUInt8 || input->type == kTfLiteInt8); |
| int32_t activation_min, activation_max; |
| (void)CalculateActivationRangeQuantized(context, params->activation, output, |
| &activation_min, &activation_max); |
| |
| PoolParams op_params; |
| op_params.stride_height = params->stride_height; |
| op_params.stride_width = params->stride_width; |
| op_params.filter_height = params->filter_height; |
| op_params.filter_width = params->filter_width; |
| op_params.padding_values.height = data->padding.height; |
| op_params.padding_values.width = data->padding.width; |
| op_params.quantized_activation_min = activation_min; |
| op_params.quantized_activation_max = activation_max; |
| |
| if (input->type == kTfLiteUInt8) { |
| reference_ops::AveragePool( |
| op_params, GetTensorShape(input), GetTensorData<uint8_t>(input), |
| GetTensorShape(output), GetTensorData<uint8_t>(output)); |
| } else { |
| reference_integer_ops::AveragePool( |
| op_params, GetTensorShape(input), GetTensorData<int8_t>(input), |
| GetTensorShape(output), GetTensorData<int8_t>(output)); |
| } |
| } |
| |
| void MaxEvalFloat(TfLiteContext* context, TfLiteNode* node, |
| TfLitePoolParams* params, OpData* data, |
| const TfLiteTensor* input, TfLiteTensor* output) { |
| float activation_min, activation_max; |
| CalculateActivationRange(params->activation, &activation_min, |
| &activation_max); |
| |
| tflite::PoolParams op_params; |
| op_params.stride_height = params->stride_height; |
| op_params.stride_width = params->stride_width; |
| op_params.filter_height = params->filter_height; |
| op_params.filter_width = params->filter_width; |
| op_params.padding_values.height = data->padding.height; |
| op_params.padding_values.width = data->padding.width; |
| op_params.float_activation_min = activation_min; |
| op_params.float_activation_max = activation_max; |
| reference_ops::MaxPool(op_params, GetTensorShape(input), |
| GetTensorData<float>(input), GetTensorShape(output), |
| GetTensorData<float>(output)); |
| } |
| |
| void MaxEvalQuantized(TfLiteContext* context, TfLiteNode* node, |
| TfLitePoolParams* params, OpData* data, |
| const TfLiteTensor* input, TfLiteTensor* output) { |
| TFLITE_DCHECK(input->type == kTfLiteUInt8 || input->type == kTfLiteInt8); |
| |
| int32_t activation_min, activation_max; |
| (void)CalculateActivationRangeQuantized(context, params->activation, output, |
| &activation_min, &activation_max); |
| |
| tflite::PoolParams op_params; |
| op_params.stride_height = params->stride_height; |
| op_params.stride_width = params->stride_width; |
| op_params.filter_height = params->filter_height; |
| op_params.filter_width = params->filter_width; |
| op_params.padding_values.height = data->padding.height; |
| op_params.padding_values.width = data->padding.width; |
| op_params.quantized_activation_min = activation_min; |
| op_params.quantized_activation_max = activation_max; |
| |
| if (input->type == kTfLiteUInt8) { |
| reference_ops::MaxPool( |
| op_params, GetTensorShape(input), GetTensorData<uint8_t>(input), |
| GetTensorShape(output), GetTensorData<uint8_t>(output)); |
| } else { |
| reference_integer_ops::MaxPool( |
| op_params, GetTensorShape(input), GetTensorData<int8_t>(input), |
| GetTensorShape(output), GetTensorData<int8_t>(output)); |
| } |
| } |
| } // namespace |
| |
| |
| TfLiteStatus AverageEval(TfLiteContext* context, TfLiteNode* node) { |
| auto* params = reinterpret_cast<TfLitePoolParams*>(node->builtin_data); |
| OpData data; |
| |
| const TfLiteTensor* input = GetInput(context, node, kInputTensor); |
| TfLiteTensor* output = GetOutput(context, node, kOutputTensor); |
| |
| TF_LITE_ENSURE_STATUS(CalculateOpData(context, params, input, output, &data)); |
| |
| // Inputs and outputs share the same type, guaranteed by the converter. |
| switch (input->type) { |
| case kTfLiteFloat32: |
| AverageEvalFloat(context, node, params, &data, input, output); |
| break; |
| case kTfLiteUInt8: |
| case kTfLiteInt8: |
| AverageEvalQuantized(context, node, params, &data, input, output); |
| break; |
| default: |
| TF_LITE_KERNEL_LOG(context, "Input type %s is not currently supported", |
| TfLiteTypeGetName(input->type)); |
| return kTfLiteError; |
| } |
| return kTfLiteOk; |
| } |
| |
| TfLiteStatus MaxEval(TfLiteContext* context, TfLiteNode* node) { |
| auto* params = reinterpret_cast<TfLitePoolParams*>(node->builtin_data); |
| OpData data; |
| |
| const TfLiteTensor* input = GetInput(context, node, kInputTensor); |
| TfLiteTensor* output = GetOutput(context, node, kOutputTensor); |
| |
| TF_LITE_ENSURE_STATUS(CalculateOpData(context, params, input, output, &data)); |
| |
| switch (input->type) { |
| case kTfLiteFloat32: |
| MaxEvalFloat(context, node, params, &data, input, output); |
| break; |
| case kTfLiteUInt8: |
| case kTfLiteInt8: |
| MaxEvalQuantized(context, node, params, &data, input, output); |
| break; |
| default: |
| TF_LITE_KERNEL_LOG(context, "Type %s not currently supported.", |
| TfLiteTypeGetName(input->type)); |
| return kTfLiteError; |
| } |
| return kTfLiteOk; |
| } |
| |
| } // namespace pooling |
| |
| TfLiteRegistration* Register_AVERAGE_POOL_2D() { |
| static TfLiteRegistration r = {/*init=*/nullptr, |
| /*free=*/nullptr, |
| /*prepare=*/nullptr, |
| /*invoke=*/pooling::AverageEval, |
| /*profiling_string=*/nullptr, |
| /*builtin_code=*/0, |
| /*custom_name=*/nullptr, |
| /*version=*/0}; |
| return &r; |
| } |
| |
| TfLiteRegistration* Register_MAX_POOL_2D() { |
| static TfLiteRegistration r = {/*init=*/nullptr, |
| /*free=*/nullptr, |
| /*prepare=*/nullptr, |
| /*invoke=*/pooling::MaxEval, |
| /*profiling_string=*/nullptr, |
| /*builtin_code=*/0, |
| /*custom_name=*/nullptr, |
| /*version=*/0}; |
| return &r; |
| } |
| |
| } // namespace micro |
| } // namespace ops |
| } // namespace tflite |