xref: /aosp_15_r20/external/armnn/delegate/test/ComparisonTestHelper.hpp (revision 89c4ff92f2867872bb9e2354d150bf0c8c502810)
1 //
2 // Copyright © 2020, 2023 Arm Ltd and Contributors. All rights reserved.
3 // SPDX-License-Identifier: MIT
4 //
5 
6 #pragma once
7 
8 #include "TestUtils.hpp"
9 
10 #include <armnn_delegate.hpp>
11 #include <DelegateTestInterpreter.hpp>
12 
13 #include <flatbuffers/flatbuffers.h>
14 #include <tensorflow/lite/kernels/register.h>
15 #include <tensorflow/lite/version.h>
16 
17 #include <schema_generated.h>
18 
19 #include <doctest/doctest.h>
20 
21 namespace
22 {
23 
CreateComparisonTfLiteModel(tflite::BuiltinOperator comparisonOperatorCode,tflite::TensorType tensorType,const std::vector<int32_t> & input0TensorShape,const std::vector<int32_t> & input1TensorShape,const std::vector<int32_t> & outputTensorShape,float quantScale=1.0f,int quantOffset=0)24 std::vector<char> CreateComparisonTfLiteModel(tflite::BuiltinOperator comparisonOperatorCode,
25                                               tflite::TensorType tensorType,
26                                               const std::vector <int32_t>& input0TensorShape,
27                                               const std::vector <int32_t>& input1TensorShape,
28                                               const std::vector <int32_t>& outputTensorShape,
29                                               float quantScale = 1.0f,
30                                               int quantOffset  = 0)
31 {
32     using namespace tflite;
33     flatbuffers::FlatBufferBuilder flatBufferBuilder;
34 
35     std::vector<flatbuffers::Offset<tflite::Buffer>> buffers;
36     buffers.push_back(CreateBuffer(flatBufferBuilder));
37     buffers.push_back(CreateBuffer(flatBufferBuilder));
38     buffers.push_back(CreateBuffer(flatBufferBuilder));
39     buffers.push_back(CreateBuffer(flatBufferBuilder));
40 
41     auto quantizationParameters =
42         CreateQuantizationParameters(flatBufferBuilder,
43                                      0,
44                                      0,
45                                      flatBufferBuilder.CreateVector<float>({ quantScale }),
46                                      flatBufferBuilder.CreateVector<int64_t>({ quantOffset }));
47 
48     std::array<flatbuffers::Offset<Tensor>, 3> tensors;
49     tensors[0] = CreateTensor(flatBufferBuilder,
50                               flatBufferBuilder.CreateVector<int32_t>(input0TensorShape.data(),
51                                                                       input0TensorShape.size()),
52                               tensorType,
53                               1,
54                               flatBufferBuilder.CreateString("input_0"),
55                               quantizationParameters);
56     tensors[1] = CreateTensor(flatBufferBuilder,
57                               flatBufferBuilder.CreateVector<int32_t>(input1TensorShape.data(),
58                                                                       input1TensorShape.size()),
59                               tensorType,
60                               2,
61                               flatBufferBuilder.CreateString("input_1"),
62                               quantizationParameters);
63     tensors[2] = CreateTensor(flatBufferBuilder,
64                               flatBufferBuilder.CreateVector<int32_t>(outputTensorShape.data(),
65                                                                       outputTensorShape.size()),
66                               ::tflite::TensorType_BOOL,
67                               3);
68 
69     // create operator
70     tflite::BuiltinOptions operatorBuiltinOptionsType = BuiltinOptions_EqualOptions;;
71     flatbuffers::Offset<void> operatorBuiltinOptions = CreateEqualOptions(flatBufferBuilder).Union();
72     switch (comparisonOperatorCode)
73     {
74         case BuiltinOperator_EQUAL:
75         {
76             operatorBuiltinOptionsType = BuiltinOptions_EqualOptions;
77             operatorBuiltinOptions = CreateEqualOptions(flatBufferBuilder).Union();
78             break;
79         }
80         case BuiltinOperator_NOT_EQUAL:
81         {
82             operatorBuiltinOptionsType = BuiltinOptions_NotEqualOptions;
83             operatorBuiltinOptions = CreateNotEqualOptions(flatBufferBuilder).Union();
84             break;
85         }
86         case BuiltinOperator_GREATER:
87         {
88             operatorBuiltinOptionsType = BuiltinOptions_GreaterOptions;
89             operatorBuiltinOptions = CreateGreaterOptions(flatBufferBuilder).Union();
90             break;
91         }
92         case BuiltinOperator_GREATER_EQUAL:
93         {
94             operatorBuiltinOptionsType = BuiltinOptions_GreaterEqualOptions;
95             operatorBuiltinOptions = CreateGreaterEqualOptions(flatBufferBuilder).Union();
96             break;
97         }
98         case BuiltinOperator_LESS:
99         {
100             operatorBuiltinOptionsType = BuiltinOptions_LessOptions;
101             operatorBuiltinOptions = CreateLessOptions(flatBufferBuilder).Union();
102             break;
103         }
104         case BuiltinOperator_LESS_EQUAL:
105         {
106             operatorBuiltinOptionsType = BuiltinOptions_LessEqualOptions;
107             operatorBuiltinOptions = CreateLessEqualOptions(flatBufferBuilder).Union();
108             break;
109         }
110         default:
111             break;
112     }
113     const std::vector<int32_t> operatorInputs{0, 1};
114     const std::vector<int32_t> operatorOutputs{2};
115     flatbuffers::Offset <Operator> comparisonOperator =
116         CreateOperator(flatBufferBuilder,
117                        0,
118                        flatBufferBuilder.CreateVector<int32_t>(operatorInputs.data(), operatorInputs.size()),
119                        flatBufferBuilder.CreateVector<int32_t>(operatorOutputs.data(), operatorOutputs.size()),
120                        operatorBuiltinOptionsType,
121                        operatorBuiltinOptions);
122 
123     const std::vector<int> subgraphInputs{0, 1};
124     const std::vector<int> subgraphOutputs{2};
125     flatbuffers::Offset <SubGraph> subgraph =
126         CreateSubGraph(flatBufferBuilder,
127                        flatBufferBuilder.CreateVector(tensors.data(), tensors.size()),
128                        flatBufferBuilder.CreateVector<int32_t>(subgraphInputs.data(), subgraphInputs.size()),
129                        flatBufferBuilder.CreateVector<int32_t>(subgraphOutputs.data(), subgraphOutputs.size()),
130                        flatBufferBuilder.CreateVector(&comparisonOperator, 1));
131 
132     flatbuffers::Offset <flatbuffers::String> modelDescription =
133         flatBufferBuilder.CreateString("ArmnnDelegate: Comparison Operator Model");
134     flatbuffers::Offset <OperatorCode> operatorCode = CreateOperatorCode(flatBufferBuilder, comparisonOperatorCode);
135 
136     flatbuffers::Offset <Model> flatbufferModel =
137         CreateModel(flatBufferBuilder,
138                     TFLITE_SCHEMA_VERSION,
139                     flatBufferBuilder.CreateVector(&operatorCode, 1),
140                     flatBufferBuilder.CreateVector(&subgraph, 1),
141                     modelDescription,
142                     flatBufferBuilder.CreateVector(buffers.data(), buffers.size()));
143 
144     flatBufferBuilder.Finish(flatbufferModel, armnnDelegate::FILE_IDENTIFIER);
145 
146     return std::vector<char>(flatBufferBuilder.GetBufferPointer(),
147                              flatBufferBuilder.GetBufferPointer() + flatBufferBuilder.GetSize());
148 }
149 
150 template <typename T>
ComparisonTest(tflite::BuiltinOperator comparisonOperatorCode,tflite::TensorType tensorType,std::vector<armnn::BackendId> & backends,std::vector<int32_t> & input0Shape,std::vector<int32_t> & input1Shape,std::vector<int32_t> & outputShape,std::vector<T> & input0Values,std::vector<T> & input1Values,std::vector<bool> & expectedOutputValues,float quantScale=1.0f,int quantOffset=0)151 void ComparisonTest(tflite::BuiltinOperator comparisonOperatorCode,
152                     tflite::TensorType tensorType,
153                     std::vector<armnn::BackendId>& backends,
154                     std::vector<int32_t>& input0Shape,
155                     std::vector<int32_t>& input1Shape,
156                     std::vector<int32_t>& outputShape,
157                     std::vector<T>& input0Values,
158                     std::vector<T>& input1Values,
159                     std::vector<bool>& expectedOutputValues,
160                     float quantScale = 1.0f,
161                     int quantOffset  = 0)
162 {
163     using namespace delegateTestInterpreter;
164     std::vector<char> modelBuffer = CreateComparisonTfLiteModel(comparisonOperatorCode,
165                                                                 tensorType,
166                                                                 input0Shape,
167                                                                 input1Shape,
168                                                                 outputShape,
169                                                                 quantScale,
170                                                                 quantOffset);
171 
172     // Setup interpreter with just TFLite Runtime.
173     auto tfLiteInterpreter = DelegateTestInterpreter(modelBuffer);
174     CHECK(tfLiteInterpreter.AllocateTensors() == kTfLiteOk);
175     CHECK(tfLiteInterpreter.FillInputTensor<T>(input0Values, 0) == kTfLiteOk);
176     CHECK(tfLiteInterpreter.FillInputTensor<T>(input1Values, 1) == kTfLiteOk);
177     CHECK(tfLiteInterpreter.Invoke() == kTfLiteOk);
178     std::vector<bool>    tfLiteOutputValues = tfLiteInterpreter.GetOutputResult(0);
179     std::vector<int32_t> tfLiteOutputShape  = tfLiteInterpreter.GetOutputShape(0);
180 
181     // Setup interpreter with Arm NN Delegate applied.
182     auto armnnInterpreter = DelegateTestInterpreter(modelBuffer, backends);
183     CHECK(armnnInterpreter.AllocateTensors() == kTfLiteOk);
184     CHECK(armnnInterpreter.FillInputTensor<T>(input0Values, 0) == kTfLiteOk);
185     CHECK(armnnInterpreter.FillInputTensor<T>(input1Values, 1) == kTfLiteOk);
186     CHECK(armnnInterpreter.Invoke() == kTfLiteOk);
187     std::vector<bool>    armnnOutputValues = armnnInterpreter.GetOutputResult(0);
188     std::vector<int32_t> armnnOutputShape  = armnnInterpreter.GetOutputShape(0);
189 
190     armnnDelegate::CompareData(expectedOutputValues, armnnOutputValues, expectedOutputValues.size());
191     armnnDelegate::CompareData(expectedOutputValues, tfLiteOutputValues, expectedOutputValues.size());
192     armnnDelegate::CompareData(tfLiteOutputValues, armnnOutputValues, expectedOutputValues.size());
193 
194     armnnDelegate::CompareOutputShape(tfLiteOutputShape, armnnOutputShape, outputShape);
195 
196     tfLiteInterpreter.Cleanup();
197     armnnInterpreter.Cleanup();
198 }
199 
200 } // anonymous namespace