1 /* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
2
3 Licensed under the Apache License, Version 2.0 (the "License");
4 you may not use this file except in compliance with the License.
5 You may obtain a copy of the License at
6
7 http://www.apache.org/licenses/LICENSE-2.0
8
9 Unless required by applicable law or agreed to in writing, software
10 distributed under the License is distributed on an "AS IS" BASIS,
11 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 See the License for the specific language governing permissions and
13 limitations under the License.
14 ==============================================================================*/
15
16 #include "tensorflow/lite/delegates/gpu/common/tasks/split_test_util.h"
17
18 #include <memory>
19 #include <vector>
20
21 #include "tensorflow/lite/delegates/gpu/common/operations.h"
22 #include "tensorflow/lite/delegates/gpu/common/status.h"
23 #include "tensorflow/lite/delegates/gpu/common/task/testing_util.h"
24 #include "tensorflow/lite/delegates/gpu/common/tasks/split.h"
25
26 namespace tflite {
27 namespace gpu {
28
SplitChannelsTest(TestExecutionEnvironment * env)29 absl::Status SplitChannelsTest(TestExecutionEnvironment* env) {
30 TensorFloat32 src_tensor;
31 src_tensor.shape = BHWC(1, 3, 2, 5);
32 src_tensor.data = {
33 half(0.1f), half(0.2f), half(0.3f), half(0.4), half(0.5),
34 half(1.1f), half(1.2f), half(1.3f), half(1.4), half(1.5),
35 half(10.1f), half(10.2f), half(10.3f), half(10.4), half(10.5),
36 half(11.1f), half(11.2f), half(11.3f), half(11.4), half(11.5),
37 half(20.1f), half(20.2f), half(20.3f), half(20.4), half(20.5),
38 half(21.1f), half(21.2f), half(21.3f), half(21.4), half(21.5)};
39
40 SplitAttributes attr;
41 attr.axis = Axis::CHANNELS;
42
43 for (auto precision : env->GetSupportedPrecisions()) {
44 auto data_type = DeduceDataTypeFromPrecision(precision);
45 for (auto storage : env->GetSupportedStorages(data_type)) {
46 OperationDef op_def;
47 op_def.precision = precision;
48 op_def.src_tensors.push_back({data_type, storage, Layout::HWC});
49 op_def.dst_tensors.push_back({data_type, storage, Layout::HWC});
50 op_def.dst_tensors.push_back({data_type, storage, Layout::HWC});
51 TensorFloat32 dst_tensor0, dst_tensor1;
52 Split operation = CreateSplit(env->GetGpuInfo(), op_def, attr, {2, 3});
53 RETURN_IF_ERROR(env->ExecuteGPUOperation(
54 {src_tensor}, std::make_unique<Split>(std::move(operation)),
55 {BHWC(1, 3, 2, 2), BHWC(1, 3, 2, 3)}, {&dst_tensor0, &dst_tensor1}));
56 RETURN_IF_ERROR(
57 PointWiseNear({half(0.1f), half(0.2f), half(1.1f), half(1.2f),
58 half(10.1f), half(10.2f), half(11.1f), half(11.2f),
59 half(20.1f), half(20.2f), half(21.1f), half(21.2f)},
60 dst_tensor0.data, 0.0f));
61 RETURN_IF_ERROR(PointWiseNear(
62 {half(0.3f), half(0.4), half(0.5), half(1.3f), half(1.4), half(1.5),
63 half(10.3f), half(10.4), half(10.5), half(11.3f), half(11.4),
64 half(11.5), half(20.3f), half(20.4), half(20.5), half(21.3f),
65 half(21.4), half(21.5)},
66 dst_tensor1.data, 0.0f));
67 }
68 }
69 return absl::OkStatus();
70 }
71
SplitChannelsX4Test(TestExecutionEnvironment * env)72 absl::Status SplitChannelsX4Test(TestExecutionEnvironment* env) {
73 TensorFloat32 src_tensor;
74 src_tensor.shape = BHWC(1, 2, 2, 8);
75 src_tensor.data = {half(0.1f), half(0.2f), half(0.3f), half(0.4),
76 half(1.1f), half(1.2f), half(1.3f), half(1.4),
77 half(10.1f), half(10.2f), half(10.3f), half(10.4),
78 half(11.1f), half(11.2f), half(11.3f), half(11.4),
79 half(20.1f), half(20.2f), half(20.3f), half(20.4),
80 half(21.1f), half(21.2f), half(21.3f), half(21.4),
81 half(30.1f), half(30.2f), half(30.3f), half(30.4),
82 half(31.1f), half(31.2f), half(31.3f), half(31.4)};
83
84 SplitAttributes attr;
85 attr.axis = Axis::CHANNELS;
86
87 for (auto precision : env->GetSupportedPrecisions()) {
88 auto data_type = DeduceDataTypeFromPrecision(precision);
89 for (auto storage : env->GetSupportedStorages(data_type)) {
90 OperationDef op_def;
91 op_def.precision = precision;
92 op_def.src_tensors.push_back({data_type, storage, Layout::HWC});
93 op_def.dst_tensors.push_back({data_type, storage, Layout::HWC});
94 op_def.dst_tensors.push_back({data_type, storage, Layout::HWC});
95 TensorFloat32 dst_tensor0, dst_tensor1;
96 Split operation = CreateSplit(env->GetGpuInfo(), op_def, attr, {4, 4});
97 RETURN_IF_ERROR(env->ExecuteGPUOperation(
98 {src_tensor}, std::make_unique<Split>(std::move(operation)),
99 {BHWC(1, 2, 2, 4), BHWC(1, 2, 2, 4)}, {&dst_tensor0, &dst_tensor1}));
100 RETURN_IF_ERROR(
101 PointWiseNear({half(0.1f), half(0.2f), half(0.3f), half(0.4),
102 half(10.1f), half(10.2f), half(10.3f), half(10.4),
103 half(20.1f), half(20.2f), half(20.3f), half(20.4),
104 half(30.1f), half(30.2f), half(30.3f), half(30.4)},
105 dst_tensor0.data, 0.0f));
106 RETURN_IF_ERROR(
107 PointWiseNear({half(1.1f), half(1.2f), half(1.3f), half(1.4),
108 half(11.1f), half(11.2f), half(11.3f), half(11.4),
109 half(21.1f), half(21.2f), half(21.3f), half(21.4),
110 half(31.1f), half(31.2f), half(31.3f), half(31.4)},
111 dst_tensor1.data, 0.0f));
112 }
113 }
114 return absl::OkStatus();
115 }
116
SplitWidthTest(TestExecutionEnvironment * env)117 absl::Status SplitWidthTest(TestExecutionEnvironment* env) {
118 TensorFloat32 src_tensor;
119 src_tensor.shape = BHWC(1, 6, 5, 1);
120 src_tensor.data = {
121 half(0.1f), half(0.2f), half(0.3f), half(0.4), half(0.5),
122 half(1.1f), half(1.2f), half(1.3f), half(1.4), half(1.5),
123 half(10.1f), half(10.2f), half(10.3f), half(10.4), half(10.5),
124 half(11.1f), half(11.2f), half(11.3f), half(11.4), half(11.5),
125 half(20.1f), half(20.2f), half(20.3f), half(20.4), half(20.5),
126 half(21.1f), half(21.2f), half(21.3f), half(21.4), half(21.5)};
127
128 SplitAttributes attr;
129 attr.axis = Axis::WIDTH;
130
131 for (auto precision : env->GetSupportedPrecisions()) {
132 auto data_type = DeduceDataTypeFromPrecision(precision);
133 for (auto storage : env->GetSupportedStorages(data_type)) {
134 OperationDef op_def;
135 op_def.precision = precision;
136 op_def.src_tensors.push_back({data_type, storage, Layout::HWC});
137 op_def.dst_tensors.push_back({data_type, storage, Layout::HWC});
138 op_def.dst_tensors.push_back({data_type, storage, Layout::HWC});
139 TensorFloat32 dst_tensor0, dst_tensor1;
140 Split operation = CreateSplit(env->GetGpuInfo(), op_def, attr, {1, 1});
141 RETURN_IF_ERROR(env->ExecuteGPUOperation(
142 {src_tensor}, std::make_unique<Split>(std::move(operation)),
143 {BHWC(1, 6, 2, 1), BHWC(1, 6, 3, 1)}, {&dst_tensor0, &dst_tensor1}));
144 RETURN_IF_ERROR(
145 PointWiseNear({half(0.1f), half(0.2f), half(1.1f), half(1.2f),
146 half(10.1f), half(10.2f), half(11.1f), half(11.2f),
147 half(20.1f), half(20.2f), half(21.1f), half(21.2f)},
148 dst_tensor0.data, 0.0f));
149 RETURN_IF_ERROR(PointWiseNear(
150 {half(0.3f), half(0.4), half(0.5), half(1.3f), half(1.4), half(1.5),
151 half(10.3f), half(10.4), half(10.5), half(11.3f), half(11.4),
152 half(11.5), half(20.3f), half(20.4), half(20.5), half(21.3f),
153 half(21.4), half(21.5)},
154 dst_tensor1.data, 0.0f));
155 }
156 }
157 return absl::OkStatus();
158 }
159
SplitHeightTest(TestExecutionEnvironment * env)160 absl::Status SplitHeightTest(TestExecutionEnvironment* env) {
161 TensorFloat32 src_tensor;
162 src_tensor.shape = BHWC(1, 6, 5, 1);
163 src_tensor.data = {
164 half(0.1f), half(0.2f), half(0.3f), half(0.4), half(0.5),
165 half(1.1f), half(1.2f), half(1.3f), half(1.4), half(1.5),
166 half(10.1f), half(10.2f), half(10.3f), half(10.4), half(10.5),
167 half(11.1f), half(11.2f), half(11.3f), half(11.4), half(11.5),
168 half(20.1f), half(20.2f), half(20.3f), half(20.4), half(20.5),
169 half(21.1f), half(21.2f), half(21.3f), half(21.4), half(21.5)};
170
171 SplitAttributes attr;
172 attr.axis = Axis::HEIGHT;
173
174 for (auto precision : env->GetSupportedPrecisions()) {
175 auto data_type = DeduceDataTypeFromPrecision(precision);
176 for (auto storage : env->GetSupportedStorages(data_type)) {
177 OperationDef op_def;
178 op_def.precision = precision;
179 op_def.src_tensors.push_back({data_type, storage, Layout::HWC});
180 op_def.dst_tensors.push_back({data_type, storage, Layout::HWC});
181 op_def.dst_tensors.push_back({data_type, storage, Layout::HWC});
182 TensorFloat32 dst_tensor0, dst_tensor1;
183 Split operation = CreateSplit(env->GetGpuInfo(), op_def, attr, {1, 1});
184 RETURN_IF_ERROR(env->ExecuteGPUOperation(
185 {src_tensor}, std::make_unique<Split>(std::move(operation)),
186 {BHWC(1, 2, 5, 1), BHWC(1, 4, 5, 1)}, {&dst_tensor0, &dst_tensor1}));
187 RETURN_IF_ERROR(PointWiseNear(
188 {half(0.1f), half(0.2f), half(0.3f), half(0.4), half(0.5), half(1.1f),
189 half(1.2f), half(1.3f), half(1.4), half(1.5)},
190 dst_tensor0.data, 0.0f));
191 RETURN_IF_ERROR(PointWiseNear(
192 {half(10.1f), half(10.2f), half(10.3f), half(10.4), half(10.5),
193 half(11.1f), half(11.2f), half(11.3f), half(11.4), half(11.5),
194 half(20.1f), half(20.2f), half(20.3f), half(20.4), half(20.5),
195 half(21.1f), half(21.2f), half(21.3f), half(21.4), half(21.5)},
196 dst_tensor1.data, 0.0f));
197 }
198 }
199 return absl::OkStatus();
200 }
201
SplitBatchTest(TestExecutionEnvironment * env)202 absl::Status SplitBatchTest(TestExecutionEnvironment* env) {
203 TensorFloat32 src_tensor;
204 src_tensor.shape = BHWC(6, 1, 5, 1);
205 src_tensor.data = {
206 half(0.1f), half(0.2f), half(0.3f), half(0.4), half(0.5),
207 half(1.1f), half(1.2f), half(1.3f), half(1.4), half(1.5),
208 half(10.1f), half(10.2f), half(10.3f), half(10.4), half(10.5),
209 half(11.1f), half(11.2f), half(11.3f), half(11.4), half(11.5),
210 half(20.1f), half(20.2f), half(20.3f), half(20.4), half(20.5),
211 half(21.1f), half(21.2f), half(21.3f), half(21.4), half(21.5)};
212
213 SplitAttributes attr;
214 attr.axis = Axis::BATCH;
215
216 for (auto precision : env->GetSupportedPrecisions()) {
217 auto data_type = DeduceDataTypeFromPrecision(precision);
218 for (auto storage : env->GetSupportedStorages(data_type)) {
219 OperationDef op_def;
220 op_def.precision = precision;
221 op_def.src_tensors.push_back({data_type, storage, Layout::BHWC});
222 op_def.dst_tensors.push_back({data_type, storage, Layout::HWC});
223 op_def.dst_tensors.push_back({data_type, storage, Layout::BHWC});
224 TensorFloat32 dst_tensor0, dst_tensor1;
225 Split operation = CreateSplit(env->GetGpuInfo(), op_def, attr, {1, 1});
226 RETURN_IF_ERROR(env->ExecuteGPUOperation(
227 {src_tensor}, std::make_unique<Split>(std::move(operation)),
228 {BHWC(1, 1, 5, 1), BHWC(5, 1, 5, 1)}, {&dst_tensor0, &dst_tensor1}));
229 RETURN_IF_ERROR(PointWiseNear(
230 {half(0.1f), half(0.2f), half(0.3f), half(0.4), half(0.5)},
231 dst_tensor0.data, 0.0f));
232 RETURN_IF_ERROR(PointWiseNear(
233 {half(1.1f), half(1.2f), half(1.3f), half(1.4), half(1.5),
234 half(10.1f), half(10.2f), half(10.3f), half(10.4), half(10.5),
235 half(11.1f), half(11.2f), half(11.3f), half(11.4), half(11.5),
236 half(20.1f), half(20.2f), half(20.3f), half(20.4), half(20.5),
237 half(21.1f), half(21.2f), half(21.3f), half(21.4), half(21.5)},
238 dst_tensor1.data, 0.0f));
239 }
240 }
241 return absl::OkStatus();
242 }
243
SplitDepthTest(TestExecutionEnvironment * env)244 absl::Status SplitDepthTest(TestExecutionEnvironment* env) {
245 Tensor5DFloat32 src_tensor;
246 src_tensor.shape = BHWDC(1, 6, 1, 5, 1);
247 src_tensor.data = {
248 half(0.1f), half(0.2f), half(0.3f), half(0.4), half(0.5),
249 half(1.1f), half(1.2f), half(1.3f), half(1.4), half(1.5),
250 half(10.1f), half(10.2f), half(10.3f), half(10.4), half(10.5),
251 half(11.1f), half(11.2f), half(11.3f), half(11.4), half(11.5),
252 half(20.1f), half(20.2f), half(20.3f), half(20.4), half(20.5),
253 half(21.1f), half(21.2f), half(21.3f), half(21.4), half(21.5)};
254
255 SplitAttributes attr;
256 attr.axis = Axis::DEPTH;
257
258 for (auto precision : env->GetSupportedPrecisions()) {
259 auto data_type = DeduceDataTypeFromPrecision(precision);
260 for (auto storage : env->GetSupportedStorages(data_type)) {
261 OperationDef op_def;
262 op_def.precision = precision;
263 op_def.src_tensors.push_back({data_type, storage, Layout::HWDC});
264 op_def.dst_tensors.push_back({data_type, storage, Layout::HWDC});
265 op_def.dst_tensors.push_back({data_type, storage, Layout::HWDC});
266 Tensor5DFloat32 dst_tensor0, dst_tensor1;
267 Split operation = CreateSplit(env->GetGpuInfo(), op_def, attr, {1, 1});
268 RETURN_IF_ERROR(env->ExecuteGPUOperation(
269 {src_tensor}, std::make_unique<Split>(std::move(operation)),
270 {BHWDC(1, 6, 1, 2, 1), BHWDC(1, 6, 1, 3, 1)},
271 {&dst_tensor0, &dst_tensor1}));
272 RETURN_IF_ERROR(
273 PointWiseNear({half(0.1f), half(0.2f), half(1.1f), half(1.2f),
274 half(10.1f), half(10.2f), half(11.1f), half(11.2f),
275 half(20.1f), half(20.2f), half(21.1f), half(21.2f)},
276 dst_tensor0.data, 0.0f));
277 RETURN_IF_ERROR(PointWiseNear(
278 {half(0.3f), half(0.4), half(0.5), half(1.3f), half(1.4), half(1.5),
279 half(10.3f), half(10.4), half(10.5), half(11.3f), half(11.4),
280 half(11.5), half(20.3f), half(20.4), half(20.5), half(21.3f),
281 half(21.4), half(21.5)},
282 dst_tensor1.data, 0.0f));
283 }
284 }
285 return absl::OkStatus();
286 }
287
288 } // namespace gpu
289 } // namespace tflite
290