1 /* Copyright 2019 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/c/builtin_op_data.h"
17 #include "tensorflow/lite/c/common.h"
18 #include "tensorflow/lite/micro/all_ops_resolver.h"
19 #include "tensorflow/lite/micro/kernels/kernel_runner.h"
20 #include "tensorflow/lite/micro/test_helpers.h"
21 #include "tensorflow/lite/micro/testing/micro_test.h"
22
23 namespace tflite {
24 namespace testing {
25 namespace {
26
27 // Common 2D inputs, outputs and axis.
28 static const int kInputElements2D = 8;
29 static const int kInputShape2D[] = {2, 2, 4};
30 static const float kInputData2D[] = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0};
31
32 static const int kAxisShape2D[] = {1, 1};
33 static const int32_t kAxisData2D[] = {1};
34
35 static const int kOutputElements2D = 2;
36 static const int kOutputShape2D[] = {2, 1, 2};
37 static const float kGoldenData2D[] = {2.5, 6.5};
38
39 // Common 3D inputs, outputs and axis.
40 static const int kInputElements3D = 8;
41 static const int kInputShape3D[] = {3, 2, 2, 2};
42 static const float kInputData3D[] = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0};
43
44 static const int kAxisShape3D[] = {1, 2};
45 static const int32_t kAxisData3D[] = {1, 2};
46
47 static const int kOutputElements3D = 2;
48 static const int kOutputShape3D[] = {2, 1, 2};
49 static const float kGoldenData3D[] = {2.5, 6.5};
50
51 // Common 4D inputs, outputs and axis.
52 static const int kInputElements4D = 24;
53 static const int kInputShape4D[] = {4, 2, 2, 3, 2};
54 static const float kInputData4D[] = {
55 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0,
56 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0};
57
58 static const int kAxisShape4D[] = {1, 2};
59 static const int32_t kAxisData4D[] = {1, 2};
60
61 static const int kOutputElements4D = 4;
62 static const int kOutputShape4D[] = {4, 2, 1, 1, 2};
63 static const float kGoldenData4D[] = {6, 7, 18, 19};
64
65 // Axis shape and contents are independent of input / output dimensions.
66
67 template <typename T>
ValidateReduceGoldens(TfLiteTensor * tensors,int tensors_size,const T * expected_output_data,T * output_data,int output_length,const TfLiteRegistration & registration,TfLiteReducerParams * params,float tolerance=1e-5)68 TfLiteStatus ValidateReduceGoldens(TfLiteTensor* tensors, int tensors_size,
69 const T* expected_output_data,
70 T* output_data, int output_length,
71 const TfLiteRegistration& registration,
72 TfLiteReducerParams* params,
73 float tolerance = 1e-5) {
74 int inputs_array_data[] = {2, 0, 1};
75 TfLiteIntArray* inputs_array = IntArrayFromInts(inputs_array_data);
76 int outputs_array_data[] = {1, 2};
77 TfLiteIntArray* outputs_array = IntArrayFromInts(outputs_array_data);
78
79 micro::KernelRunner runner(registration, tensors, tensors_size, inputs_array,
80 outputs_array, params);
81
82 TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.InitAndPrepare());
83 TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.Invoke());
84
85 for (int i = 0; i < output_length; ++i) {
86 TF_LITE_MICRO_EXPECT_NEAR(expected_output_data[i], output_data[i],
87 tolerance);
88 }
89 return kTfLiteOk;
90 }
91
TestMeanFloatInput4D(const int * input_dims_data,const float * input_data,const int * axis_dims_data,const int32_t * axis_data,const int * output_dims_data,const float * expected_output_data,float * output_data,TfLiteReducerParams * params,float tolerance=1e-5)92 void TestMeanFloatInput4D(const int* input_dims_data, const float* input_data,
93 const int* axis_dims_data, const int32_t* axis_data,
94 const int* output_dims_data,
95 const float* expected_output_data, float* output_data,
96 TfLiteReducerParams* params, float tolerance = 1e-5) {
97 TfLiteIntArray* input_dims = IntArrayFromInts(input_dims_data);
98 TfLiteIntArray* axis_dims = IntArrayFromInts(axis_dims_data);
99 TfLiteIntArray* output_dims = IntArrayFromInts(output_dims_data);
100 const int output_dims_count = ElementCount(*output_dims);
101
102 const TfLiteRegistration registration = tflite::ops::micro::Register_MEAN();
103
104 constexpr int num_of_inputs = 2; // input and axis
105 constexpr int num_of_outputs = 1; // output
106
107 constexpr int tensors_size = num_of_inputs + num_of_outputs;
108 TfLiteTensor tensors[tensors_size] = {
109 CreateTensor(input_data, input_dims),
110 CreateTensor(axis_data, axis_dims),
111 CreateTensor(output_data, output_dims),
112 };
113
114 TF_LITE_MICRO_EXPECT_EQ(
115 kTfLiteOk, ValidateReduceGoldens(
116 tensors, tensors_size, expected_output_data, output_data,
117 output_dims_count, registration, params, tolerance));
118 }
119
TestReduceOpFloat(const int * input_dims_data,const float * input_data,const int * axis_dims_data,const int32_t * axis_data,const int * output_dims_data,float * output_data,const float * expected_output_data,const TfLiteRegistration & registration,TfLiteReducerParams * params,float tolerance=1e-5)120 void TestReduceOpFloat(const int* input_dims_data, const float* input_data,
121 const int* axis_dims_data, const int32_t* axis_data,
122 const int* output_dims_data, float* output_data,
123 const float* expected_output_data,
124 const TfLiteRegistration& registration,
125 TfLiteReducerParams* params, float tolerance = 1e-5) {
126 TfLiteIntArray* input_dims = IntArrayFromInts(input_dims_data);
127 TfLiteIntArray* axis_dims = IntArrayFromInts(axis_dims_data);
128 TfLiteIntArray* output_dims = IntArrayFromInts(output_dims_data);
129 const int output_dims_count = ElementCount(*output_dims);
130
131 constexpr int num_of_inputs = 2; // input and axis
132 constexpr int num_of_outputs = 1; // output
133
134 constexpr int tensors_size = num_of_inputs + num_of_outputs;
135 TfLiteTensor tensors[tensors_size] = {
136 CreateTensor(input_data, input_dims),
137 CreateTensor(axis_data, axis_dims),
138 CreateTensor(output_data, output_dims),
139 };
140
141 TF_LITE_MICRO_EXPECT_EQ(
142 kTfLiteOk, ValidateReduceGoldens(
143 tensors, tensors_size, expected_output_data, output_data,
144 output_dims_count, registration, params, tolerance));
145 }
146
147 template <typename T>
TestReduceOpQuantized(const int * input_dims_data,const float * input_data,T * input_data_quant,float input_scale,int input_zero_point,const int * axis_dims_data,const int32_t * axis_data,const int * output_dims_data,const float * expected_output_data,T * output_data_quant,T * expected_output_data_quant,float output_scale,int output_zero_point,const TfLiteRegistration & registration,TfLiteReducerParams * params)148 void TestReduceOpQuantized(
149 const int* input_dims_data, const float* input_data, T* input_data_quant,
150 float input_scale, int input_zero_point, const int* axis_dims_data,
151 const int32_t* axis_data, const int* output_dims_data,
152 const float* expected_output_data, T* output_data_quant,
153 T* expected_output_data_quant, float output_scale, int output_zero_point,
154 const TfLiteRegistration& registration, TfLiteReducerParams* params) {
155 // Convert dimesion arguments to TfLiteArrays
156 TfLiteIntArray* input_dims = IntArrayFromInts(input_dims_data);
157 TfLiteIntArray* axis_dims = IntArrayFromInts(axis_dims_data);
158 TfLiteIntArray* output_dims = IntArrayFromInts(output_dims_data);
159
160 // Get number of elements in input and output tensors
161 const int output_dims_count = ElementCount(*output_dims);
162
163 // Initialize tensors
164 constexpr int tensors_size = 3;
165 TfLiteTensor tensors[] = {
166 CreateQuantizedTensor(input_data, input_data_quant, input_dims,
167 input_scale, input_zero_point),
168 CreateTensor(axis_data, axis_dims),
169 CreateQuantizedTensor(output_data_quant, output_dims, output_scale,
170 output_zero_point),
171 };
172
173 // Quantize expected output
174 tflite::Quantize(expected_output_data, expected_output_data_quant,
175 output_dims_count, output_scale, output_zero_point);
176
177 TF_LITE_MICRO_EXPECT_EQ(
178 kTfLiteOk,
179 ValidateReduceGoldens(tensors, tensors_size, expected_output_data_quant,
180 output_data_quant, output_dims_count, registration,
181 params, 0.01));
182 }
183
184 template <typename T>
TestMeanOpQuantized(const int * input_dims_data,const float * input_data,T * input_data_quant,float input_scale,int input_zero_point,const int * axis_dims_data,const int32_t * axis_data,const int * output_dims_data,const float * expected_output_data,T * output_data_quant,T * expected_output_data_quant,float output_scale,int output_zero_point,TfLiteReducerParams * params)185 void TestMeanOpQuantized(const int* input_dims_data, const float* input_data,
186 T* input_data_quant, float input_scale,
187 int input_zero_point, const int* axis_dims_data,
188 const int32_t* axis_data, const int* output_dims_data,
189 const float* expected_output_data,
190 T* output_data_quant, T* expected_output_data_quant,
191 float output_scale, int output_zero_point,
192 TfLiteReducerParams* params) {
193 // Convert dimesion arguments to TfLiteArrays
194 TfLiteIntArray* input_dims = IntArrayFromInts(input_dims_data);
195 TfLiteIntArray* axis_dims = IntArrayFromInts(axis_dims_data);
196 TfLiteIntArray* output_dims = IntArrayFromInts(output_dims_data);
197
198 // Get number of elements in input and output tensors
199 const int output_dims_count = ElementCount(*output_dims);
200
201 // Initialize tensors
202 constexpr int tensors_size = 3;
203 TfLiteTensor tensors[] = {
204 CreateQuantizedTensor(input_data, input_data_quant, input_dims,
205 input_scale, input_zero_point),
206 CreateTensor(axis_data, axis_dims),
207 CreateQuantizedTensor(output_data_quant, output_dims, output_scale,
208 output_zero_point),
209 };
210
211 // Quantize expected output
212 tflite::Quantize(expected_output_data, expected_output_data_quant,
213 output_dims_count, output_scale, output_zero_point);
214
215 TF_LITE_MICRO_EXPECT_EQ(
216 kTfLiteOk,
217 ValidateReduceGoldens(tensors, tensors_size, expected_output_data_quant,
218 output_data_quant, output_dims_count,
219 tflite::ops::micro::Register_MEAN(), params, 1.0));
220 }
221
222 } // namespace
223 } // namespace testing
224 } // namespace tflite
225
226 TF_LITE_MICRO_TESTS_BEGIN
227
TF_LITE_MICRO_TEST(MeanFloat2DKeepDims)228 TF_LITE_MICRO_TEST(MeanFloat2DKeepDims) {
229 float output_data[tflite::testing::kOutputElements2D];
230
231 TfLiteReducerParams params = {true};
232
233 tflite::testing::TestMeanFloatInput4D(
234 tflite::testing::kInputShape2D, tflite::testing::kInputData2D,
235 tflite::testing::kAxisShape2D, tflite::testing::kAxisData2D,
236 tflite::testing::kOutputShape2D, tflite::testing::kGoldenData2D,
237 output_data, ¶ms);
238 }
239
TF_LITE_MICRO_TEST(MeanInt82DKeepDims)240 TF_LITE_MICRO_TEST(MeanInt82DKeepDims) {
241 int8_t expected_output_data_quant[tflite::testing::kOutputElements2D];
242 int8_t output_data_quant[tflite::testing::kOutputElements2D];
243 int8_t input_data_quant[tflite::testing::kInputElements2D];
244
245 float input_scale = 0.5f;
246 int input_zero_point = 0;
247 float output_scale = 0.5f;
248 int output_zero_point = 0;
249
250 TfLiteReducerParams params = {
251 true // keep_dims
252 };
253
254 tflite::testing::TestMeanOpQuantized<int8_t>(
255 tflite::testing::kInputShape2D, tflite::testing::kInputData2D,
256 input_data_quant, input_scale, input_zero_point,
257 tflite::testing::kAxisShape2D, tflite::testing::kAxisData2D,
258 tflite::testing::kOutputShape2D, tflite::testing::kGoldenData2D,
259 output_data_quant, expected_output_data_quant, output_scale,
260 output_zero_point, ¶ms);
261 }
262
TF_LITE_MICRO_TEST(MeanUInt82DKeepDims)263 TF_LITE_MICRO_TEST(MeanUInt82DKeepDims) {
264 uint8_t expected_output_data_quant[tflite::testing::kOutputElements2D];
265 uint8_t output_data_quant[tflite::testing::kOutputElements2D];
266 uint8_t input_data_quant[tflite::testing::kInputElements2D];
267
268 float input_scale = 0.5f;
269 int input_zero_point = 128;
270 float output_scale = 0.5f;
271 int output_zero_point = 128;
272
273 TfLiteReducerParams params = {
274 true // keep_dims
275 };
276
277 tflite::testing::TestMeanOpQuantized<uint8_t>(
278 tflite::testing::kInputShape2D, tflite::testing::kInputData2D,
279 input_data_quant, input_scale, input_zero_point,
280 tflite::testing::kAxisShape2D, tflite::testing::kAxisData2D,
281 tflite::testing::kOutputShape2D, tflite::testing::kGoldenData2D,
282 output_data_quant, expected_output_data_quant, output_scale,
283 output_zero_point, ¶ms);
284 }
285
TF_LITE_MICRO_TEST(MeanFloat3DKeepDims)286 TF_LITE_MICRO_TEST(MeanFloat3DKeepDims) {
287 float output_data[tflite::testing::kOutputElements3D];
288
289 TfLiteReducerParams params = {true};
290
291 tflite::testing::TestMeanFloatInput4D(
292 tflite::testing::kInputShape3D, tflite::testing::kInputData3D,
293 tflite::testing::kAxisShape3D, tflite::testing::kAxisData3D,
294 tflite::testing::kOutputShape3D, tflite::testing::kGoldenData3D,
295 output_data, ¶ms);
296 }
297
TF_LITE_MICRO_TEST(MeanInt83DKeepDims)298 TF_LITE_MICRO_TEST(MeanInt83DKeepDims) {
299 int8_t expected_output_data_quant[tflite::testing::kOutputElements3D];
300 int8_t output_data_quant[tflite::testing::kOutputElements3D];
301 int8_t input_data_quant[tflite::testing::kInputElements3D];
302
303 float input_scale = 0.5f;
304 int input_zero_point = 0;
305 float output_scale = 0.5f;
306 int output_zero_point = 0;
307
308 TfLiteReducerParams params = {
309 true // keep_dims
310 };
311
312 tflite::testing::TestMeanOpQuantized<int8_t>(
313 tflite::testing::kInputShape3D, tflite::testing::kInputData3D,
314 input_data_quant, input_scale, input_zero_point,
315 tflite::testing::kAxisShape3D, tflite::testing::kAxisData3D,
316 tflite::testing::kOutputShape3D, tflite::testing::kGoldenData3D,
317 output_data_quant, expected_output_data_quant, output_scale,
318 output_zero_point, ¶ms);
319 }
320
TF_LITE_MICRO_TEST(MeanUInt83DKeepDims)321 TF_LITE_MICRO_TEST(MeanUInt83DKeepDims) {
322 uint8_t expected_output_data_quant[tflite::testing::kOutputElements3D];
323 uint8_t output_data_quant[tflite::testing::kOutputElements3D];
324 uint8_t input_data_quant[tflite::testing::kInputElements3D];
325
326 float input_scale = 0.5f;
327 int input_zero_point = 138;
328 float output_scale = 0.5f;
329 int output_zero_point = 138;
330
331 TfLiteReducerParams params = {
332 true // keep_dims
333 };
334
335 tflite::testing::TestMeanOpQuantized<uint8_t>(
336 tflite::testing::kInputShape3D, tflite::testing::kInputData3D,
337 input_data_quant, input_scale, input_zero_point,
338 tflite::testing::kAxisShape3D, tflite::testing::kAxisData3D,
339 tflite::testing::kOutputShape3D, tflite::testing::kGoldenData3D,
340 output_data_quant, expected_output_data_quant, output_scale,
341 output_zero_point, ¶ms);
342 }
343
TF_LITE_MICRO_TEST(MeanFloat4DKeepDims)344 TF_LITE_MICRO_TEST(MeanFloat4DKeepDims) {
345 float output_data[tflite::testing::kOutputElements4D];
346
347 TfLiteReducerParams params = {
348 true // keep_dims
349 };
350
351 tflite::testing::TestMeanFloatInput4D(
352 tflite::testing::kInputShape4D, tflite::testing::kInputData4D,
353 tflite::testing::kAxisShape4D, tflite::testing::kAxisData4D,
354 tflite::testing::kOutputShape4D, tflite::testing::kGoldenData4D,
355 output_data, ¶ms);
356 }
357
TF_LITE_MICRO_TEST(MeanInt84DKeepDims)358 TF_LITE_MICRO_TEST(MeanInt84DKeepDims) {
359 int8_t expected_output_data_quant[tflite::testing::kOutputElements4D];
360 int8_t output_data_quant[tflite::testing::kOutputElements4D];
361 int8_t input_data_quant[tflite::testing::kInputElements4D];
362
363 float input_scale = 0.5f;
364 int input_zero_point = 0;
365 float output_scale = 0.5f;
366 int output_zero_point = 0;
367
368 TfLiteReducerParams params = {
369 true // keep_dims
370 };
371
372 tflite::testing::TestMeanOpQuantized<int8_t>(
373 tflite::testing::kInputShape4D, tflite::testing::kInputData4D,
374 input_data_quant, input_scale, input_zero_point,
375 tflite::testing::kAxisShape4D, tflite::testing::kAxisData4D,
376 tflite::testing::kOutputShape4D, tflite::testing::kGoldenData4D,
377 output_data_quant, expected_output_data_quant, output_scale,
378 output_zero_point, ¶ms);
379 }
380
TF_LITE_MICRO_TEST(MeanUInt84DKeepDims)381 TF_LITE_MICRO_TEST(MeanUInt84DKeepDims) {
382 uint8_t expected_output_data_quant[tflite::testing::kOutputElements4D];
383 uint8_t output_data_quant[tflite::testing::kOutputElements4D];
384 uint8_t input_data_quant[tflite::testing::kInputElements4D];
385
386 float input_scale = 0.5f;
387 int input_zero_point = 128;
388 float output_scale = 0.5f;
389 int output_zero_point = 128;
390
391 TfLiteReducerParams params = {
392 true // keep_dims
393 };
394
395 tflite::testing::TestMeanOpQuantized<uint8_t>(
396 tflite::testing::kInputShape4D, tflite::testing::kInputData4D,
397 input_data_quant, input_scale, input_zero_point,
398 tflite::testing::kAxisShape4D, tflite::testing::kAxisData4D,
399 tflite::testing::kOutputShape4D, tflite::testing::kGoldenData4D,
400 output_data_quant, expected_output_data_quant, output_scale,
401 output_zero_point, ¶ms);
402 }
403
TF_LITE_MICRO_TEST(MeanFloat4DWithoutKeepDims)404 TF_LITE_MICRO_TEST(MeanFloat4DWithoutKeepDims) {
405 const int kOutputShape4D[] = {2, 2, 2};
406 float output_data[tflite::testing::kOutputElements4D];
407 TfLiteReducerParams params = {
408 false // keep_dims
409 };
410
411 tflite::testing::TestMeanFloatInput4D(
412 tflite::testing::kInputShape4D, tflite::testing::kInputData4D,
413 tflite::testing::kAxisShape4D, tflite::testing::kAxisData4D,
414 kOutputShape4D, tflite::testing::kGoldenData4D, output_data, ¶ms);
415 }
416
TF_LITE_MICRO_TEST(MeanInt84DWithoutKeepDims)417 TF_LITE_MICRO_TEST(MeanInt84DWithoutKeepDims) {
418 int8_t expected_output_data_quant[tflite::testing::kOutputElements4D];
419 int8_t output_data_quant[tflite::testing::kOutputElements4D];
420 int8_t input_data_quant[tflite::testing::kInputElements4D];
421
422 const int kOutputShape4D[] = {2, 2, 2};
423 TfLiteReducerParams params = {
424 false // keep_dims
425 };
426 float input_scale = 0.5f;
427 int input_zero_point = 0;
428 float output_scale = 0.5f;
429 int output_zero_point = 0;
430
431 tflite::testing::TestMeanOpQuantized<int8_t>(
432 tflite::testing::kInputShape4D, tflite::testing::kInputData4D,
433 input_data_quant, input_scale, input_zero_point,
434 tflite::testing::kAxisShape4D, tflite::testing::kAxisData4D,
435 kOutputShape4D, tflite::testing::kGoldenData4D, output_data_quant,
436 expected_output_data_quant, output_scale, output_zero_point, ¶ms);
437 }
438
TF_LITE_MICRO_TEST(MeanUInt84DWithoutKeepDims)439 TF_LITE_MICRO_TEST(MeanUInt84DWithoutKeepDims) {
440 uint8_t expected_output_data_quant[tflite::testing::kOutputElements4D];
441 uint8_t output_data_quant[tflite::testing::kOutputElements4D];
442 uint8_t input_data_quant[tflite::testing::kInputElements4D];
443
444 const int kOutputShape4D[] = {2, 2, 2};
445 TfLiteReducerParams params = {
446 false // keep_dims
447 };
448 float input_scale = 0.5f;
449 int input_zero_point = 128;
450 float output_scale = 0.5f;
451 int output_zero_point = 128;
452
453 tflite::testing::TestMeanOpQuantized<uint8_t>(
454 tflite::testing::kInputShape4D, tflite::testing::kInputData4D,
455 input_data_quant, input_scale, input_zero_point,
456 tflite::testing::kAxisShape4D, tflite::testing::kAxisData4D,
457 kOutputShape4D, tflite::testing::kGoldenData4D, output_data_quant,
458 expected_output_data_quant, output_scale, output_zero_point, ¶ms);
459 }
460
TF_LITE_MICRO_TEST(MeanFloat4DWithoutKeepDimsWithPrecision)461 TF_LITE_MICRO_TEST(MeanFloat4DWithoutKeepDimsWithPrecision) {
462 const int kInputShape4D[] = {4, 2, 2, 3, 1};
463 const float kInputData4D[] = {1.0, 24.0, 13.0, 3.0, 9.0, 17.0,
464 11.0, 36.0, 14.0, 19.0, 17.0, 22.0};
465 const int kOutputElements4D = 2;
466 const int kOutputShape4D[] = {2, 2, 1};
467 const float kGoldenData4D[] = {11.166667, 19.833334};
468 float output_data[kOutputElements4D];
469 TfLiteReducerParams params = {
470 false // keep_dims
471 };
472
473 tflite::testing::TestMeanFloatInput4D(
474 kInputShape4D, kInputData4D, tflite::testing::kAxisShape4D,
475 tflite::testing::kAxisData4D, kOutputShape4D, kGoldenData4D, output_data,
476 ¶ms);
477 }
478
TF_LITE_MICRO_TEST(FloatMaxOpTestNotKeepDims)479 TF_LITE_MICRO_TEST(FloatMaxOpTestNotKeepDims) {
480 const int input_shape[] = {3, 4, 3, 2};
481 const float input_data[] = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0,
482 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
483 17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0};
484 const int axis_shape[] = {1, 4};
485 const int32_t axis_data[] = {1, 0, -3, -3};
486 const int output_shape[] = {1, 2};
487 const float expected_output_data[] = {23, 24};
488 float output_data[2];
489
490 TfLiteReducerParams params = {false};
491
492 tflite::testing::TestReduceOpFloat(
493 input_shape, input_data, axis_shape, axis_data, output_shape, output_data,
494 expected_output_data, tflite::ops::micro::Register_REDUCE_MAX(), ¶ms);
495 }
496
TF_LITE_MICRO_TEST(FloatMaxOpTestKeepDims)497 TF_LITE_MICRO_TEST(FloatMaxOpTestKeepDims) {
498 const int input_shape[] = {3, 4, 3, 2};
499 const float input_data[] = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0,
500 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0,
501 17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0};
502 const int axis_shape[] = {1, 2};
503 const int32_t axis_data[] = {0, 2};
504 const int output_shape[] = {1, 3};
505 const float expected_output_data[] = {20, 22, 24};
506 float output_data[3];
507
508 TfLiteReducerParams params = {true};
509
510 tflite::testing::TestReduceOpFloat(
511 input_shape, input_data, axis_shape, axis_data, output_shape, output_data,
512 expected_output_data, tflite::ops::micro::Register_REDUCE_MAX(), ¶ms);
513 }
514
TF_LITE_MICRO_TEST(Int8MaxOpTestKeepDims)515 TF_LITE_MICRO_TEST(Int8MaxOpTestKeepDims) {
516 const int input_shape[] = {3, 1, 3, 2};
517 const float input_data[] = {0.4, 0.2, 0.3, 0.4, 0.5, 0.6};
518 const int axis_shape[] = {1, 1};
519 const int32_t axis_data[] = {1, 1};
520 const int output_shape[] = {1, 2};
521 const float expected_output_data[] = {0.5, 0.6};
522
523 float input_scale = 2 / 255.0;
524 int input_zp = 0;
525
526 TfLiteReducerParams params = {true};
527
528 int8_t input_data_quant[6];
529 int8_t output_data_quant[2];
530 int8_t expected_output_data_quant[2];
531
532 tflite::testing::TestReduceOpQuantized<int8_t>(
533 input_shape, input_data, input_data_quant, input_scale, input_zp,
534 axis_shape, axis_data, output_shape, expected_output_data,
535 output_data_quant, expected_output_data_quant, input_scale, input_zp,
536 tflite::ops::micro::Register_REDUCE_MAX(), ¶ms);
537 }
538
TF_LITE_MICRO_TEST(Int8MaxOpTestWithoutKeepDims)539 TF_LITE_MICRO_TEST(Int8MaxOpTestWithoutKeepDims) {
540 const int input_shape[] = {3, 1, 3, 2};
541 const float input_data[] = {0.4, 0.2, 0.3, 0.4, 0.5, 0.6};
542 const int axis_shape[] = {1, 1};
543 const int32_t axis_data[] = {1, 1};
544 const int output_shape[] = {1, 2};
545 const float expected_output_data[] = {0.5, 0.6};
546
547 float input_scale = 2 / 255.0;
548 int input_zp = 0;
549 float output_scale = 2 / 255.0;
550 int output_zp = 0;
551
552 TfLiteReducerParams params = {false};
553
554 int8_t input_data_quant[6];
555 int8_t output_data_quant[2];
556 int8_t expected_output_data_quant[2];
557
558 tflite::testing::TestReduceOpQuantized<int8_t>(
559 input_shape, input_data, input_data_quant, input_scale, input_zp,
560 axis_shape, axis_data, output_shape, expected_output_data,
561 output_data_quant, expected_output_data_quant, output_scale, output_zp,
562 tflite::ops::micro::Register_REDUCE_MAX(), ¶ms);
563 }
564
TF_LITE_MICRO_TEST(MeanInt84DWithoutKeepDimsWithPrecision)565 TF_LITE_MICRO_TEST(MeanInt84DWithoutKeepDimsWithPrecision) {
566 const int kInputShape4D[] = {4, 2, 2, 3, 1};
567 const float kInputData4D[] = {1.0, 24.0, 13.0, 3.0, 9.0, 17.0,
568 11.0, 36.0, 14.0, 19.0, 17.0, 22.0};
569 const int kOutputShape4D[] = {2, 2, 1};
570 const float kGoldenData4D[] = {11.166667, 19.833334};
571 TfLiteReducerParams params = {
572 false // keep_dims
573 };
574 float input_scale = 0.5f;
575 int input_zero_point = 0;
576 float output_scale = 0.5f;
577 int output_zero_point = 0;
578
579 int8_t output_data_quant[2];
580 int8_t expected_output_data_quant[2];
581 int8_t input_data_quant[12];
582
583 tflite::testing::TestMeanOpQuantized<int8_t>(
584 kInputShape4D, kInputData4D, input_data_quant, input_scale,
585 input_zero_point, tflite::testing::kAxisShape4D,
586 tflite::testing::kAxisData4D, kOutputShape4D, kGoldenData4D,
587 output_data_quant, expected_output_data_quant, output_scale,
588 output_zero_point, ¶ms);
589 }
590
TF_LITE_MICRO_TEST(MeanUInt84DWithoutKeepDimsWithPrecision)591 TF_LITE_MICRO_TEST(MeanUInt84DWithoutKeepDimsWithPrecision) {
592 const int kInputShape4D[] = {4, 2, 2, 3, 1};
593 const float kInputData4D[] = {1.0, 24.0, 13.0, 3.0, 9.0, 17.0,
594 11.0, 36.0, 14.0, 19.0, 17.0, 22.0};
595 const int kOutputShape4D[] = {2, 2, 1};
596 const float kGoldenData4D[] = {11.166667, 19.833334};
597 TfLiteReducerParams params = {
598 false // keep_dims
599 };
600
601 float input_scale = 0.5f;
602 int input_zero_point = 128;
603 float output_scale = 0.5f;
604 int output_zero_point = 128;
605
606 uint8_t output_data_quant[2];
607 uint8_t expected_output_data_quant[2];
608 uint8_t input_data_quant[12];
609
610 tflite::testing::TestMeanOpQuantized<uint8_t>(
611 kInputShape4D, kInputData4D, input_data_quant, input_scale,
612 input_zero_point, tflite::testing::kAxisShape4D,
613 tflite::testing::kAxisData4D, kOutputShape4D, kGoldenData4D,
614 output_data_quant, expected_output_data_quant, output_scale,
615 output_zero_point, ¶ms);
616 }
617 TF_LITE_MICRO_TESTS_END
618