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
24 template <typename T>
CreateElementwiseBinaryTfLiteModel(tflite::BuiltinOperator binaryOperatorCode,tflite::ActivationFunctionType activationType,tflite::TensorType tensorType,const std::vector<int32_t> & input0TensorShape,const std::vector<int32_t> & input1TensorShape,const std::vector<int32_t> & outputTensorShape,std::vector<T> & input1Values,bool constantInput=false,float quantScale=1.0f,int quantOffset=0)25 std::vector<char> CreateElementwiseBinaryTfLiteModel(tflite::BuiltinOperator binaryOperatorCode,
26 tflite::ActivationFunctionType activationType,
27 tflite::TensorType tensorType,
28 const std::vector <int32_t>& input0TensorShape,
29 const std::vector <int32_t>& input1TensorShape,
30 const std::vector <int32_t>& outputTensorShape,
31 std::vector<T>& input1Values,
32 bool constantInput = false,
33 float quantScale = 1.0f,
34 int quantOffset = 0)
35 {
36 using namespace tflite;
37 flatbuffers::FlatBufferBuilder flatBufferBuilder;
38
39 std::vector<flatbuffers::Offset<tflite::Buffer>> buffers;
40 buffers.push_back(CreateBuffer(flatBufferBuilder));
41 buffers.push_back(CreateBuffer(flatBufferBuilder));
42 if (constantInput)
43 {
44 buffers.push_back(
45 CreateBuffer(flatBufferBuilder,
46 flatBufferBuilder.CreateVector(reinterpret_cast<const uint8_t*>(input1Values.data()),
47 sizeof(T) * input1Values.size())));
48 }
49 else
50 {
51 buffers.push_back(CreateBuffer(flatBufferBuilder));
52 }
53 buffers.push_back(CreateBuffer(flatBufferBuilder));
54
55 auto quantizationParameters =
56 CreateQuantizationParameters(flatBufferBuilder,
57 0,
58 0,
59 flatBufferBuilder.CreateVector<float>({ quantScale }),
60 flatBufferBuilder.CreateVector<int64_t>({ quantOffset }));
61
62
63 std::array<flatbuffers::Offset<Tensor>, 3> tensors;
64 tensors[0] = CreateTensor(flatBufferBuilder,
65 flatBufferBuilder.CreateVector<int32_t>(input0TensorShape.data(),
66 input0TensorShape.size()),
67 tensorType,
68 1,
69 flatBufferBuilder.CreateString("input_0"),
70 quantizationParameters);
71 tensors[1] = CreateTensor(flatBufferBuilder,
72 flatBufferBuilder.CreateVector<int32_t>(input1TensorShape.data(),
73 input1TensorShape.size()),
74 tensorType,
75 2,
76 flatBufferBuilder.CreateString("input_1"),
77 quantizationParameters);
78 tensors[2] = CreateTensor(flatBufferBuilder,
79 flatBufferBuilder.CreateVector<int32_t>(outputTensorShape.data(),
80 outputTensorShape.size()),
81 tensorType,
82 3,
83 flatBufferBuilder.CreateString("output"),
84 quantizationParameters);
85
86 // create operator
87 tflite::BuiltinOptions operatorBuiltinOptionsType = tflite::BuiltinOptions_NONE;
88 flatbuffers::Offset<void> operatorBuiltinOptions = 0;
89 switch (binaryOperatorCode)
90 {
91 case BuiltinOperator_ADD:
92 {
93 operatorBuiltinOptionsType = BuiltinOptions_AddOptions;
94 operatorBuiltinOptions = CreateAddOptions(flatBufferBuilder, activationType).Union();
95 break;
96 }
97 case BuiltinOperator_DIV:
98 {
99 operatorBuiltinOptionsType = BuiltinOptions_DivOptions;
100 operatorBuiltinOptions = CreateDivOptions(flatBufferBuilder, activationType).Union();
101 break;
102 }
103 case BuiltinOperator_MAXIMUM:
104 {
105 operatorBuiltinOptionsType = BuiltinOptions_MaximumMinimumOptions;
106 operatorBuiltinOptions = CreateMaximumMinimumOptions(flatBufferBuilder).Union();
107 break;
108 }
109 case BuiltinOperator_MINIMUM:
110 {
111 operatorBuiltinOptionsType = BuiltinOptions_MaximumMinimumOptions;
112 operatorBuiltinOptions = CreateMaximumMinimumOptions(flatBufferBuilder).Union();
113 break;
114 }
115 case BuiltinOperator_MUL:
116 {
117 operatorBuiltinOptionsType = BuiltinOptions_MulOptions;
118 operatorBuiltinOptions = CreateMulOptions(flatBufferBuilder, activationType).Union();
119 break;
120 }
121 case BuiltinOperator_SUB:
122 {
123 operatorBuiltinOptionsType = BuiltinOptions_SubOptions;
124 operatorBuiltinOptions = CreateSubOptions(flatBufferBuilder, activationType).Union();
125 break;
126 }
127 case BuiltinOperator_FLOOR_DIV:
128 {
129 operatorBuiltinOptionsType = tflite::BuiltinOptions_FloorDivOptions;
130 operatorBuiltinOptions = CreateSubOptions(flatBufferBuilder, activationType).Union();
131 break;
132 }
133 default:
134 break;
135 }
136 const std::vector<int32_t> operatorInputs{0, 1};
137 const std::vector<int32_t> operatorOutputs{2};
138 flatbuffers::Offset <Operator> elementwiseBinaryOperator =
139 CreateOperator(flatBufferBuilder,
140 0,
141 flatBufferBuilder.CreateVector<int32_t>(operatorInputs.data(), operatorInputs.size()),
142 flatBufferBuilder.CreateVector<int32_t>(operatorOutputs.data(), operatorOutputs.size()),
143 operatorBuiltinOptionsType,
144 operatorBuiltinOptions);
145
146 const std::vector<int> subgraphInputs{0, 1};
147 const std::vector<int> subgraphOutputs{2};
148 flatbuffers::Offset <SubGraph> subgraph =
149 CreateSubGraph(flatBufferBuilder,
150 flatBufferBuilder.CreateVector(tensors.data(), tensors.size()),
151 flatBufferBuilder.CreateVector<int32_t>(subgraphInputs.data(), subgraphInputs.size()),
152 flatBufferBuilder.CreateVector<int32_t>(subgraphOutputs.data(), subgraphOutputs.size()),
153 flatBufferBuilder.CreateVector(&elementwiseBinaryOperator, 1));
154
155 flatbuffers::Offset <flatbuffers::String> modelDescription =
156 flatBufferBuilder.CreateString("ArmnnDelegate: Elementwise Binary Operator Model");
157 flatbuffers::Offset <OperatorCode> operatorCode = CreateOperatorCode(flatBufferBuilder, binaryOperatorCode);
158
159 flatbuffers::Offset <Model> flatbufferModel =
160 CreateModel(flatBufferBuilder,
161 TFLITE_SCHEMA_VERSION,
162 flatBufferBuilder.CreateVector(&operatorCode, 1),
163 flatBufferBuilder.CreateVector(&subgraph, 1),
164 modelDescription,
165 flatBufferBuilder.CreateVector(buffers.data(), buffers.size()));
166
167 flatBufferBuilder.Finish(flatbufferModel, armnnDelegate::FILE_IDENTIFIER);
168
169 return std::vector<char>(flatBufferBuilder.GetBufferPointer(),
170 flatBufferBuilder.GetBufferPointer() + flatBufferBuilder.GetSize());
171 }
172
173 template <typename T>
ElementwiseBinaryTest(tflite::BuiltinOperator binaryOperatorCode,tflite::ActivationFunctionType activationType,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<T> & expectedOutputValues,float quantScale=1.0f,int quantOffset=0,bool constantInput=false)174 void ElementwiseBinaryTest(tflite::BuiltinOperator binaryOperatorCode,
175 tflite::ActivationFunctionType activationType,
176 tflite::TensorType tensorType,
177 std::vector<armnn::BackendId>& backends,
178 std::vector<int32_t>& input0Shape,
179 std::vector<int32_t>& input1Shape,
180 std::vector<int32_t>& outputShape,
181 std::vector<T>& input0Values,
182 std::vector<T>& input1Values,
183 std::vector<T>& expectedOutputValues,
184 float quantScale = 1.0f,
185 int quantOffset = 0,
186 bool constantInput = false)
187 {
188 using namespace delegateTestInterpreter;
189 std::vector<char> modelBuffer = CreateElementwiseBinaryTfLiteModel<T>(binaryOperatorCode,
190 activationType,
191 tensorType,
192 input0Shape,
193 input1Shape,
194 outputShape,
195 input1Values,
196 constantInput,
197 quantScale,
198 quantOffset);
199
200 // Setup interpreter with just TFLite Runtime.
201 auto tfLiteInterpreter = DelegateTestInterpreter(modelBuffer);
202 CHECK(tfLiteInterpreter.AllocateTensors() == kTfLiteOk);
203 CHECK(tfLiteInterpreter.FillInputTensor<T>(input0Values, 0) == kTfLiteOk);
204 CHECK(tfLiteInterpreter.FillInputTensor<T>(input1Values, 1) == kTfLiteOk);
205 CHECK(tfLiteInterpreter.Invoke() == kTfLiteOk);
206 std::vector<T> tfLiteOutputValues = tfLiteInterpreter.GetOutputResult<T>(0);
207 std::vector<int32_t> tfLiteOutputShape = tfLiteInterpreter.GetOutputShape(0);
208
209 // Setup interpreter with Arm NN Delegate applied.
210 auto armnnInterpreter = DelegateTestInterpreter(modelBuffer, backends);
211 CHECK(armnnInterpreter.AllocateTensors() == kTfLiteOk);
212 CHECK(armnnInterpreter.FillInputTensor<T>(input0Values, 0) == kTfLiteOk);
213 CHECK(armnnInterpreter.FillInputTensor<T>(input1Values, 1) == kTfLiteOk);
214 CHECK(armnnInterpreter.Invoke() == kTfLiteOk);
215 std::vector<T> armnnOutputValues = armnnInterpreter.GetOutputResult<T>(0);
216 std::vector<int32_t> armnnOutputShape = armnnInterpreter.GetOutputShape(0);
217
218 armnnDelegate::CompareOutputData<T>(tfLiteOutputValues, armnnOutputValues, expectedOutputValues);
219 armnnDelegate::CompareOutputShape(tfLiteOutputShape, armnnOutputShape, outputShape);
220
221 tfLiteInterpreter.Cleanup();
222 armnnInterpreter.Cleanup();
223 }
224
225 } // anonymous namespace