1 //
2 // Copyright © 2020 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
12 #include <flatbuffers/flatbuffers.h>
13 #include <tensorflow/lite/interpreter.h>
14 #include <tensorflow/lite/kernels/register.h>
15 #include <tensorflow/lite/model.h>
16 #include <tensorflow/lite/schema/schema_generated.h>
17 #include <tensorflow/lite/version.h>
18
19 #include <doctest/doctest.h>
20
21 namespace
22 {
23
CreateResizeTfLiteModel(tflite::BuiltinOperator operatorCode,tflite::TensorType inputTensorType,const std::vector<int32_t> & inputTensorShape,const std::vector<int32_t> & sizeTensorData,const std::vector<int32_t> & sizeTensorShape,const std::vector<int32_t> & outputTensorShape)24 std::vector<char> CreateResizeTfLiteModel(tflite::BuiltinOperator operatorCode,
25 tflite::TensorType inputTensorType,
26 const std::vector <int32_t>& inputTensorShape,
27 const std::vector <int32_t>& sizeTensorData,
28 const std::vector <int32_t>& sizeTensorShape,
29 const std::vector <int32_t>& outputTensorShape)
30 {
31 using namespace tflite;
32 flatbuffers::FlatBufferBuilder flatBufferBuilder;
33
34 std::vector<flatbuffers::Offset<tflite::Buffer>> buffers;
35 buffers.push_back(CreateBuffer(flatBufferBuilder, flatBufferBuilder.CreateVector({})));
36 buffers.push_back(CreateBuffer(flatBufferBuilder,
37 flatBufferBuilder.CreateVector(
38 reinterpret_cast<const uint8_t*>(sizeTensorData.data()),
39 sizeof(int32_t) * sizeTensorData.size())));
40
41 std::array<flatbuffers::Offset<Tensor>, 3> tensors;
42 tensors[0] = CreateTensor(flatBufferBuilder,
43 flatBufferBuilder.CreateVector<int32_t>(inputTensorShape.data(), inputTensorShape.size()),
44 inputTensorType,
45 0,
46 flatBufferBuilder.CreateString("input_tensor"));
47
48 tensors[1] = CreateTensor(flatBufferBuilder,
49 flatBufferBuilder.CreateVector<int32_t>(sizeTensorShape.data(),
50 sizeTensorShape.size()),
51 TensorType_INT32,
52 1,
53 flatBufferBuilder.CreateString("size_input_tensor"));
54
55 tensors[2] = CreateTensor(flatBufferBuilder,
56 flatBufferBuilder.CreateVector<int32_t>(outputTensorShape.data(),
57 outputTensorShape.size()),
58 inputTensorType,
59 0,
60 flatBufferBuilder.CreateString("output_tensor"));
61
62 // Create Operator
63 tflite::BuiltinOptions operatorBuiltinOptionsType = tflite::BuiltinOptions_NONE;
64 flatbuffers::Offset<void> operatorBuiltinOption = 0;
65 switch (operatorCode)
66 {
67 case BuiltinOperator_RESIZE_BILINEAR:
68 {
69 operatorBuiltinOption = CreateResizeBilinearOptions(flatBufferBuilder, false, false).Union();
70 operatorBuiltinOptionsType = tflite::BuiltinOptions_ResizeBilinearOptions;
71 break;
72 }
73 case BuiltinOperator_RESIZE_NEAREST_NEIGHBOR:
74 {
75 operatorBuiltinOption = CreateResizeNearestNeighborOptions(flatBufferBuilder, false, false).Union();
76 operatorBuiltinOptionsType = tflite::BuiltinOptions_ResizeNearestNeighborOptions;
77 break;
78 }
79 default:
80 break;
81 }
82
83 const std::vector<int> operatorInputs{{0, 1}};
84 const std::vector<int> operatorOutputs{{2}};
85 flatbuffers::Offset <Operator> resizeOperator =
86 CreateOperator(flatBufferBuilder,
87 0,
88 flatBufferBuilder.CreateVector<int32_t>(operatorInputs.data(), operatorInputs.size()),
89 flatBufferBuilder.CreateVector<int32_t>(operatorOutputs.data(), operatorOutputs.size()),
90 operatorBuiltinOptionsType,
91 operatorBuiltinOption);
92
93 const std::vector<int> subgraphInputs{{0, 1}};
94 const std::vector<int> subgraphOutputs{{2}};
95 flatbuffers::Offset <SubGraph> subgraph =
96 CreateSubGraph(flatBufferBuilder,
97 flatBufferBuilder.CreateVector(tensors.data(), tensors.size()),
98 flatBufferBuilder.CreateVector<int32_t>(subgraphInputs.data(), subgraphInputs.size()),
99 flatBufferBuilder.CreateVector<int32_t>(subgraphOutputs.data(), subgraphOutputs.size()),
100 flatBufferBuilder.CreateVector(&resizeOperator, 1));
101
102 flatbuffers::Offset <flatbuffers::String> modelDescription =
103 flatBufferBuilder.CreateString("ArmnnDelegate: Resize Biliniar Operator Model");
104 flatbuffers::Offset <OperatorCode> opCode = CreateOperatorCode(flatBufferBuilder, operatorCode);
105
106 flatbuffers::Offset <Model> flatbufferModel =
107 CreateModel(flatBufferBuilder,
108 TFLITE_SCHEMA_VERSION,
109 flatBufferBuilder.CreateVector(&opCode, 1),
110 flatBufferBuilder.CreateVector(&subgraph, 1),
111 modelDescription,
112 flatBufferBuilder.CreateVector(buffers.data(), buffers.size()));
113
114 flatBufferBuilder.Finish(flatbufferModel);
115
116 return std::vector<char>(flatBufferBuilder.GetBufferPointer(),
117 flatBufferBuilder.GetBufferPointer() + flatBufferBuilder.GetSize());
118 }
119
ResizeFP32TestImpl(tflite::BuiltinOperator operatorCode,std::vector<armnn::BackendId> & backends,std::vector<float> & input1Values,std::vector<int32_t> input1Shape,std::vector<int32_t> input2NewShape,std::vector<int32_t> input2Shape,std::vector<float> & expectedOutputValues,std::vector<int32_t> expectedOutputShape)120 void ResizeFP32TestImpl(tflite::BuiltinOperator operatorCode,
121 std::vector<armnn::BackendId>& backends,
122 std::vector<float>& input1Values,
123 std::vector<int32_t> input1Shape,
124 std::vector<int32_t> input2NewShape,
125 std::vector<int32_t> input2Shape,
126 std::vector<float>& expectedOutputValues,
127 std::vector<int32_t> expectedOutputShape)
128 {
129 using namespace tflite;
130
131 std::vector<char> modelBuffer = CreateResizeTfLiteModel(operatorCode,
132 ::tflite::TensorType_FLOAT32,
133 input1Shape,
134 input2NewShape,
135 input2Shape,
136 expectedOutputShape);
137
138 const Model* tfLiteModel = GetModel(modelBuffer.data());
139
140 // The model will be executed using tflite and using the armnn delegate so that the outputs
141 // can be compared.
142
143 // Create TfLite Interpreter with armnn delegate
144 std::unique_ptr<Interpreter> armnnDelegateInterpreter;
145 CHECK(InterpreterBuilder(tfLiteModel, ::tflite::ops::builtin::BuiltinOpResolver())
146 (&armnnDelegateInterpreter) == kTfLiteOk);
147 CHECK(armnnDelegateInterpreter != nullptr);
148 CHECK(armnnDelegateInterpreter->AllocateTensors() == kTfLiteOk);
149
150 // Create TfLite Interpreter without armnn delegate
151 std::unique_ptr<Interpreter> tfLiteInterpreter;
152 CHECK(InterpreterBuilder(tfLiteModel, ::tflite::ops::builtin::BuiltinOpResolver())
153 (&tfLiteInterpreter) == kTfLiteOk);
154 CHECK(tfLiteInterpreter != nullptr);
155 CHECK(tfLiteInterpreter->AllocateTensors() == kTfLiteOk);
156
157 // Create the ArmNN Delegate
158 armnnDelegate::DelegateOptions delegateOptions(backends);
159 std::unique_ptr<TfLiteDelegate, decltype(&armnnDelegate::TfLiteArmnnDelegateDelete)>
160 theArmnnDelegate(armnnDelegate::TfLiteArmnnDelegateCreate(delegateOptions),
161 armnnDelegate::TfLiteArmnnDelegateDelete);
162 CHECK(theArmnnDelegate != nullptr);
163 // Modify armnnDelegateInterpreter to use armnnDelegate
164 CHECK(armnnDelegateInterpreter->ModifyGraphWithDelegate(theArmnnDelegate.get()) == kTfLiteOk);
165
166 // Set input data for the armnn interpreter
167 armnnDelegate::FillInput(armnnDelegateInterpreter, 0, input1Values);
168 armnnDelegate::FillInput(armnnDelegateInterpreter, 1, input2NewShape);
169
170 // Set input data for the tflite interpreter
171 armnnDelegate::FillInput(tfLiteInterpreter, 0, input1Values);
172 armnnDelegate::FillInput(tfLiteInterpreter, 1, input2NewShape);
173
174 // Run EnqueWorkload
175 CHECK(armnnDelegateInterpreter->Invoke() == kTfLiteOk);
176 CHECK(tfLiteInterpreter->Invoke() == kTfLiteOk);
177
178 // Compare output data
179 auto tfLiteDelegateOutputId = tfLiteInterpreter->outputs()[0];
180 auto tfLiteDelageOutputData = tfLiteInterpreter->typed_tensor<float>(tfLiteDelegateOutputId);
181 auto armnnDelegateOutputId = armnnDelegateInterpreter->outputs()[0];
182 auto armnnDelegateOutputData = armnnDelegateInterpreter->typed_tensor<float>(armnnDelegateOutputId);
183 for (size_t i = 0; i < expectedOutputValues.size(); i++)
184 {
185 CHECK(expectedOutputValues[i] == doctest::Approx(armnnDelegateOutputData[i]));
186 CHECK(armnnDelegateOutputData[i] == doctest::Approx(tfLiteDelageOutputData[i]));
187 }
188
189 armnnDelegateInterpreter.reset(nullptr);
190 }
191
192 } // anonymous namespace