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
CreateQuantizationTfLiteModel(tflite::BuiltinOperator quantizationOperatorCode,tflite::TensorType inputTensorType,tflite::TensorType outputTensorType,const std::vector<int32_t> & inputTensorShape,const std::vector<int32_t> & outputTensorShape,float quantScale=1.0f,int quantOffset=0)24 std::vector<char> CreateQuantizationTfLiteModel(tflite::BuiltinOperator quantizationOperatorCode,
25 tflite::TensorType inputTensorType,
26 tflite::TensorType outputTensorType,
27 const std::vector <int32_t>& inputTensorShape,
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
40
41 auto quantizationParameters =
42 CreateQuantizationParameters(flatBufferBuilder,
43 0,
44 0,
45 flatBufferBuilder.CreateVector<float>({ quantScale }),
46 flatBufferBuilder.CreateVector<int64_t>({ quantOffset }),
47 QuantizationDetails_CustomQuantization);
48
49 std::array<flatbuffers::Offset<Tensor>, 2> tensors;
50 tensors[0] = CreateTensor(flatBufferBuilder,
51 flatBufferBuilder.CreateVector<int32_t>(inputTensorShape.data(),
52 inputTensorShape.size()),
53 inputTensorType,
54 1,
55 flatBufferBuilder.CreateString("input"),
56 quantizationParameters);
57 tensors[1] = CreateTensor(flatBufferBuilder,
58 flatBufferBuilder.CreateVector<int32_t>(outputTensorShape.data(),
59 outputTensorShape.size()),
60 outputTensorType,
61 2,
62 flatBufferBuilder.CreateString("output"),
63 quantizationParameters);
64
65 // create operator
66 tflite::BuiltinOptions operatorBuiltinOptionsType = tflite::BuiltinOptions_NONE;
67 flatbuffers::Offset<void> operatorBuiltinOptions = 0;
68 switch (quantizationOperatorCode)
69 {
70 case BuiltinOperator_QUANTIZE:
71 {
72 operatorBuiltinOptionsType = BuiltinOptions_QuantizeOptions;
73 operatorBuiltinOptions = CreateQuantizeOptions(flatBufferBuilder).Union();
74 break;
75 }
76 case BuiltinOperator_DEQUANTIZE:
77 {
78 operatorBuiltinOptionsType = BuiltinOptions_DequantizeOptions;
79 operatorBuiltinOptions = CreateDequantizeOptions(flatBufferBuilder).Union();
80 break;
81 }
82 default:
83 break;
84 }
85
86 const std::vector<int32_t> operatorInputs{0};
87 const std::vector<int32_t> operatorOutputs{1};
88 flatbuffers::Offset <Operator> quantizationOperator =
89 CreateOperator(flatBufferBuilder,
90 0,
91 flatBufferBuilder.CreateVector<int32_t>(operatorInputs.data(), operatorInputs.size()),
92 flatBufferBuilder.CreateVector<int32_t>(operatorOutputs.data(), operatorOutputs.size()),
93 operatorBuiltinOptionsType,
94 operatorBuiltinOptions);
95
96 const std::vector<int> subgraphInputs{0};
97 const std::vector<int> subgraphOutputs{1};
98 flatbuffers::Offset <SubGraph> subgraph =
99 CreateSubGraph(flatBufferBuilder,
100 flatBufferBuilder.CreateVector(tensors.data(), tensors.size()),
101 flatBufferBuilder.CreateVector<int32_t>(subgraphInputs.data(), subgraphInputs.size()),
102 flatBufferBuilder.CreateVector<int32_t>(subgraphOutputs.data(), subgraphOutputs.size()),
103 flatBufferBuilder.CreateVector(&quantizationOperator, 1));
104
105 flatbuffers::Offset <flatbuffers::String> modelDescription =
106 flatBufferBuilder.CreateString("ArmnnDelegate: Quantization Operator Model");
107 flatbuffers::Offset <OperatorCode> operatorCode = CreateOperatorCode(flatBufferBuilder, quantizationOperatorCode);
108
109 flatbuffers::Offset <Model> flatbufferModel =
110 CreateModel(flatBufferBuilder,
111 TFLITE_SCHEMA_VERSION,
112 flatBufferBuilder.CreateVector(&operatorCode, 1),
113 flatBufferBuilder.CreateVector(&subgraph, 1),
114 modelDescription,
115 flatBufferBuilder.CreateVector(buffers.data(), buffers.size()));
116
117 flatBufferBuilder.Finish(flatbufferModel, armnnDelegate::FILE_IDENTIFIER);
118
119 return std::vector<char>(flatBufferBuilder.GetBufferPointer(),
120 flatBufferBuilder.GetBufferPointer() + flatBufferBuilder.GetSize());
121 }
122
123 template <typename InputT, typename OutputT>
QuantizationTest(tflite::BuiltinOperator quantizeOperatorCode,tflite::TensorType inputTensorType,tflite::TensorType outputTensorType,std::vector<armnn::BackendId> & backends,std::vector<int32_t> & inputShape,std::vector<int32_t> & outputShape,std::vector<InputT> & inputValues,std::vector<OutputT> & expectedOutputValues,float quantScale=1.0f,int quantOffset=0)124 void QuantizationTest(tflite::BuiltinOperator quantizeOperatorCode,
125 tflite::TensorType inputTensorType,
126 tflite::TensorType outputTensorType,
127 std::vector<armnn::BackendId>& backends,
128 std::vector<int32_t>& inputShape,
129 std::vector<int32_t>& outputShape,
130 std::vector<InputT>& inputValues,
131 std::vector<OutputT>& expectedOutputValues,
132 float quantScale = 1.0f,
133 int quantOffset = 0)
134 {
135 using namespace delegateTestInterpreter;
136 std::vector<char> modelBuffer = CreateQuantizationTfLiteModel(quantizeOperatorCode,
137 inputTensorType,
138 outputTensorType,
139 inputShape,
140 outputShape,
141 quantScale,
142 quantOffset);
143
144 // Setup interpreter with just TFLite Runtime.
145 auto tfLiteInterpreter = DelegateTestInterpreter(modelBuffer);
146 CHECK(tfLiteInterpreter.AllocateTensors() == kTfLiteOk);
147 CHECK(tfLiteInterpreter.FillInputTensor(inputValues, 0) == kTfLiteOk);
148 CHECK(tfLiteInterpreter.Invoke() == kTfLiteOk);
149 std::vector<OutputT> tfLiteOutputValues = tfLiteInterpreter.GetOutputResult<OutputT>(0);
150 std::vector<int32_t> tfLiteOutputShape = tfLiteInterpreter.GetOutputShape(0);
151
152 // Setup interpreter with Arm NN Delegate applied.
153 auto armnnInterpreter = DelegateTestInterpreter(modelBuffer, backends);
154 CHECK(armnnInterpreter.AllocateTensors() == kTfLiteOk);
155 CHECK(armnnInterpreter.FillInputTensor(inputValues, 0) == kTfLiteOk);
156 CHECK(armnnInterpreter.Invoke() == kTfLiteOk);
157 std::vector<OutputT> armnnOutputValues = armnnInterpreter.GetOutputResult<OutputT>(0);
158 std::vector<int32_t> armnnOutputShape = armnnInterpreter.GetOutputShape(0);
159
160 armnnDelegate::CompareOutputData<OutputT>(tfLiteOutputValues, armnnOutputValues, expectedOutputValues);
161 armnnDelegate::CompareOutputShape(tfLiteOutputShape, armnnOutputShape, outputShape);
162
163 tfLiteInterpreter.Cleanup();
164 armnnInterpreter.Cleanup();
165 }
166
167 } // anonymous namespace