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
TestCastFloatToInt8(const int * input_dims_data,const float * input_data,const int8_t * expected_output_data,int8_t * output_data)27 void TestCastFloatToInt8(const int* input_dims_data, const float* input_data,
28 const int8_t* expected_output_data,
29 int8_t* output_data) {
30 TfLiteIntArray* input_dims = IntArrayFromInts(input_dims_data);
31 TfLiteIntArray* output_dims = IntArrayFromInts(input_dims_data);
32 const int output_dims_count = ElementCount(*output_dims);
33 constexpr int inputs_size = 1;
34 constexpr int outputs_size = 1;
35 constexpr int tensors_size = inputs_size + outputs_size;
36 TfLiteTensor tensors[tensors_size] = {
37 CreateTensor(input_data, input_dims),
38 CreateTensor(output_data, output_dims),
39 };
40
41 int inputs_array_data[] = {1, 0};
42 TfLiteIntArray* inputs_array = IntArrayFromInts(inputs_array_data);
43 int outputs_array_data[] = {1, 1};
44 TfLiteIntArray* outputs_array = IntArrayFromInts(outputs_array_data);
45
46 const TfLiteRegistration registration = Register_CAST();
47 micro::KernelRunner runner(registration, tensors, tensors_size, inputs_array,
48 outputs_array,
49 /*builtin_data=*/nullptr);
50
51 TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.InitAndPrepare());
52 TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.Invoke());
53
54 for (int i = 0; i < output_dims_count; ++i) {
55 TF_LITE_MICRO_EXPECT_EQ(expected_output_data[i], output_data[i]);
56 }
57 }
58
TestCastInt8ToFloat(const int * input_dims_data,const int8_t * input_data,const float * expected_output_data,float * output_data)59 void TestCastInt8ToFloat(const int* input_dims_data, const int8_t* input_data,
60 const float* expected_output_data,
61 float* output_data) {
62 TfLiteIntArray* input_dims = IntArrayFromInts(input_dims_data);
63 TfLiteIntArray* output_dims = IntArrayFromInts(input_dims_data);
64 const int output_dims_count = ElementCount(*output_dims);
65 constexpr int inputs_size = 1;
66 constexpr int outputs_size = 1;
67 constexpr int tensors_size = inputs_size + outputs_size;
68 TfLiteTensor tensors[tensors_size] = {
69 CreateTensor(input_data, input_dims),
70 CreateTensor(output_data, output_dims),
71 };
72
73 int inputs_array_data[] = {1, 0};
74 TfLiteIntArray* inputs_array = IntArrayFromInts(inputs_array_data);
75 int outputs_array_data[] = {1, 1};
76 TfLiteIntArray* outputs_array = IntArrayFromInts(outputs_array_data);
77
78 const TfLiteRegistration registration = Register_CAST();
79 micro::KernelRunner runner(registration, tensors, tensors_size, inputs_array,
80 outputs_array,
81 /*builtin_data=*/nullptr);
82
83 TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.InitAndPrepare());
84 TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.Invoke());
85
86 for (int i = 0; i < output_dims_count; ++i) {
87 TF_LITE_MICRO_EXPECT_EQ(expected_output_data[i], output_data[i]);
88 }
89 }
90
91 } // namespace
92 } // namespace testing
93 } // namespace tflite
94
95 TF_LITE_MICRO_TESTS_BEGIN
96
TF_LITE_MICRO_TEST(CastFloatToInt8)97 TF_LITE_MICRO_TEST(CastFloatToInt8) {
98 int8_t output_data[6];
99 const int input_dims[] = {2, 3, 2};
100
101 // TODO(b/178391195): Test negative and out-of-range numbers.
102 const float input_values[] = {100.f, 1.0f, 0.f, 0.4f, 1.999f, 1.1f};
103 const int8_t golden[] = {100, 1, 0, 0, 1, 1};
104 tflite::testing::TestCastFloatToInt8(input_dims, input_values, golden,
105 output_data);
106 }
107
TF_LITE_MICRO_TEST(CastInt8ToFloat)108 TF_LITE_MICRO_TEST(CastInt8ToFloat) {
109 float output_data[6];
110 const int input_dims[] = {2, 3, 2};
111 const int8_t input_values[] = {123, 0, 1, 2, 3, 4};
112 const float golden[] = {123.f, 0.f, 1.f, 2.f, 3.f, 4.f};
113 tflite::testing::TestCastInt8ToFloat(input_dims, input_values, golden,
114 output_data);
115 }
116
117 TF_LITE_MICRO_TESTS_END
118