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/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
TestZerosLikeFloat(const int * input_dims_data,const float * input_data,const float * expected_output_data,float * output_data)27 void TestZerosLikeFloat(const int* input_dims_data, const float* input_data,
28 const float* expected_output_data, float* output_data) {
29 TfLiteIntArray* input_dims = IntArrayFromInts(input_dims_data);
30 TfLiteIntArray* output_dims = IntArrayFromInts(input_dims_data);
31 const int output_dims_count = ElementCount(*output_dims);
32 constexpr int inputs_size = 1;
33 constexpr int outputs_size = 1;
34 constexpr int tensors_size = inputs_size + outputs_size;
35 TfLiteTensor tensors[tensors_size] = {
36 CreateTensor(input_data, input_dims),
37 CreateTensor(output_data, output_dims),
38 };
39
40 int inputs_array_data[] = {1, 0};
41 TfLiteIntArray* inputs_array = IntArrayFromInts(inputs_array_data);
42 int outputs_array_data[] = {1, 1};
43 TfLiteIntArray* outputs_array = IntArrayFromInts(outputs_array_data);
44
45 const TfLiteRegistration registration = Register_ZEROS_LIKE();
46 micro::KernelRunner runner(registration, tensors, tensors_size, inputs_array,
47 outputs_array,
48 /*builtin_data=*/nullptr);
49
50 TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.InitAndPrepare());
51 TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.Invoke());
52
53 for (int i = 0; i < output_dims_count; ++i) {
54 TF_LITE_MICRO_EXPECT_EQ(expected_output_data[i], output_data[i]);
55 }
56 }
57
TestZerosLikeInt32(const int * input_dims_data,const int32_t * input_data,const int32_t * expected_output_data,int32_t * output_data)58 void TestZerosLikeInt32(const int* input_dims_data, const int32_t* input_data,
59 const int32_t* expected_output_data,
60 int32_t* output_data) {
61 TfLiteIntArray* input_dims = IntArrayFromInts(input_dims_data);
62 TfLiteIntArray* output_dims = IntArrayFromInts(input_dims_data);
63 const int output_dims_count = ElementCount(*output_dims);
64 constexpr int inputs_size = 1;
65 constexpr int outputs_size = 1;
66 constexpr int tensors_size = inputs_size + outputs_size;
67 TfLiteTensor tensors[tensors_size] = {
68 CreateTensor(input_data, input_dims),
69 CreateTensor(output_data, output_dims),
70 };
71
72 int inputs_array_data[] = {1, 0};
73 TfLiteIntArray* inputs_array = IntArrayFromInts(inputs_array_data);
74 int outputs_array_data[] = {1, 1};
75 TfLiteIntArray* outputs_array = IntArrayFromInts(outputs_array_data);
76
77 const TfLiteRegistration registration = Register_ZEROS_LIKE();
78 micro::KernelRunner runner(registration, tensors, tensors_size, inputs_array,
79 outputs_array,
80 /*builtin_data=*/nullptr);
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_dims_count; ++i) {
86 TF_LITE_MICRO_EXPECT_EQ(expected_output_data[i], output_data[i]);
87 }
88 }
89
TestZerosLikeInt64(const int * input_dims_data,const int64_t * input_data,const int64_t * expected_output_data,int64_t * output_data)90 void TestZerosLikeInt64(const int* input_dims_data, const int64_t* input_data,
91 const int64_t* expected_output_data,
92 int64_t* output_data) {
93 TfLiteIntArray* input_dims = IntArrayFromInts(input_dims_data);
94 TfLiteIntArray* output_dims = IntArrayFromInts(input_dims_data);
95 const int output_dims_count = ElementCount(*output_dims);
96 constexpr int inputs_size = 1;
97 constexpr int outputs_size = 1;
98 constexpr int tensors_size = inputs_size + outputs_size;
99 TfLiteTensor tensors[tensors_size] = {
100 CreateTensor(input_data, input_dims),
101 CreateTensor(output_data, output_dims),
102 };
103
104 int inputs_array_data[] = {1, 0};
105 TfLiteIntArray* inputs_array = IntArrayFromInts(inputs_array_data);
106 int outputs_array_data[] = {1, 1};
107 TfLiteIntArray* outputs_array = IntArrayFromInts(outputs_array_data);
108
109 const TfLiteRegistration registration = Register_ZEROS_LIKE();
110 micro::KernelRunner runner(registration, tensors, tensors_size, inputs_array,
111 outputs_array,
112 /*builtin_data=*/nullptr);
113
114 TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.InitAndPrepare());
115 TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.Invoke());
116
117 for (int i = 0; i < output_dims_count; ++i) {
118 TF_LITE_MICRO_EXPECT_EQ(expected_output_data[i], output_data[i]);
119 }
120 }
121
122 } // namespace
123 } // namespace testing
124 } // namespace tflite
125
126 TF_LITE_MICRO_TESTS_BEGIN
127
TF_LITE_MICRO_TEST(TestZerosLikeFloat)128 TF_LITE_MICRO_TEST(TestZerosLikeFloat) {
129 float output_data[6];
130 const int input_dims[] = {2, 2, 3};
131 const float input_values[] = {-2.0, -1.0, 0.0, 1.0, 2.0, 3.0};
132 const float golden[] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
133 tflite::testing::TestZerosLikeFloat(input_dims, input_values, golden,
134 output_data);
135 }
136
TF_LITE_MICRO_TEST(TestZerosLikeInt32)137 TF_LITE_MICRO_TEST(TestZerosLikeInt32) {
138 int32_t output_data[4];
139 const int input_dims[] = {4, 1, 2, 2, 1};
140 const int32_t input_values[] = {-2, -1, 0, 3};
141 const int32_t golden[] = {0, 0, 0, 0};
142 tflite::testing::TestZerosLikeInt32(input_dims, input_values, golden,
143 output_data);
144 }
145
TF_LITE_MICRO_TEST(TestZerosLikeInt64)146 TF_LITE_MICRO_TEST(TestZerosLikeInt64) {
147 int64_t output_data[4];
148 const int input_dims[] = {4, 1, 2, 2, 1};
149 const int64_t input_values[] = {-2, -1, 0, 3};
150 const int64_t golden[] = {0, 0, 0, 0};
151 tflite::testing::TestZerosLikeInt64(input_dims, input_values, golden,
152 output_data);
153 }
154
155 TF_LITE_MICRO_TESTS_END
156