Imported Upstream version 1.18.0
[platform/core/ml/nnfw.git] / tests / nnfw_api / src / CircleGen.h
1 /*
2  * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 #ifndef __NNFW_API_TEST_CIRCLE_GEN_H__
18 #define __NNFW_API_TEST_CIRCLE_GEN_H__
19
20 #include <circle_schema_generated.h>
21
22 #include <vector>
23
24 /**
25  * @brief Class for storing flatbuffer buffer
26  *
27  * This is a simple wrapper for a finished FlatBufferBuilder. It owns the buffer and a user can
28  * get the buffer pointer and size.
29  */
30 class CircleBuffer
31 {
32 public:
33   CircleBuffer() = default;
34   explicit CircleBuffer(flatbuffers::FlatBufferBuilder &&fbb) : _fbb{std::move(fbb)}
35   {
36     _fbb.Finished(); // The build must have been finished, so check that here
37   }
38
39   uint8_t *buffer() const { return _fbb.GetBufferPointer(); }
40   size_t size() const { return _fbb.GetSize(); }
41
42 private:
43   flatbuffers::FlatBufferBuilder _fbb;
44 };
45
46 /**
47  * @brief Circle flatbuffer file generator
48  *
49  * This is a helper class for generating circle file.
50  *
51  */
52 class CircleGen
53 {
54 public:
55   using Shape = std::vector<int32_t>;
56
57   using SparseIndexVectorType = circle::SparseIndexVector;
58   using SparseDimensionType = circle::DimensionType;
59
60   struct SparseIndexVector
61   {
62     std::vector<uint16_t> u16;
63   };
64
65   struct DimMetaData
66   {
67     DimMetaData() = delete;
68     DimMetaData(SparseDimensionType format, std::vector<uint16_t> array_segments,
69                 std::vector<uint16_t> array_indices)
70       : _format{format},
71         _array_segments_type(SparseIndexVectorType::SparseIndexVector_Uint16Vector),
72         _array_indices_type(SparseIndexVectorType::SparseIndexVector_Uint16Vector)
73     {
74       _array_segments.u16 = array_segments;
75       _array_indices.u16 = array_indices;
76     }
77     DimMetaData(SparseDimensionType format, int32_t dense_size)
78       : _format{format}, _dense_size{dense_size}
79     {
80     }
81     SparseDimensionType _format{circle::DimensionType_DENSE};
82     int32_t _dense_size{0};
83     SparseIndexVectorType _array_segments_type{circle::SparseIndexVector_NONE};
84     SparseIndexVector _array_segments;
85     SparseIndexVectorType _array_indices_type{circle::SparseIndexVector_NONE};
86     SparseIndexVector _array_indices;
87   };
88
89   struct SparsityParams
90   {
91     std::vector<int32_t> traversal_order;
92     std::vector<int32_t> block_map;
93     std::vector<DimMetaData> dim_metadata;
94   };
95
96   struct TensorParams
97   {
98     std::vector<int32_t> shape;
99     circle::TensorType tensor_type = circle::TensorType::TensorType_FLOAT32;
100     uint32_t buffer = 0;
101     std::string name;
102   };
103
104   struct OperatorParams
105   {
106     std::vector<int32_t> inputs;
107     std::vector<int32_t> outputs;
108     int version = 1;
109   };
110
111   struct SubgraphContext
112   {
113     std::vector<int> inputs;
114     std::vector<int> outputs;
115     std::vector<flatbuffers::Offset<circle::Tensor>> tensors;
116     std::vector<flatbuffers::Offset<circle::Operator>> operators;
117   };
118
119 public:
120   CircleGen();
121
122   template <typename T> uint32_t addBuffer(const std::vector<T> &buf_vec)
123   {
124     auto buf = reinterpret_cast<const uint8_t *>(buf_vec.data());
125     auto size = buf_vec.size() * sizeof(T);
126     return addBuffer(buf, size);
127   }
128   uint32_t addBuffer(const uint8_t *buf, size_t size);
129   uint32_t addTensor(const TensorParams &params);
130   uint32_t addTensor(const TensorParams &params, float scale, int64_t zero_point);
131   uint32_t addTensor(const TensorParams &params, std::vector<float> &scale,
132                      std::vector<int64_t> &zero_point);
133   uint32_t addTensor(const TensorParams &params, const SparsityParams &sp);
134   void setInputsAndOutputs(const std::vector<int> &inputs, const std::vector<int> &outputs);
135   uint32_t nextSubgraph();
136   CircleBuffer finish();
137
138   // ===== Add Operator methods begin (SORTED IN ALPHABETICAL ORDER) =====
139
140   uint32_t addOperatorAdd(const OperatorParams &params, circle::ActivationFunctionType actfn);
141   uint32_t addOperatorAddN(const OperatorParams &params);
142   uint32_t addOperatorArgMax(const OperatorParams &params,
143                              circle::TensorType output_type = circle::TensorType::TensorType_INT32);
144   uint32_t addOperatorArgMin(const OperatorParams &params,
145                              circle::TensorType output_type = circle::TensorType::TensorType_INT32);
146   uint32_t addOperatorAveragePool2D(const OperatorParams &params, circle::Padding padding,
147                                     int stride_w, int stride_h, int filter_w, int filter_h,
148                                     circle::ActivationFunctionType actfn);
149   uint32_t addOperatorCast(const OperatorParams &params, circle::TensorType input_type,
150                            circle::TensorType output_type);
151   uint32_t addOperatorConcatenation(const OperatorParams &params, int axis,
152                                     circle::ActivationFunctionType actfn);
153   uint32_t addOperatorConv2D(const OperatorParams &params, circle::Padding padding, int stride_w,
154                              int stride_h, circle::ActivationFunctionType actfn, int dilation_w = 1,
155                              int dilation_h = 1);
156   uint32_t addOperatorCos(const OperatorParams &params);
157   uint32_t addOperatorDepthToSpace(const OperatorParams &params, int32_t block_size);
158   uint32_t addOperatorDepthwiseConv2D(const OperatorParams &params, circle::Padding padding,
159                                       int stride_w, int stride_h, int depth_multiplier,
160                                       circle::ActivationFunctionType actfn, int dilation_w = 1,
161                                       int dilation_h = 1);
162   uint32_t addOperatorDetectionPostProcess(const OperatorParams &params, int num_classes,
163                                            float y_scale, float x_scale, float h_scale,
164                                            float w_scale, float nms_score_threshold,
165                                            float nms_iou_threshold, int max_detections,
166                                            int max_classes_per_detection, int detections_per_class);
167   uint32_t addOperatorElu(const OperatorParams &params);
168   uint32_t addOperatorEqual(const OperatorParams &params);
169   uint32_t addOperatorExpandDims(const OperatorParams &params);
170   uint32_t addOperatorFill(const OperatorParams &params);
171   uint32_t addOperatorFloor(const OperatorParams &params);
172   uint32_t addOperatorFloorDiv(const OperatorParams &params);
173   uint32_t addOperatorFullyConnected(const OperatorParams &params,
174                                      circle::FullyConnectedOptionsWeightsFormat weights_format =
175                                        circle::FullyConnectedOptionsWeightsFormat_DEFAULT);
176   uint32_t addOperatorIf(const OperatorParams &params, uint32_t then_subg, uint32_t else_subg);
177   uint32_t addOperatorInstanceNorm(const OperatorParams &params, float epsilon,
178                                    circle::ActivationFunctionType actfn);
179   uint32_t addOperatorL2Normalization(const OperatorParams &params);
180   uint32_t addOperatorLeakyRelu(const OperatorParams &params, float alpha);
181   uint32_t addOperatorLess(const OperatorParams &params);
182   uint32_t addOperatorLogSoftmax(const OperatorParams &params);
183   uint32_t addOperatorMul(const OperatorParams &params, circle::ActivationFunctionType actfn);
184   uint32_t addOperatorMean(const OperatorParams &params, bool keep_dims);
185   uint32_t addOperatorNeg(const OperatorParams &params);
186   uint32_t addOperatorOneHot(const OperatorParams &params, int32_t axis);
187   uint32_t addOperatorPad(const OperatorParams &params);
188   uint32_t addOperatorPadV2(const OperatorParams &params);
189   uint32_t addOperatorQuantize(const OperatorParams &params);
190   uint32_t addOperatorRank(const OperatorParams &params);
191   uint32_t addOperatorReduce(const OperatorParams &params, circle::BuiltinOperator reduce_op,
192                              bool keep_dims);
193   /**
194    * @brief Create circle Reshape op
195    *        the second param new_shape can be optional just like circle::CreateReshapeOptionsDirect
196    */
197   uint32_t addOperatorRelu(const OperatorParams &params);
198   uint32_t addOperatorRelu6(const OperatorParams &params);
199   uint32_t addOperatorReshape(const OperatorParams &params, const Shape *new_shape = nullptr);
200   uint32_t addOperatorResizeBilinear(const OperatorParams &params, bool align_corners = false,
201                                      bool half_pixel_centers = false);
202   uint32_t addOperatorResizeNearestNeighbor(const OperatorParams &params);
203   uint32_t addOperatorReverseV2(const OperatorParams &params);
204   uint32_t addOperatorShape(const OperatorParams &params,
205                             circle::TensorType type = circle::TensorType::TensorType_INT32);
206   uint32_t addOperatorSelect(const OperatorParams &params);
207   uint32_t addOperatorSelectV2(const OperatorParams &params);
208   uint32_t addOperatorSlice(const OperatorParams &params);
209   uint32_t addOperatorSoftmax(const OperatorParams &params, float beta);
210   uint32_t addOperatorSplit(const OperatorParams &params, int32_t num_split);
211   uint32_t addOperatorSqrt(const OperatorParams &params);
212   uint32_t addOperatorSquare(const OperatorParams &params);
213   uint32_t addOperatorStridedSlice(const OperatorParams &params, int32_t begin_mask = 0,
214                                    int32_t end_mask = 0, int32_t ellipsis_mask = 0,
215                                    int32_t new_axis_mask = 0, int32_t shrink_axis_mask = 0);
216   uint32_t addOperatorSub(const OperatorParams &params, circle::ActivationFunctionType actfn);
217   uint32_t addOperatorTile(const OperatorParams &params);
218   uint32_t addOperatorTranspose(const OperatorParams &params);
219   uint32_t addOperatorWhile(const OperatorParams &params, uint32_t cond_subg, uint32_t body_subg);
220
221   // NOTE Please add addOperator functions ABOVE this line in ALPHABETICAL ORDER
222   // ===== Add Operator methods end =====
223
224 private:
225   uint32_t addOperatorWithOptions(const OperatorParams &params, circle::BuiltinOperator opcode,
226                                   circle::BuiltinOptions options_type,
227                                   flatbuffers::Offset<void> options);
228   uint32_t addCustomOperatorWithOptions(const OperatorParams &params, std::string custom_code,
229                                         circle::BuiltinOptions options_type,
230                                         flatbuffers::Offset<void> options,
231                                         const std::vector<uint8_t> *custom_options,
232                                         circle::CustomOptionsFormat custom_options_format,
233                                         const std::vector<uint8_t> *mutating_variable_inputs,
234                                         const std::vector<int32_t> *intermediates);
235   uint32_t addOperatorCode(circle::BuiltinOperator opcode);
236   uint32_t addCustomOperatorCode(std::string custom_code);
237   flatbuffers::Offset<circle::Buffer> buildBuffer(const uint8_t *buf, size_t size);
238   flatbuffers::Offset<circle::Tensor> buildTensor(const TensorParams &params);
239   flatbuffers::Offset<circle::Tensor> buildTensor(const TensorParams &params, float scale,
240                                                   int64_t zero_point);
241   flatbuffers::Offset<circle::Tensor> buildTensor(const TensorParams &params,
242                                                   std::vector<float> &scales,
243                                                   std::vector<int64_t> &zero_points);
244   flatbuffers::Offset<circle::SparsityParameters> buildSparsityParameters(const SparsityParams &sp);
245   flatbuffers::Offset<circle::Tensor> buildTensor(const TensorParams &params,
246                                                   const SparsityParams &sp);
247   flatbuffers::Offset<circle::SubGraph> buildSubGraph(const SubgraphContext &ctx);
248
249   SubgraphContext &curSubgCtx() { return _subgraph_contexts.back(); }
250
251 private:
252   flatbuffers::FlatBufferBuilder _fbb{1024};
253   std::vector<flatbuffers::Offset<circle::Buffer>> _buffers;
254   std::vector<flatbuffers::Offset<circle::OperatorCode>> _opcodes;
255   std::vector<SubgraphContext> _subgraph_contexts;
256 };
257
258 #endif // __NNFW_API_TEST_CIRCLE_GEN_H__