common/operations/ElementwiseValidation.cpp - platform/packages/modules/NeuralNetworks - Git at Google

 /*
  * Copyright (C) 2018 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.
  */

 #define LOG_TAG "Operations"

 #include <cmath>
 #include <functional>
 #include <limits>

 #include "OperationResolver.h"
 #include "OperationsUtils.h"
 #include "Tracing.h"

 namespace android {
 namespace nn {
 namespace elementwise {

 constexpr uint32_t kNumInputs = 1;
 constexpr uint32_t kInputTensor = 0;

 constexpr uint32_t kNumOutputs = 1;
 constexpr uint32_t kOutputTensor = 0;

 namespace {

 template <typename IntermediateType, typename T>
 inline bool compute(const std::function<IntermediateType(IntermediateType)>& func, const T* input,
                     const Shape& shape, T* output) {
     const auto size = getNumberOfElements(shape);
     for (uint32_t i = 0; i < size; ++i) {
         output[i] = static_cast<T>(func(static_cast<IntermediateType>(input[i])));
     }
     return true;
 }

 template <typename IntermediateType, typename T>
 inline bool compute(IntermediateType func(IntermediateType), const T* input, const Shape& shape,
                     T* output) {
     return compute(std::function<IntermediateType(IntermediateType)>(func), input, shape, output);
 }

 template <typename IntermediateType, typename T>
 auto makeQuantized(const std::function<IntermediateType(IntermediateType)>& func, float inScale,
                    T inZeroPoint, float outScale, T outZeroPoint) {
     return [func, inScale, inZeroPoint, outScale, outZeroPoint](T val) -> T {
         // For dequantization formula, see Dequantize.cpp.
         using WideT = int32_t;
         static_assert(sizeof(T) < sizeof(WideT));
         IntermediateType dequantizedVal =
                 (static_cast<WideT>(val) - static_cast<WideT>(inZeroPoint)) * inScale;

         IntermediateType res = func(dequantizedVal);

         // For quantization formula, see Quantize.cpp.
         T quantizedRes = static_cast<T>(std::max<float>(
                 static_cast<IntermediateType>(std::numeric_limits<T>::min()),
                 std::min<float>(static_cast<IntermediateType>(std::numeric_limits<T>::max()),
                                 outZeroPoint + std::round(res / outScale))));

         return quantizedRes;
     };
 }

 bool execute(IOperationExecutionContext* context, float func(float)) {
     switch (context->getInputType(kInputTensor)) {
         case OperandType::TENSOR_FLOAT16:
             return compute<float, _Float16>(func, context->getInputBuffer<_Float16>(kInputTensor),
                                             context->getInputShape(kInputTensor),
                                             context->getOutputBuffer<_Float16>(kOutputTensor));
         case OperandType::TENSOR_FLOAT32:
             return compute<float, float>(func, context->getInputBuffer<float>(kInputTensor),
                                          context->getInputShape(kInputTensor),
                                          context->getOutputBuffer<float>(kOutputTensor));
         default:
             NN_RET_CHECK_FAIL() << "Unsupported tensor type for elementwise operation";
     }
 }

 }  // namespace

 bool executeAbs(IOperationExecutionContext* context) {
     switch (context->getInputType(kInputTensor)) {
         case OperandType::TENSOR_FLOAT16:
             return compute<float, _Float16>(std::abs,
                                             context->getInputBuffer<_Float16>(kInputTensor),
                                             context->getInputShape(kInputTensor),
                                             context->getOutputBuffer<_Float16>(kOutputTensor));
         case OperandType::TENSOR_FLOAT32:
             return compute<float, float>(std::abs, context->getInputBuffer<float>(kInputTensor),
                                          context->getInputShape(kInputTensor),
                                          context->getOutputBuffer<float>(kOutputTensor));
         case OperandType::TENSOR_INT32:
             return compute<int32_t, int32_t>(std::abs,
                                              context->getInputBuffer<int32_t>(kInputTensor),
                                              context->getInputShape(kInputTensor),
                                              context->getOutputBuffer<int32_t>(kOutputTensor));
         default:
             NN_RET_CHECK_FAIL() << "Unsupported tensor type for operation ABS";
     }
 }

 bool executeRsqrt(IOperationExecutionContext* context) {
     const std::function<float(float)> frsqrt = [](float x) { return 1.f / std::sqrt(x); };
     const auto tensorType = context->getInputType(kInputTensor);
     switch (tensorType) {
         case OperandType::TENSOR_FLOAT16:
             return compute<float, _Float16>(frsqrt, context->getInputBuffer<_Float16>(kInputTensor),
                                             context->getInputShape(kInputTensor),
                                             context->getOutputBuffer<_Float16>(kOutputTensor));
         case OperandType::TENSOR_FLOAT32:
             return compute<float, float>(frsqrt, context->getInputBuffer<float>(kInputTensor),
                                          context->getInputShape(kInputTensor),
                                          context->getOutputBuffer<float>(kOutputTensor));
         case OperandType::TENSOR_QUANT8_ASYMM: {
             const Shape inShape = context->getInputShape(kInputTensor);
             const Shape outShape = context->getOutputShape(kOutputTensor);
             return compute<uint8_t, uint8_t>(
                     makeQuantized(frsqrt, inShape.scale, static_cast<uint8_t>(inShape.offset),
                                   outShape.scale, static_cast<uint8_t>(outShape.offset)),
                     context->getInputBuffer<uint8_t>(kInputTensor),
                     context->getInputShape(kInputTensor),
                     context->getOutputBuffer<uint8_t>(kOutputTensor));
         }
         case OperandType::TENSOR_QUANT8_ASYMM_SIGNED: {
             const Shape inShape = context->getInputShape(kInputTensor);
             const Shape outShape = context->getOutputShape(kOutputTensor);
             return compute<int8_t, int8_t>(
                     makeQuantized(frsqrt, inShape.scale, static_cast<int8_t>(inShape.offset),
                                   outShape.scale, static_cast<int8_t>(outShape.offset)),
                     context->getInputBuffer<int8_t>(kInputTensor),
                     context->getInputShape(kInputTensor),
                     context->getOutputBuffer<int8_t>(kOutputTensor));
         }
         default:
             NN_RET_CHECK_FAIL() << "Unsupported tensor type " << tensorType
                                 << " for operation RSQRT";
     }
 }

 Result<Version> validate(const IOperationValidationContext* context) {
     NN_RET_CHECK_EQ(context->getNumInputs(), kNumInputs);
     NN_RET_CHECK_EQ(context->getNumOutputs(), kNumOutputs);
     OperandType inputType = context->getInputType(kInputTensor);
     NN_RET_CHECK(inputType == OperandType::TENSOR_FLOAT16 ||
                  inputType == OperandType::TENSOR_FLOAT32)
             << "Unsupported tensor type for elementwise operation";
     NN_RET_CHECK(validateInputTypes(context, {inputType}));
     NN_RET_CHECK(validateOutputTypes(context, {inputType}));
     return kVersionFeatureLevel3;
 }

 Result<Version> validateAbs(const IOperationValidationContext* context) {
     NN_RET_CHECK_EQ(context->getNumInputs(), kNumInputs);
     NN_RET_CHECK_EQ(context->getNumOutputs(), kNumOutputs);
     OperandType inputType = context->getInputType(kInputTensor);
     NN_RET_CHECK(inputType == OperandType::TENSOR_FLOAT16 ||
                  inputType == OperandType::TENSOR_FLOAT32 || inputType == OperandType::TENSOR_INT32)
             << "Unsupported tensor type for operation ABS";
     NN_RET_CHECK(validateInputTypes(context, {inputType}));
     NN_RET_CHECK(validateOutputTypes(context, {inputType}));
     return inputType == OperandType::TENSOR_INT32 ? kVersionFeatureLevel4 : kVersionFeatureLevel3;
 }

 Result<Version> validateFloor(const IOperationValidationContext* context) {
     NN_RET_CHECK_EQ(context->getNumInputs(), kNumInputs);
     NN_RET_CHECK_EQ(context->getNumOutputs(), kNumOutputs);

     OperandType inputType = context->getInputType(kInputTensor);
     NN_RET_CHECK(inputType == OperandType::TENSOR_FLOAT16 ||
                  inputType == OperandType::TENSOR_FLOAT32)
             << "Unsupported tensor type for operation FLOOR";
     NN_RET_CHECK(validateInputTypes(context, {inputType}));
     NN_RET_CHECK(validateOutputTypes(context, {inputType}));

     const Shape& input = context->getInputShape(kInputTensor);
     if (hasKnownRank(input)) {
         NN_RET_CHECK_LE(getNumberOfDimensions(input), 4u);
     }

     return inputType == OperandType::TENSOR_FLOAT16 ? kVersionFeatureLevel3 : kVersionFeatureLevel1;
 }

 Result<Version> validateRsqrt(const IOperationValidationContext* context) {
     NN_RET_CHECK_EQ(context->getNumInputs(), kNumInputs);
     NN_RET_CHECK_EQ(context->getNumOutputs(), kNumOutputs);
     OperandType inputType = context->getInputType(kInputTensor);
     NN_RET_CHECK(inputType == OperandType::TENSOR_FLOAT16 ||
                  inputType == OperandType::TENSOR_FLOAT32 ||
                  inputType == OperandType::TENSOR_QUANT8_ASYMM ||
                  inputType == OperandType::TENSOR_QUANT8_ASYMM_SIGNED)
             << "Unsupported tensor type for operation RSQRT";
     NN_RET_CHECK(validateInputTypes(context, {inputType}));
     NN_RET_CHECK(validateOutputTypes(context, {inputType}));
     return (inputType == OperandType::TENSOR_QUANT8_ASYMM ||
             inputType == OperandType::TENSOR_QUANT8_ASYMM_SIGNED)
                    ? kVersionFeatureLevel7
                    : kVersionFeatureLevel3;
 }

 bool prepare(IOperationExecutionContext* context) {
     Shape input = context->getInputShape(kInputTensor);
     Shape output = context->getOutputShape(kOutputTensor);
     NN_RET_CHECK(SetShape(input, &output));
     return context->setOutputShape(kOutputTensor, output);
 }

 bool prepareFloor(IOperationExecutionContext* context) {
     Shape input = context->getInputShape(kInputTensor);
     Shape output = context->getOutputShape(kOutputTensor);
     NN_RET_CHECK_LE(getNumberOfDimensions(input), 4u);
     NN_RET_CHECK(SetShape(input, &output));
     return context->setOutputShape(kOutputTensor, output);
 }

 bool executeExp(IOperationExecutionContext* context) {
     return execute(context, std::exp);
 }

 bool executeFloor(IOperationExecutionContext* context) {
     return execute(context, std::floor);
 }

 bool executeLog(IOperationExecutionContext* context) {
     return execute(context, std::log);
 }

 bool executeSin(IOperationExecutionContext* context) {
     return execute(context, std::sin);
 }

 bool executeSqrt(IOperationExecutionContext* context) {
     return execute(context, std::sqrt);
 }

 }  // namespace elementwise

 NN_REGISTER_OPERATION(ABS, "ABS", elementwise::validateAbs, elementwise::prepare,
                       elementwise::executeAbs);
 NN_REGISTER_OPERATION(EXP, "EXP", elementwise::validate, elementwise::prepare,
                       elementwise::executeExp);
 NN_REGISTER_OPERATION(FLOOR, "FLOOR", elementwise::validateFloor, elementwise::prepareFloor,
                       elementwise::executeFloor);
 NN_REGISTER_OPERATION(LOG, "LOG", elementwise::validate, elementwise::prepare,
                       elementwise::executeLog);
 NN_REGISTER_OPERATION(RSQRT, "RSQRT", elementwise::validateRsqrt, elementwise::prepare,
                       elementwise::executeRsqrt);
 NN_REGISTER_OPERATION(SIN, "SIN", elementwise::validate, elementwise::prepare,
                       elementwise::executeSin);
 NN_REGISTER_OPERATION(SQRT, "SQRT", elementwise::validate, elementwise::prepare,
                       elementwise::executeSqrt);

 }  // namespace nn
 }  // namespace android
	/*
	* Copyright (C) 2018 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.
	*/

	#define LOG_TAG "Operations"

	#include <cmath>
	#include <functional>
	#include <limits>

	#include "OperationResolver.h"
	#include "OperationsUtils.h"
	#include "Tracing.h"

	namespace android {
	namespace nn {
	namespace elementwise {

	constexpr uint32_t kNumInputs = 1;
	constexpr uint32_t kInputTensor = 0;

	constexpr uint32_t kNumOutputs = 1;
	constexpr uint32_t kOutputTensor = 0;

	namespace {

	template <typename IntermediateType, typename T>
	inline bool compute(const std::function<IntermediateType(IntermediateType)>& func, const T* input,
	const Shape& shape, T* output) {
	const auto size = getNumberOfElements(shape);
	for (uint32_t i = 0; i < size; ++i) {
	output[i] = static_cast<T>(func(static_cast<IntermediateType>(input[i])));
	}
	return true;
	}

	template <typename IntermediateType, typename T>
	inline bool compute(IntermediateType func(IntermediateType), const T* input, const Shape& shape,
	T* output) {
	return compute(std::function<IntermediateType(IntermediateType)>(func), input, shape, output);
	}

	template <typename IntermediateType, typename T>
	auto makeQuantized(const std::function<IntermediateType(IntermediateType)>& func, float inScale,
	T inZeroPoint, float outScale, T outZeroPoint) {
	return [func, inScale, inZeroPoint, outScale, outZeroPoint](T val) -> T {
	// For dequantization formula, see Dequantize.cpp.
	using WideT = int32_t;
	static_assert(sizeof(T) < sizeof(WideT));
	IntermediateType dequantizedVal =
	(static_cast<WideT>(val) - static_cast<WideT>(inZeroPoint)) * inScale;

	IntermediateType res = func(dequantizedVal);

	// For quantization formula, see Quantize.cpp.
	T quantizedRes = static_cast<T>(std::max<float>(
	static_cast<IntermediateType>(std::numeric_limits<T>::min()),
	std::min<float>(static_cast<IntermediateType>(std::numeric_limits<T>::max()),
	outZeroPoint + std::round(res / outScale))));

	return quantizedRes;
	};
	}

	bool execute(IOperationExecutionContext* context, float func(float)) {
	switch (context->getInputType(kInputTensor)) {
	case OperandType::TENSOR_FLOAT16:
	return compute<float, _Float16>(func, context->getInputBuffer<_Float16>(kInputTensor),
	context->getInputShape(kInputTensor),
	context->getOutputBuffer<_Float16>(kOutputTensor));
	case OperandType::TENSOR_FLOAT32:
	return compute<float, float>(func, context->getInputBuffer<float>(kInputTensor),
	context->getInputShape(kInputTensor),
	context->getOutputBuffer<float>(kOutputTensor));
	default:
	NN_RET_CHECK_FAIL() << "Unsupported tensor type for elementwise operation";
	}
	}

	} // namespace

	bool executeAbs(IOperationExecutionContext* context) {
	switch (context->getInputType(kInputTensor)) {
	case OperandType::TENSOR_FLOAT16:
	return compute<float, _Float16>(std::abs,
	context->getInputBuffer<_Float16>(kInputTensor),
	context->getInputShape(kInputTensor),
	context->getOutputBuffer<_Float16>(kOutputTensor));
	case OperandType::TENSOR_FLOAT32:
	return compute<float, float>(std::abs, context->getInputBuffer<float>(kInputTensor),
	context->getInputShape(kInputTensor),
	context->getOutputBuffer<float>(kOutputTensor));
	case OperandType::TENSOR_INT32:
	return compute<int32_t, int32_t>(std::abs,
	context->getInputBuffer<int32_t>(kInputTensor),
	context->getInputShape(kInputTensor),
	context->getOutputBuffer<int32_t>(kOutputTensor));
	default:
	NN_RET_CHECK_FAIL() << "Unsupported tensor type for operation ABS";
	}
	}

	bool executeRsqrt(IOperationExecutionContext* context) {
	const std::function<float(float)> frsqrt = [](float x) { return 1.f / std::sqrt(x); };
	const auto tensorType = context->getInputType(kInputTensor);
	switch (tensorType) {
	case OperandType::TENSOR_FLOAT16:
	return compute<float, _Float16>(frsqrt, context->getInputBuffer<_Float16>(kInputTensor),
	context->getInputShape(kInputTensor),
	context->getOutputBuffer<_Float16>(kOutputTensor));
	case OperandType::TENSOR_FLOAT32:
	return compute<float, float>(frsqrt, context->getInputBuffer<float>(kInputTensor),
	context->getInputShape(kInputTensor),
	context->getOutputBuffer<float>(kOutputTensor));
	case OperandType::TENSOR_QUANT8_ASYMM: {
	const Shape inShape = context->getInputShape(kInputTensor);
	const Shape outShape = context->getOutputShape(kOutputTensor);
	return compute<uint8_t, uint8_t>(
	makeQuantized(frsqrt, inShape.scale, static_cast<uint8_t>(inShape.offset),
	outShape.scale, static_cast<uint8_t>(outShape.offset)),
	context->getInputBuffer<uint8_t>(kInputTensor),
	context->getInputShape(kInputTensor),
	context->getOutputBuffer<uint8_t>(kOutputTensor));
	}
	case OperandType::TENSOR_QUANT8_ASYMM_SIGNED: {
	const Shape inShape = context->getInputShape(kInputTensor);
	const Shape outShape = context->getOutputShape(kOutputTensor);
	return compute<int8_t, int8_t>(
	makeQuantized(frsqrt, inShape.scale, static_cast<int8_t>(inShape.offset),
	outShape.scale, static_cast<int8_t>(outShape.offset)),
	context->getInputBuffer<int8_t>(kInputTensor),
	context->getInputShape(kInputTensor),
	context->getOutputBuffer<int8_t>(kOutputTensor));
	}
	default:
	NN_RET_CHECK_FAIL() << "Unsupported tensor type " << tensorType
	<< " for operation RSQRT";
	}
	}

	Result<Version> validate(const IOperationValidationContext* context) {
	NN_RET_CHECK_EQ(context->getNumInputs(), kNumInputs);
	NN_RET_CHECK_EQ(context->getNumOutputs(), kNumOutputs);
	OperandType inputType = context->getInputType(kInputTensor);
	NN_RET_CHECK(inputType == OperandType::TENSOR_FLOAT16 \|\|
	inputType == OperandType::TENSOR_FLOAT32)
	<< "Unsupported tensor type for elementwise operation";
	NN_RET_CHECK(validateInputTypes(context, {inputType}));
	NN_RET_CHECK(validateOutputTypes(context, {inputType}));
	return kVersionFeatureLevel3;
	}

	Result<Version> validateAbs(const IOperationValidationContext* context) {
	NN_RET_CHECK_EQ(context->getNumInputs(), kNumInputs);
	NN_RET_CHECK_EQ(context->getNumOutputs(), kNumOutputs);
	OperandType inputType = context->getInputType(kInputTensor);
	NN_RET_CHECK(inputType == OperandType::TENSOR_FLOAT16 \|\|
	inputType == OperandType::TENSOR_FLOAT32 \|\| inputType == OperandType::TENSOR_INT32)
	<< "Unsupported tensor type for operation ABS";
	NN_RET_CHECK(validateInputTypes(context, {inputType}));
	NN_RET_CHECK(validateOutputTypes(context, {inputType}));
	return inputType == OperandType::TENSOR_INT32 ? kVersionFeatureLevel4 : kVersionFeatureLevel3;
	}

	Result<Version> validateFloor(const IOperationValidationContext* context) {
	NN_RET_CHECK_EQ(context->getNumInputs(), kNumInputs);
	NN_RET_CHECK_EQ(context->getNumOutputs(), kNumOutputs);

	OperandType inputType = context->getInputType(kInputTensor);
	NN_RET_CHECK(inputType == OperandType::TENSOR_FLOAT16 \|\|
	inputType == OperandType::TENSOR_FLOAT32)
	<< "Unsupported tensor type for operation FLOOR";
	NN_RET_CHECK(validateInputTypes(context, {inputType}));
	NN_RET_CHECK(validateOutputTypes(context, {inputType}));

	const Shape& input = context->getInputShape(kInputTensor);
	if (hasKnownRank(input)) {
	NN_RET_CHECK_LE(getNumberOfDimensions(input), 4u);
	}

	return inputType == OperandType::TENSOR_FLOAT16 ? kVersionFeatureLevel3 : kVersionFeatureLevel1;
	}

	Result<Version> validateRsqrt(const IOperationValidationContext* context) {
	NN_RET_CHECK_EQ(context->getNumInputs(), kNumInputs);
	NN_RET_CHECK_EQ(context->getNumOutputs(), kNumOutputs);
	OperandType inputType = context->getInputType(kInputTensor);
	NN_RET_CHECK(inputType == OperandType::TENSOR_FLOAT16 \|\|
	inputType == OperandType::TENSOR_FLOAT32 \|\|
	inputType == OperandType::TENSOR_QUANT8_ASYMM \|\|
	inputType == OperandType::TENSOR_QUANT8_ASYMM_SIGNED)
	<< "Unsupported tensor type for operation RSQRT";
	NN_RET_CHECK(validateInputTypes(context, {inputType}));
	NN_RET_CHECK(validateOutputTypes(context, {inputType}));
	return (inputType == OperandType::TENSOR_QUANT8_ASYMM \|\|
	inputType == OperandType::TENSOR_QUANT8_ASYMM_SIGNED)
	? kVersionFeatureLevel7
	: kVersionFeatureLevel3;
	}

	bool prepare(IOperationExecutionContext* context) {
	Shape input = context->getInputShape(kInputTensor);
	Shape output = context->getOutputShape(kOutputTensor);
	NN_RET_CHECK(SetShape(input, &output));
	return context->setOutputShape(kOutputTensor, output);
	}

	bool prepareFloor(IOperationExecutionContext* context) {
	Shape input = context->getInputShape(kInputTensor);
	Shape output = context->getOutputShape(kOutputTensor);
	NN_RET_CHECK_LE(getNumberOfDimensions(input), 4u);
	NN_RET_CHECK(SetShape(input, &output));
	return context->setOutputShape(kOutputTensor, output);
	}

	bool executeExp(IOperationExecutionContext* context) {
	return execute(context, std::exp);
	}

	bool executeFloor(IOperationExecutionContext* context) {
	return execute(context, std::floor);
	}

	bool executeLog(IOperationExecutionContext* context) {
	return execute(context, std::log);
	}

	bool executeSin(IOperationExecutionContext* context) {
	return execute(context, std::sin);
	}

	bool executeSqrt(IOperationExecutionContext* context) {
	return execute(context, std::sqrt);
	}

	} // namespace elementwise

	NN_REGISTER_OPERATION(ABS, "ABS", elementwise::validateAbs, elementwise::prepare,
	elementwise::executeAbs);
	NN_REGISTER_OPERATION(EXP, "EXP", elementwise::validate, elementwise::prepare,
	elementwise::executeExp);
	NN_REGISTER_OPERATION(FLOOR, "FLOOR", elementwise::validateFloor, elementwise::prepareFloor,
	elementwise::executeFloor);
	NN_REGISTER_OPERATION(LOG, "LOG", elementwise::validate, elementwise::prepare,
	elementwise::executeLog);
	NN_REGISTER_OPERATION(RSQRT, "RSQRT", elementwise::validateRsqrt, elementwise::prepare,
	elementwise::executeRsqrt);
	NN_REGISTER_OPERATION(SIN, "SIN", elementwise::validate, elementwise::prepare,
	elementwise::executeSin);
	NN_REGISTER_OPERATION(SQRT, "SQRT", elementwise::validate, elementwise::prepare,
	elementwise::executeSqrt);

	} // namespace nn
	} // namespace android