1 /*
2  * Copyright (C) 2017 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #define LOG_TAG "Operations"
18 
19 #include <algorithm>
20 #include <iterator>
21 #include <vector>
22 
23 #include "OperationResolver.h"
24 #include "OperationsUtils.h"
25 #include "Tracing.h"
26 #include "nnapi/Validation.h"
27 
28 #ifdef NN_INCLUDE_CPU_IMPLEMENTATION
29 #include <tensorflow/lite/kernels/internal/optimized/legacy_optimized_ops.h>
30 #include <tensorflow/lite/kernels/internal/reference/legacy_reference_ops.h>
31 #include <tensorflow/lite/kernels/internal/reference/reference_ops.h>
32 #include <tensorflow/lite/kernels/internal/types.h>
33 
34 #include "CpuOperationUtils.h"
35 #endif  // NN_INCLUDE_CPU_IMPLEMENTATION
36 
37 namespace android {
38 namespace nn {
39 namespace concatenation {
40 
41 constexpr char kOperationName[] = "CONCATENATION";
42 
43 constexpr uint32_t kNumOutputs = 1;
44 constexpr uint32_t kOutputTensor = 0;
45 
46 #ifdef NN_INCLUDE_CPU_IMPLEMENTATION
47 namespace {
48 
49 template <typename T>
concatenation(const std::vector<const T * > & inputDataPtrs,const std::vector<Shape> & inputShapes,int32_t axis,T * outputData,const Shape & outputShape)50 bool concatenation(const std::vector<const T*>& inputDataPtrs,
51                    const std::vector<Shape>& inputShapes, int32_t axis, T* outputData,
52                    const Shape& outputShape) {
53     NNTRACE_TRANS("concatenation");
54     int num_inputs = inputShapes.size();
55     std::vector<tflite::Dims<4>*> inputDimsPtr(num_inputs);
56     std::vector<tflite::Dims<4>> inputDims(num_inputs);
57     for (int i = 0; i < num_inputs; i++) {
58         inputDims[i] = convertShapeToDims(inputShapes[i]);
59         inputDimsPtr[i] = &inputDims[i];
60     }
61     NNTRACE_COMP_SWITCH("optimized_ops::Concatenation");
62     tflite::optimized_ops::Concatenation<tflite::FusedActivationFunctionType::kNone, T>(
63             getNumberOfDimensions(outputShape) - axis - 1, inputDataPtrs.data(),
64             inputDimsPtr.data(), num_inputs, outputData, convertShapeToDims(outputShape));
65 
66     return true;
67 }
68 
69 template <>
70 bool concatenation<uint8_t>(const std::vector<const uint8_t*>& inputDataPtrs,
71                             const std::vector<Shape>& inputShapes, int32_t axis,
72                             uint8_t* outputData, const Shape& outputShape) {
73     NNTRACE_TRANS("concatenationQuant8");
74     int num_inputs = inputShapes.size();
75     std::vector<float> inputScales(num_inputs);
76     std::vector<int32> inputOffsets(num_inputs);
77     std::vector<tflite::Dims<4>*> inputDimsPtr(num_inputs);
78     std::vector<tflite::Dims<4>> inputDims(num_inputs);
79     for (int i = 0; i < num_inputs; i++) {
80         inputScales[i] = inputShapes[i].scale;
81         inputOffsets[i] = inputShapes[i].offset;
82         inputDims[i] = convertShapeToDims(inputShapes[i]);
83         inputDimsPtr[i] = &inputDims[i];
84     }
85 
86     NNTRACE_COMP_SWITCH("reference_ops::Concatenation");
87     tflite::reference_ops::Concatenation(
88             getNumberOfDimensions(outputShape) - axis - 1, inputDataPtrs.data(),
89             inputDimsPtr.data(), inputOffsets.data(), inputScales.data(), num_inputs, outputData,
90             convertShapeToDims(outputShape), outputShape.offset, outputShape.scale);
91 
92     return true;
93 }
94 
95 template <typename T>
concatenation(IOperationExecutionContext * context)96 inline bool concatenation(IOperationExecutionContext* context) {
97     uint32_t inputCount = context->getNumInputs() - 1;
98     std::vector<const T*> inputDatas;
99     std::vector<Shape> inputShapes;
100     for (uint32_t i = 0; i < inputCount; ++i) {
101         const T* buffer = context->getInputBuffer<T>(i);
102         if (buffer == nullptr) continue;
103         inputDatas.push_back(buffer);
104         inputShapes.push_back(context->getInputShape(i));
105     }
106     return concatenation(inputDatas, inputShapes, context->getInputValue<int32_t>(inputCount),
107                          context->getOutputBuffer<T>(kOutputTensor),
108                          context->getOutputShape(kOutputTensor));
109 }
110 
111 template <>
112 inline bool concatenation<int8_t>(IOperationExecutionContext* context) {
113     uint32_t inputCount = context->getNumInputs() - 1;
114     std::vector<std::vector<uint8_t>> inputs_uint8(inputCount);
115     for (int i = 0; i < inputCount; ++i) {
116         const auto currentSize = getNumberOfElements(context->getInputShape(i));
117         inputs_uint8[i].resize(currentSize);
118         if (currentSize != 0) {
119             convertInt8ToUInt8(context->getInputBuffer<int8_t>(i), &inputs_uint8[i]);
120         }
121     }
122     std::vector<const uint8_t*> inputDatas;
123     std::vector<Shape> inputShapes;
124     for (uint32_t i = 0; i < inputCount; ++i) {
125         inputDatas.push_back(inputs_uint8[i].data());
126         inputShapes.push_back(context->getInputShape(i));
127         inputShapes[i].offset += 128;
128     }
129 
130     std::vector<uint8_t> output_uint8(getNumberOfElements(context->getOutputShape(kOutputTensor)));
131     Shape outputShape(context->getOutputShape(kOutputTensor));
132     outputShape.offset += 128;
133     NN_RET_CHECK(concatenation(inputDatas, inputShapes, context->getInputValue<int32_t>(inputCount),
134                                output_uint8.data(), outputShape));
135 
136     convertUInt8ToInt8(output_uint8, context->getOutputBuffer<int8_t>(kOutputTensor));
137 
138     return true;
139 }
140 
141 }  // namespace
142 #endif  // NN_INCLUDE_CPU_IMPLEMENTATION
143 
validate(const IOperationValidationContext * context)144 Result<Version> validate(const IOperationValidationContext* context) {
145     uint32_t inputCount = context->getNumInputs();
146     NN_RET_CHECK_GE(inputCount, 2);
147     NN_RET_CHECK_EQ(context->getNumOutputs(), kNumOutputs);
148     const OperandType inputType = context->getInputType(0);
149     auto minSupportedVersion = Version::ANDROID_OC_MR1;
150     if (inputType == OperandType::TENSOR_FLOAT32 || inputType == OperandType::TENSOR_QUANT8_ASYMM) {
151         minSupportedVersion = Version::ANDROID_OC_MR1;
152     } else if (inputType == OperandType::TENSOR_FLOAT16) {
153         minSupportedVersion = Version::ANDROID_Q;
154     } else if (inputType == OperandType::TENSOR_QUANT8_ASYMM_SIGNED) {
155         minSupportedVersion = Version::ANDROID_R;
156     } else {
157         NN_RET_CHECK_FAIL() << "Unsupported tensor type for operation " << kOperationName;
158     }
159     std::vector<OperandType> inExpectedTypes(inputCount - 1, inputType);
160     inExpectedTypes.push_back(OperandType::INT32);
161     if (inputType == OperandType::TENSOR_QUANT8_ASYMM) {
162         const Shape& output = context->getOutputShape(kOutputTensor);
163         for (uint32_t i = 0; i < inputCount - 1; ++i) {
164             const Shape& input = context->getInputShape(i);
165             if (input.scale != output.scale || input.offset != output.offset) {
166                 minSupportedVersion = combineVersions(minSupportedVersion, Version::ANDROID_Q);
167             }
168         }
169     }
170     for (uint32_t i = 0; i < inputCount - 1; ++i) {
171         const uint32_t inputRank = getNumberOfDimensions(context->getInputShape(i));
172         if (inputRank != 0) {
173             NN_RET_CHECK_LE(inputRank, 4);
174         }
175     }
176     NN_RET_CHECK(validateInputTypes(context, inExpectedTypes));
177     NN_RET_CHECK(validateOutputTypes(context, {inputType}));
178     return minSupportedVersion;
179 }
180 
181 #ifdef NN_INCLUDE_CPU_IMPLEMENTATION
prepare(IOperationExecutionContext * context)182 bool prepare(IOperationExecutionContext* context) {
183     uint32_t numInputs = context->getNumInputs();
184     NN_RET_CHECK_GE(numInputs, 2);
185     const Shape& input0 = context->getInputShape(0);
186     uint32_t numDimensions = getNumberOfDimensions(input0);
187     int32_t axis = context->getInputValue<int32_t>(numInputs - 1);
188     NN_RET_CHECK_GE(axis, 0);
189     NN_RET_CHECK_LT(axis, numDimensions);
190     NN_RET_CHECK_LE(numDimensions, 4);
191 
192     uint32_t sumAxis = getSizeOfDimension(input0, axis);
193     for (uint32_t i = 1; i < numInputs - 1; ++i) {
194         const Shape& input = context->getInputShape(i);
195         NN_RET_CHECK_EQ(getNumberOfDimensions(input), numDimensions);
196         NN_RET_CHECK(input.type == input0.type);
197         for (uint32_t d = 0; d < numDimensions; ++d) {
198             if (d == axis) {
199                 sumAxis += getSizeOfDimension(input, axis);
200             } else {
201                 NN_RET_CHECK_EQ(getSizeOfDimension(input0, d), getSizeOfDimension(input, d));
202             }
203         }
204     }
205 
206     Shape output = context->getOutputShape(kOutputTensor);
207     output.type = input0.type;
208     output.dimensions = input0.dimensions;
209     output.dimensions[axis] = sumAxis;
210     return context->setOutputShape(kOutputTensor, output);
211 }
212 
execute(IOperationExecutionContext * context)213 bool execute(IOperationExecutionContext* context) {
214     // Bypass execution in the case of zero-sized input.
215     if (getNumberOfElements(context->getOutputShape(kOutputTensor)) == 0) return true;
216     switch (context->getInputType(0)) {
217         case OperandType::TENSOR_FLOAT16:
218             return concatenation<_Float16>(context);
219         case OperandType::TENSOR_FLOAT32:
220             return concatenation<float>(context);
221         case OperandType::TENSOR_QUANT8_ASYMM:
222             return concatenation<uint8_t>(context);
223         case OperandType::TENSOR_QUANT8_ASYMM_SIGNED:
224             return concatenation<int8_t>(context);
225         default:
226             NN_RET_CHECK_FAIL() << "Unsupported tensor type for operation " << kOperationName;
227     }
228 }
229 #endif  // NN_INCLUDE_CPU_IMPLEMENTATION
230 
231 }  // namespace concatenation
232 
233 NN_REGISTER_OPERATION(CONCATENATION, concatenation::kOperationName, concatenation::validate,
234                       concatenation::prepare, concatenation::execute, .allowZeroSizedInput = true);
235 
236 }  // namespace nn
237 }  // namespace android
238