/*
* Copyright (C) 2017 The Android Open Source Project
*
* 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 "ActivationFunctor.h"
#include "CpuOperationUtils.h"
#include "OperationResolver.h"
#include "tensorflow/lite/kernels/internal/optimized/legacy_optimized_ops.h"
#include "tensorflow/lite/kernels/internal/optimized/optimized_ops.h"
#include "Tracing.h"
namespace android {
namespace nn {
namespace activation {
constexpr uint32_t kNumInputs = 1;
constexpr uint32_t kInputTensor = 0;
constexpr uint32_t kNumOutputs = 1;
constexpr uint32_t kOutputTensor = 0;
namespace {
template <typename T>
bool reluFloat(const T* inputData, const Shape& inputShape, T* outputData, const Shape& outputShape,
float reluMin = 0.f, float reluMax = std::numeric_limits<float>::max()) {
NNTRACE_COMP("reluX");
int numElements = getNumberOfElements(inputShape);
for (int i = 0; i < numElements; i++, inputData++, outputData++) {
*outputData = static_cast<T>(
std::min(std::max(reluMin, static_cast<float>(*inputData)), reluMax));
}
return true;
}
template bool reluFloat<float>(const float* inputData, const Shape& inputShape, float* outputData,
const Shape& outputShape, float reluMin, float reluMax);
template bool reluFloat<_Float16>(const _Float16* inputData, const Shape& inputShape,
_Float16* outputData, const Shape& outputShape, float reluMin,
float reluMax);
template <typename T>
bool relu1Float(const T* inputData, const Shape& inputShape, T* outputData,
const Shape& outputShape) {
return reluFloat(inputData, inputShape, outputData, outputShape, -1.f, 1.f);
}
template bool relu1Float<float>(const float* inputData, const Shape& inputShape, float* outputData,
const Shape& outputShape);
template bool relu1Float<_Float16>(const _Float16* inputData, const Shape& inputShape,
_Float16* outputData, const Shape& outputShape);
template <typename T>
bool relu6Float(const T* inputData, const Shape& inputShape, T* outputData,
const Shape& outputShape) {
return reluFloat(inputData, inputShape, outputData, outputShape, 0.f, 6.f);
}
template bool relu6Float<float>(const float* inputData, const Shape& inputShape, float* outputData,
const Shape& outputShape);
template bool relu6Float<_Float16>(const _Float16* inputData, const Shape& inputShape,
_Float16* outputData, const Shape& outputShape);
bool tanhFloat16(const _Float16* inputData, const Shape& inputShape, _Float16* outputData,
const Shape& outputShape) {
NNTRACE_COMP("tanhFloat16");
int numElements = getNumberOfElements(inputShape);
for (int i = 0; i < numElements; i++, inputData++, outputData++) {
*outputData = static_cast<_Float16>(std::tanh(static_cast<float>(*inputData)));
}
return true;
}
bool tanhFloat32(const float* inputData, const Shape& inputShape, float* outputData,
const Shape& outputShape) {
NNTRACE_COMP("tanhFloat32");
int numElements = getNumberOfElements(inputShape);
for (int i = 0; i < numElements; i++, inputData++, outputData++) {
*outputData = std::tanh(*inputData);
}
return true;
}
template <typename T>
bool logisticFloat(const T* inputData, const Shape& inputShape, T* outputData,
const Shape& outputShape) {
NNTRACE_COMP("logisticFloat");
int numElements = getNumberOfElements(inputShape);
for (int i = 0; i < numElements; i++, inputData++, outputData++) {
*outputData = static_cast<T>(1.f / (1.f + std::exp(static_cast<float>(-*inputData))));
}
return true;
}
template bool logisticFloat<float>(const float* inputData, const Shape& inputShape,
float* outputData, const Shape& outputShape);
template bool logisticFloat<_Float16>(const _Float16* inputData, const Shape& inputShape,
_Float16* outputData, const Shape& outputShape);
#define ANDROID_NN_RELUX_QUANT8(activation) \
int numElements = getNumberOfElements(inputShape); \
int32_t output_activation_min = 0; \
int32_t output_activation_max = 0; \
\
CalculateActivationRangeUint8(activation, inputShape, &output_activation_min, \
&output_activation_max); \
\
for (int i = 0; i < numElements; i++, inputData++, outputData++) { \
*outputData = std::min((uint8_t)output_activation_max, \
std::max((uint8_t)output_activation_min, *inputData)); \
}
bool reluQuant8(const uint8_t* inputData, const Shape& inputShape, uint8_t* outputData,
const Shape& outputShape) {
NNTRACE_COMP("reluQuant8");
ANDROID_NN_RELUX_QUANT8(kActivationRelu)
return true;
}
bool relu1Quant8(const uint8_t* inputData, const Shape& inputShape, uint8_t* outputData,
const Shape& outputShape) {
NNTRACE_COMP("relu1Quant8");
ANDROID_NN_RELUX_QUANT8(kActivationRelu1)
return true;
}
bool relu6Quant8(const uint8_t* inputData, const Shape& inputShape, uint8_t* outputData,
const Shape& outputShape) {
NNTRACE_COMP("relu6Quant8");
ANDROID_NN_RELUX_QUANT8(kActivationRelu6)
return true;
}
#undef ANDROID_NN_RELUX_QUANT8
bool tanhQuant8(const uint8_t* inputData, const Shape& inputShape, uint8_t* outputData,
const Shape& outputShape) {
NNTRACE_TRANS("tanhQuant8");
if (outputShape.offset != 128 || outputShape.scale != 1.f / 128) {
LOG(ERROR) << "incorrect scale or offset for TANH output";
return false;
}
int numElements = getNumberOfElements(inputShape);
static constexpr int kInputIntegerBits = 4;
const double input_real_multiplier =
inputShape.scale * static_cast<double>(1 << (31 - kInputIntegerBits));
int32_t input_multiplier = 0;
int32_t input_left_shift = 0;
if (!QuantizeMultiplierGreaterThanOne(input_real_multiplier, &input_multiplier,
&input_left_shift)) {
return false;
}
int32_t input_range_radius = CalculateInputRadius(kInputIntegerBits, input_left_shift);
NNTRACE_COMP_SWITCH("optimized_ops::Tanh");
tflite::optimized_ops::Tanh(inputData, convertShapeToTflshape(inputShape), inputShape.offset,
input_range_radius, input_multiplier, input_left_shift, outputData,
convertShapeToTflshape(outputShape));
return true;
}
bool logisticQuant8(const uint8_t* inputData, const Shape& inputShape, uint8_t* outputData,
const Shape& outputShape) {
NNTRACE_TRANS("logisticQuant8");
if (outputShape.offset != 0 || outputShape.scale != 1.f / 256) {
LOG(ERROR) << "incorrect scale / offset for output";
return false;
}
int numElements = getNumberOfElements(inputShape);
static constexpr int kInputIntegerBits = 4;
const double input_real_multiplier =
inputShape.scale * static_cast<double>(1 << (31 - kInputIntegerBits));
int32_t input_multiplier = 0;
int32_t input_left_shift = 0;
if (!QuantizeMultiplierGreaterThanOne(input_real_multiplier, &input_multiplier,
&input_left_shift)) {
return false;
}
int32_t input_range_radius = CalculateInputRadius(kInputIntegerBits, input_left_shift);
NNTRACE_COMP_SWITCH("optimized_ops::Logistic");
tflite::optimized_ops::Logistic(
inputData, convertShapeToTflshape(inputShape), inputShape.offset, input_range_radius,
input_multiplier, input_left_shift, outputData, convertShapeToTflshape(outputShape));
return true;
}
} // namespace
bool validate(OperationType opType, const IOperationValidationContext* context) {
NN_RET_CHECK_EQ(context->getNumInputs(), kNumInputs);
NN_RET_CHECK_EQ(context->getNumOutputs(), kNumOutputs);
auto inputType = context->getInputType(kInputTensor);
if (inputType == OperandType::TENSOR_FLOAT32) {
NN_RET_CHECK(validateHalVersion(context, HalVersion::V1_0));
} else if (inputType == OperandType::TENSOR_FLOAT16) {
NN_RET_CHECK(validateHalVersion(context, HalVersion::V1_2));
} else if (inputType == OperandType::TENSOR_QUANT8_ASYMM) {
if (opType == OperationType::TANH) {
NN_RET_CHECK(validateHalVersion(context, HalVersion::V1_2));
} else {
NN_RET_CHECK(validateHalVersion(context, HalVersion::V1_0));
}
} else {
NN_RET_CHECK_FAIL() << "Unsupported tensor type for operation " << getOperationName(opType);
}
return validateInputTypes(context, {inputType}) && validateOutputTypes(context, {inputType});
}
bool prepare(OperationType opType, IOperationExecutionContext* context) {
Shape input = context->getInputShape(kInputTensor);
NN_RET_CHECK_LE(getNumberOfDimensions(input), 4);
Shape output = input;
if (input.type == OperandType::TENSOR_QUANT8_ASYMM) {
switch (opType) {
case OperationType::RELU:
case OperationType::RELU1:
case OperationType::RELU6:
break;
case OperationType::LOGISTIC:
output.scale = 1.f / 256;
output.offset = 0;
break;
case OperationType::TANH:
output.scale = 1.f / 128;
output.offset = 128;
break;
default:
NN_RET_CHECK_FAIL() << "Unsupported operation type";
}
}
return context->setOutputShape(kOutputTensor, output);
}
bool executeRelu(IOperationExecutionContext* context) {
// Bypass execution in the case of zero-sized input.
if (getNumberOfElements(context->getOutputShape(kOutputTensor)) == 0) return true;
switch (context->getInputType(kInputTensor)) {
case OperandType::TENSOR_FLOAT16:
return reluFloat(context->getInputBuffer<_Float16>(kInputTensor),
context->getInputShape(kInputTensor),
context->getOutputBuffer<_Float16>(kOutputTensor),
context->getOutputShape(kOutputTensor));
case OperandType::TENSOR_FLOAT32:
return reluFloat(context->getInputBuffer<float>(kInputTensor),
context->getInputShape(kInputTensor),
context->getOutputBuffer<float>(kOutputTensor),
context->getOutputShape(kOutputTensor));
case OperandType::TENSOR_QUANT8_ASYMM:
return reluQuant8(context->getInputBuffer<uint8_t>(kInputTensor),
context->getInputShape(kInputTensor),
context->getOutputBuffer<uint8_t>(kOutputTensor),
context->getOutputShape(kOutputTensor));
default:
NN_RET_CHECK_FAIL() << "Unsupported tensor type for operation RELU";
}
}
bool executeRelu1(IOperationExecutionContext* context) {
// Bypass execution in the case of zero-sized input.
if (getNumberOfElements(context->getOutputShape(kOutputTensor)) == 0) return true;
switch (context->getInputType(kInputTensor)) {
case OperandType::TENSOR_FLOAT16:
return relu1Float(context->getInputBuffer<_Float16>(kInputTensor),
context->getInputShape(kInputTensor),
context->getOutputBuffer<_Float16>(kOutputTensor),
context->getOutputShape(kOutputTensor));
case OperandType::TENSOR_FLOAT32:
return relu1Float(context->getInputBuffer<float>(kInputTensor),
context->getInputShape(kInputTensor),
context->getOutputBuffer<float>(kOutputTensor),
context->getOutputShape(kOutputTensor));
case OperandType::TENSOR_QUANT8_ASYMM:
return relu1Quant8(context->getInputBuffer<uint8_t>(kInputTensor),
context->getInputShape(kInputTensor),
context->getOutputBuffer<uint8_t>(kOutputTensor),
context->getOutputShape(kOutputTensor));
default:
NN_RET_CHECK_FAIL() << "Unsupported tensor type for operation RELU1";
}
}
bool executeRelu6(IOperationExecutionContext* context) {
// Bypass execution in the case of zero-sized input.
if (getNumberOfElements(context->getOutputShape(kOutputTensor)) == 0) return true;
switch (context->getInputType(kInputTensor)) {
case OperandType::TENSOR_FLOAT16:
return relu6Float(context->getInputBuffer<_Float16>(kInputTensor),
context->getInputShape(kInputTensor),
context->getOutputBuffer<_Float16>(kOutputTensor),
context->getOutputShape(kOutputTensor));
case OperandType::TENSOR_FLOAT32:
return relu6Float(context->getInputBuffer<float>(kInputTensor),
context->getInputShape(kInputTensor),
context->getOutputBuffer<float>(kOutputTensor),
context->getOutputShape(kOutputTensor));
case OperandType::TENSOR_QUANT8_ASYMM:
return relu6Quant8(context->getInputBuffer<uint8_t>(kInputTensor),
context->getInputShape(kInputTensor),
context->getOutputBuffer<uint8_t>(kOutputTensor),
context->getOutputShape(kOutputTensor));
default:
NN_RET_CHECK_FAIL() << "Unsupported tensor type for operation RELU6";
}
}
bool executeLogistic(IOperationExecutionContext* context) {
// Bypass execution in the case of zero-sized input.
if (getNumberOfElements(context->getOutputShape(kOutputTensor)) == 0) return true;
switch (context->getInputType(kInputTensor)) {
case OperandType::TENSOR_FLOAT16:
return logisticFloat(context->getInputBuffer<_Float16>(kInputTensor),
context->getInputShape(kInputTensor),
context->getOutputBuffer<_Float16>(kOutputTensor),
context->getOutputShape(kOutputTensor));
case OperandType::TENSOR_FLOAT32:
return logisticFloat(context->getInputBuffer<float>(kInputTensor),
context->getInputShape(kInputTensor),
context->getOutputBuffer<float>(kOutputTensor),
context->getOutputShape(kOutputTensor));
case OperandType::TENSOR_QUANT8_ASYMM:
return logisticQuant8(context->getInputBuffer<uint8_t>(kInputTensor),
context->getInputShape(kInputTensor),
context->getOutputBuffer<uint8_t>(kOutputTensor),
context->getOutputShape(kOutputTensor));
default:
NN_RET_CHECK_FAIL() << "Unsupported tensor type for operation LOGISTIC";
}
}
bool executeTanh(IOperationExecutionContext* context) {
// Bypass execution in the case of zero-sized input.
if (getNumberOfElements(context->getOutputShape(kOutputTensor)) == 0) return true;
switch (context->getInputType(kInputTensor)) {
case OperandType::TENSOR_FLOAT16:
return tanhFloat16(context->getInputBuffer<_Float16>(kInputTensor),
context->getInputShape(kInputTensor),
context->getOutputBuffer<_Float16>(kOutputTensor),
context->getOutputShape(kOutputTensor));
case OperandType::TENSOR_FLOAT32:
return tanhFloat32(context->getInputBuffer<float>(kInputTensor),
context->getInputShape(kInputTensor),
context->getOutputBuffer<float>(kOutputTensor),
context->getOutputShape(kOutputTensor));
case OperandType::TENSOR_QUANT8_ASYMM:
return tanhQuant8(context->getInputBuffer<uint8_t>(kInputTensor),
context->getInputShape(kInputTensor),
context->getOutputBuffer<uint8_t>(kOutputTensor),
context->getOutputShape(kOutputTensor));
default:
NN_RET_CHECK_FAIL() << "Unsupported tensor type for operation TANH";
}
}
} // namespace activation
using std::placeholders::_1;
NN_REGISTER_OPERATION(RELU, "RELU", std::bind(activation::validate, OperationType::RELU, _1),
std::bind(activation::prepare, OperationType::RELU, _1),
activation::executeRelu, .allowZeroSizedInput = true);
NN_REGISTER_OPERATION(RELU1, "RELU1", std::bind(activation::validate, OperationType::RELU1, _1),
std::bind(activation::prepare, OperationType::RELU1, _1),
activation::executeRelu1, .allowZeroSizedInput = true);
NN_REGISTER_OPERATION(RELU6, "RELU6", std::bind(activation::validate, OperationType::RELU6, _1),
std::bind(activation::prepare, OperationType::RELU6, _1),
activation::executeRelu6, .allowZeroSizedInput = true);
NN_REGISTER_OPERATION(LOGISTIC, "LOGISTIC",
std::bind(activation::validate, OperationType::LOGISTIC, _1),
std::bind(activation::prepare, OperationType::LOGISTIC, _1),
activation::executeLogistic, .allowZeroSizedInput = true);
NN_REGISTER_OPERATION(TANH, "TANH", std::bind(activation::validate, OperationType::TANH, _1),
std::bind(activation::prepare, OperationType::TANH, _1),
activation::executeTanh, .allowZeroSizedInput = true);
} // namespace nn
} // namespace android