1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
|
/*
* Copyright (C) 2019 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.
*/
// Contains the implementation of the operations.
#define LOG_TAG "Operations"
#include <vector>
#include "HalInterfaces.h"
#include "OperationResolver.h"
#include "Operations.h"
#include "Tracing.h"
namespace android {
namespace nn {
namespace squeeze {
constexpr uint32_t kNumInputs = 2;
constexpr uint32_t kInputTensor = 0;
constexpr uint32_t kSqueezeDims = 1;
constexpr uint32_t kNumOutputs = 1;
constexpr uint32_t kOutputTensor = 0;
using namespace hal;
bool 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 ||
inputType == OperandType::TENSOR_QUANT8_ASYMM ||
inputType == OperandType::TENSOR_QUANT8_ASYMM_SIGNED)
<< "Unsupported input operand type for SQUEEZE op: " << toString(inputType);
HalVersion minSupportedHalVersion;
if (inputType == OperandType::TENSOR_QUANT8_ASYMM_SIGNED) {
minSupportedHalVersion = HalVersion::V1_3;
} else if (inputType == OperandType::TENSOR_FLOAT16) {
minSupportedHalVersion = HalVersion::V1_2;
} else {
minSupportedHalVersion = HalVersion::V1_1;
}
NN_RET_CHECK(validateInputTypes(context, {
inputType,
OperandType::TENSOR_INT32,
}));
NN_RET_CHECK(validateOutputTypes(context, {inputType}));
const Shape& input = context->getInputShape(kInputTensor);
if (hasKnownRank(input)) {
NN_RET_CHECK_LE(getNumberOfDimensions(input), 4);
}
return validateHalVersion(context, minSupportedHalVersion);
}
bool prepare(IOperationExecutionContext* context) {
// Only the squeeze dims tensor can be omitted.
NN_RET_CHECK(!context->isOmittedInput(kInputTensor));
NN_RET_CHECK(!context->isOmittedOutput(kOutputTensor));
const int32_t* squeezeDims = context->getInputBuffer<int32_t>(kSqueezeDims);
const Shape inputShape = context->getInputShape(kInputTensor);
const Shape squeezeDimsShape = context->getInputShape(kSqueezeDims);
int32_t numInputDims = static_cast<int32_t>(getNumberOfDimensions(inputShape));
NN_RET_CHECK_LE(getNumberOfDimensions(inputShape), 4);
// squeezeDims need to be provided as a 1-D int32 tensor.
NN_OPS_CHECK(squeezeDimsShape.type == OperandType::TENSOR_INT32);
NN_OPS_CHECK(getNumberOfDimensions(squeezeDimsShape) == 1);
std::vector<bool> shouldSqueeze(numInputDims, false);
int32_t numDimsSqueezed = 0;
if (context->isOmittedInput(kSqueezeDims)) {
// If squeezeDims is omitted, all dims with value 1 will be squeezed.
for (int32_t idx = 0; idx < numInputDims; ++idx) {
if (getSizeOfDimension(inputShape, idx) == 1) {
shouldSqueeze[idx] = true;
++numDimsSqueezed;
}
}
} else {
int32_t squeezeDimsSize = static_cast<int32_t>(getSizeOfDimension(squeezeDimsShape, 0));
for (int32_t idx = 0; idx < squeezeDimsSize; ++idx) {
int32_t current =
squeezeDims[idx] < 0 ? squeezeDims[idx] + numInputDims : squeezeDims[idx];
NN_OPS_CHECK(current >= 0 && current < numInputDims &&
getSizeOfDimension(inputShape, current) == 1);
if (!shouldSqueeze[current]) ++numDimsSqueezed;
shouldSqueeze[current] = true;
}
}
// Sets output dimensions.
std::vector<uint32_t> outDims(numInputDims - numDimsSqueezed);
if (numInputDims == numDimsSqueezed) {
// Handle edge case where squeeze removes all dimensions.
outDims.push_back(1);
} else {
for (int32_t inIdx = 0, outIdx = 0; inIdx < numInputDims; ++inIdx) {
if (!shouldSqueeze[inIdx]) {
outDims[outIdx++] = getSizeOfDimension(inputShape, inIdx);
}
}
}
Shape outputShape(inputShape);
outputShape.dimensions = outDims;
return context->setOutputShape(kOutputTensor, outputShape);
}
bool execute(IOperationExecutionContext* context) {
switch (context->getInputType(kInputTensor)) {
case OperandType::TENSOR_FLOAT16:
case OperandType::TENSOR_FLOAT32:
case OperandType::TENSOR_QUANT8_ASYMM:
case OperandType::TENSOR_QUANT8_ASYMM_SIGNED:
return copyData(context->getInputBuffer(kInputTensor),
context->getInputShape(kInputTensor),
context->getOutputBuffer(kOutputTensor),
context->getOutputShape(kOutputTensor));
default:
NN_RET_CHECK_FAIL() << "Unsupported tensor type for SQUEEZE op.";
}
}
} // namespace squeeze
NN_REGISTER_OPERATION(SQUEEZE, "SQUEEZE", squeeze::validate, squeeze::prepare, squeeze::execute,
.allowOmittedOperand = true);
} // namespace nn
} // namespace android
|
