2 * Copyright (c) 2020 Samsung Electronics Co., Ltd. All Rights Reserved
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 #include "CircleGen.h"
18 #include "flatbuffers/flexbuffers.h"
20 CircleGen::CircleGen() : _subgraph_contexts(1) // Create primary subgraph
22 // 0th buffer is always the empty buffer for non-const tensors
23 addBuffer(nullptr, 0);
26 template <typename T> uint32_t addBuffer(const std::vector<T> &buf_vec)
28 auto buf = reinterpret_cast<const uint8_t *>(buf_vec.data());
29 auto size = buf_vec.size() * sizeof(T);
30 return addBuffer(buf, size);
33 uint32_t CircleGen::addBuffer(const uint8_t *buf, size_t size)
35 uint32_t ind = _buffers.size();
36 _buffers.emplace_back(buildBuffer(buf, size));
40 uint32_t CircleGen::addTensor(const TensorParams ¶ms)
42 uint32_t ind = curSubgCtx().tensors.size();
43 curSubgCtx().tensors.emplace_back(buildTensor(params));
47 uint32_t CircleGen::addTensor(const TensorParams ¶ms, float scale, int64_t zero_point)
49 // TensorType_INT8: scale >= 0, zero_point: [-128, 127]
50 // TensorType_UINT8: scale >= 0, zero_point: [0, 255]
51 uint32_t ind = curSubgCtx().tensors.size();
52 curSubgCtx().tensors.emplace_back(buildTensor(params, scale, zero_point));
56 uint32_t CircleGen::addTensor(const TensorParams ¶ms, std::vector<float> &scale,
57 std::vector<int64_t> &zero_point)
59 uint32_t ind = curSubgCtx().tensors.size();
60 curSubgCtx().tensors.emplace_back(buildTensor(params, scale, zero_point));
64 uint32_t CircleGen::addTensor(const TensorParams ¶ms, const SparsityParams &sp)
66 uint32_t ind = curSubgCtx().tensors.size();
67 curSubgCtx().tensors.emplace_back(buildTensor(params, sp));
71 void CircleGen::setInputsAndOutputs(const std::vector<int> &inputs, const std::vector<int> &outputs)
73 curSubgCtx().inputs = inputs;
74 curSubgCtx().outputs = outputs;
77 uint32_t CircleGen::nextSubgraph()
79 uint32_t ind = _subgraph_contexts.size();
80 _subgraph_contexts.push_back({});
84 CircleBuffer CircleGen::finish()
86 std::vector<flatbuffers::Offset<circle::SubGraph>> subgraphs;
87 for (auto &ctx : _subgraph_contexts)
88 subgraphs.push_back(buildSubGraph(ctx));
90 circle::CreateModelDirect(_fbb, 3, &_opcodes, &subgraphs, "CircleGen generated", &_buffers);
92 return CircleBuffer{std::move(_fbb)};
95 // ===== Add Operator methods begin =====
97 uint32_t CircleGen::addOperatorAdd(const OperatorParams ¶ms,
98 circle::ActivationFunctionType actfn)
100 auto options = circle::CreateAddOptions(_fbb, actfn).Union();
101 return addOperatorWithOptions(params, circle::BuiltinOperator_ADD,
102 circle::BuiltinOptions_AddOptions, options);
105 uint32_t CircleGen::addOperatorAddN(const OperatorParams ¶ms)
107 auto options = circle::CreateAddNOptions(_fbb).Union();
108 return addOperatorWithOptions(params, circle::BuiltinOperator_ADD_N,
109 circle::BuiltinOptions_AddNOptions, options);
112 uint32_t CircleGen::addOperatorArgMax(const OperatorParams ¶ms, circle::TensorType output_type)
114 auto options = circle::CreateArgMaxOptions(_fbb, output_type).Union();
115 return addOperatorWithOptions(params, circle::BuiltinOperator_ARG_MAX,
116 circle::BuiltinOptions_ArgMaxOptions, options);
119 uint32_t CircleGen::addOperatorArgMin(const OperatorParams ¶ms, circle::TensorType output_type)
121 auto options = circle::CreateArgMaxOptions(_fbb, output_type).Union();
122 return addOperatorWithOptions(params, circle::BuiltinOperator_ARG_MIN,
123 circle::BuiltinOptions_ArgMinOptions, options);
126 uint32_t CircleGen::addOperatorAveragePool2D(const OperatorParams ¶ms, circle::Padding padding,
127 int stride_w, int stride_h, int filter_w, int filter_h,
128 circle::ActivationFunctionType actfn)
131 circle::CreatePool2DOptions(_fbb, padding, stride_w, stride_h, filter_w, filter_h, actfn)
133 return addOperatorWithOptions(params, circle::BuiltinOperator_AVERAGE_POOL_2D,
134 circle::BuiltinOptions_Pool2DOptions, options);
137 uint32_t CircleGen::addOperatorCast(const OperatorParams ¶ms, circle::TensorType input_type,
138 circle::TensorType output_type)
140 auto options = circle::CreateCastOptions(_fbb, input_type, output_type).Union();
141 return addOperatorWithOptions(params, circle::BuiltinOperator_CAST,
142 circle::BuiltinOptions_AddOptions, options);
145 uint32_t CircleGen::addOperatorConcatenation(const OperatorParams ¶ms, int axis,
146 circle::ActivationFunctionType actfn)
148 auto options = circle::CreateConcatenationOptions(_fbb, axis, actfn).Union();
149 return addOperatorWithOptions(params, circle::BuiltinOperator_CONCATENATION,
150 circle::BuiltinOptions_ConcatenationOptions, options);
153 uint32_t CircleGen::addOperatorConv2D(const OperatorParams ¶ms, circle::Padding padding,
154 int stride_w, int stride_h,
155 circle::ActivationFunctionType actfn, int dilation_w,
159 circle::CreateConv2DOptions(_fbb, padding, stride_w, stride_h, actfn, dilation_w, dilation_h)
161 return addOperatorWithOptions(params, circle::BuiltinOperator_CONV_2D,
162 circle::BuiltinOptions_Conv2DOptions, options);
165 uint32_t CircleGen::addOperatorCos(const OperatorParams ¶ms)
167 auto options = circle::CreateCosOptions(_fbb).Union();
168 return addOperatorWithOptions(params, circle::BuiltinOperator_COS,
169 circle::BuiltinOptions_CosOptions, options);
172 uint32_t CircleGen::addOperatorDepthToSpace(const OperatorParams ¶ms, int32_t block_size)
174 auto options = circle::CreateDepthToSpaceOptions(_fbb, block_size).Union();
175 return addOperatorWithOptions(params, circle::BuiltinOperator_DEPTH_TO_SPACE,
176 circle::BuiltinOptions_DepthToSpaceOptions, options);
179 uint32_t CircleGen::addOperatorDepthwiseConv2D(const OperatorParams ¶ms,
180 circle::Padding padding, int stride_w, int stride_h,
181 int depth_multiplier,
182 circle::ActivationFunctionType actfn, int dilation_w,
186 circle::CreateDepthwiseConv2DOptions(_fbb, padding, stride_w, stride_h, depth_multiplier, actfn,
187 dilation_w, dilation_h)
189 return addOperatorWithOptions(params, circle::BuiltinOperator_DEPTHWISE_CONV_2D,
190 circle::BuiltinOptions_DepthwiseConv2DOptions, options);
193 uint32_t CircleGen::addOperatorDetectionPostProcess(const OperatorParams ¶ms, int num_classes,
194 float y_scale, float x_scale, float h_scale,
195 float w_scale, float nms_score_threshold,
196 float nms_iou_threshold, int max_detections,
197 int max_classes_per_detection,
198 int detections_per_class)
200 // flexbuffer custom_option
201 auto flex_buffers = std::make_unique<flexbuffers::Builder>();
202 size_t map_start = flex_buffers->StartMap();
203 flex_buffers->Int("num_classes", num_classes);
204 flex_buffers->Float("y_scale", y_scale);
205 flex_buffers->Float("x_scale", x_scale);
206 flex_buffers->Float("h_scale", h_scale);
207 flex_buffers->Float("w_scale", w_scale);
208 flex_buffers->Float("nms_iou_threshold", nms_iou_threshold);
209 flex_buffers->Float("nms_score_threshold", nms_score_threshold);
210 flex_buffers->Int("max_detections", max_detections);
211 flex_buffers->Int("max_classes_per_detection", max_classes_per_detection);
212 flex_buffers->Int("detections_per_class", detections_per_class);
213 flex_buffers->EndMap(map_start);
214 flex_buffers->Finish();
216 return addCustomOperatorWithOptions(params, "TFLite_Detection_PostProcess",
217 circle::BuiltinOptions_NONE, 0, &flex_buffers->GetBuffer(),
218 circle::CustomOptionsFormat::CustomOptionsFormat_FLEXBUFFERS,
222 uint32_t CircleGen::addOperatorElu(const OperatorParams ¶ms)
224 return addOperatorWithOptions(params, circle::BuiltinOperator_ELU, circle::BuiltinOptions_NONE,
228 uint32_t CircleGen::addOperatorEqual(const OperatorParams ¶ms)
230 auto options = circle::CreateEqualOptions(_fbb).Union();
231 return addOperatorWithOptions(params, circle::BuiltinOperator_EQUAL,
232 circle::BuiltinOptions_EqualOptions, options);
235 uint32_t CircleGen::addOperatorExpandDims(const OperatorParams ¶ms)
237 auto options = circle::CreateEqualOptions(_fbb).Union();
238 return addOperatorWithOptions(params, circle::BuiltinOperator_EXPAND_DIMS,
239 circle::BuiltinOptions_ExpandDimsOptions, options);
243 CircleGen::addOperatorFullyConnected(const OperatorParams ¶ms,
244 circle::FullyConnectedOptionsWeightsFormat weights_format)
247 circle::CreateFullyConnectedOptions(_fbb, circle::ActivationFunctionType_NONE, weights_format)
249 return addOperatorWithOptions(params, circle::BuiltinOperator_FULLY_CONNECTED,
250 circle::BuiltinOptions_FullyConnectedOptions, options);
253 uint32_t CircleGen::addOperatorFill(const OperatorParams ¶ms)
255 auto options = circle::CreateFillOptions(_fbb).Union();
256 return addOperatorWithOptions(params, circle::BuiltinOperator_FILL,
257 circle::BuiltinOptions_FillOptions, options);
260 uint32_t CircleGen::addOperatorFloor(const OperatorParams ¶ms)
262 return addOperatorWithOptions(params, circle::BuiltinOperator_FLOOR, circle::BuiltinOptions_NONE,
266 uint32_t CircleGen::addOperatorFloorDiv(const OperatorParams ¶ms)
268 return addOperatorWithOptions(params, circle::BuiltinOperator_FLOOR_DIV,
269 circle::BuiltinOptions_NONE, 0);
272 uint32_t CircleGen::addOperatorGreater(const OperatorParams ¶ms)
274 auto options = circle::CreateLessOptions(_fbb).Union();
275 return addOperatorWithOptions(params, circle::BuiltinOperator_GREATER,
276 circle::BuiltinOptions_GreaterOptions, options);
279 uint32_t CircleGen::addOperatorGreaterEqual(const OperatorParams ¶ms)
281 auto options = circle::CreateGreaterOptions(_fbb).Union();
282 return addOperatorWithOptions(params, circle::BuiltinOperator_GREATER_EQUAL,
283 circle::BuiltinOptions_GreaterEqualOptions, options);
286 uint32_t CircleGen::addOperatorL2Normalization(const OperatorParams ¶ms)
288 auto options = circle::CreateL2NormOptions(_fbb).Union();
289 return addOperatorWithOptions(params, circle::BuiltinOperator_L2_NORMALIZATION,
290 circle::BuiltinOptions_L2NormOptions, options);
293 uint32_t CircleGen::addOperatorLess(const OperatorParams ¶ms)
295 auto options = circle::CreateLessOptions(_fbb).Union();
296 return addOperatorWithOptions(params, circle::BuiltinOperator_LESS,
297 circle::BuiltinOptions_LessOptions, options);
300 uint32_t CircleGen::addOperatorLessEqual(const OperatorParams ¶ms)
302 auto options = circle::CreateLessOptions(_fbb).Union();
303 return addOperatorWithOptions(params, circle::BuiltinOperator_LESS_EQUAL,
304 circle::BuiltinOptions_LessEqualOptions, options);
307 uint32_t CircleGen::addOperatorLeakyRelu(const OperatorParams ¶ms, float alpha)
309 auto options = circle::CreateLeakyReluOptions(_fbb, alpha).Union();
310 return addOperatorWithOptions(params, circle::BuiltinOperator_LEAKY_RELU,
311 circle::BuiltinOptions_LeakyReluOptions, options);
314 uint32_t CircleGen::addOperatorLogSoftmax(const OperatorParams ¶ms)
316 auto options = circle::CreateLogSoftmaxOptions(_fbb).Union();
317 return addOperatorWithOptions(params, circle::BuiltinOperator_LOG_SOFTMAX,
318 circle::BuiltinOptions_LogSoftmaxOptions, options);
321 uint32_t CircleGen::addOperatorMean(const OperatorParams ¶ms, bool keep_dims)
323 auto options = circle::CreateReducerOptions(_fbb, keep_dims).Union();
324 return addOperatorWithOptions(params, circle::BuiltinOperator_MEAN,
325 circle::BuiltinOptions_ReducerOptions, options);
328 uint32_t CircleGen::addOperatorMul(const OperatorParams ¶ms,
329 circle::ActivationFunctionType actfn)
331 auto options = circle::CreateMulOptions(_fbb, actfn).Union();
332 return addOperatorWithOptions(params, circle::BuiltinOperator_MUL,
333 circle::BuiltinOptions_MulOptions, options);
336 uint32_t CircleGen::addOperatorNeg(const OperatorParams ¶ms)
338 auto options = circle::CreatePadOptions(_fbb).Union();
339 return addOperatorWithOptions(params, circle::BuiltinOperator_NEG,
340 circle::BuiltinOptions_NegOptions, options);
343 uint32_t CircleGen::addOperatorNotEqual(const OperatorParams ¶ms)
345 auto options = circle::CreateEqualOptions(_fbb).Union();
346 return addOperatorWithOptions(params, circle::BuiltinOperator_NOT_EQUAL,
347 circle::BuiltinOptions_NotEqualOptions, options);
350 uint32_t CircleGen::addOperatorOneHot(const OperatorParams ¶ms, int32_t axis)
352 auto options = circle::CreateOneHotOptions(_fbb, axis).Union();
353 return addOperatorWithOptions(params, circle::BuiltinOperator_ONE_HOT,
354 circle::BuiltinOptions_OneHotOptions, options);
357 uint32_t CircleGen::addOperatorPad(const OperatorParams ¶ms)
359 auto options = circle::CreatePadOptions(_fbb).Union();
360 return addOperatorWithOptions(params, circle::BuiltinOperator_PAD,
361 circle::BuiltinOptions_PadOptions, options);
364 uint32_t CircleGen::addOperatorPadV2(const OperatorParams ¶ms)
366 auto options = circle::CreatePadOptions(_fbb).Union();
367 return addOperatorWithOptions(params, circle::BuiltinOperator_PADV2,
368 circle::BuiltinOptions_PadV2Options, options);
371 uint32_t CircleGen::addOperatorQuantize(const OperatorParams ¶ms)
373 auto options = circle::CreateQuantizeOptions(_fbb).Union();
374 return addOperatorWithOptions(params, circle::BuiltinOperator_QUANTIZE,
375 circle::BuiltinOptions_QuantizeOptions, options);
378 uint32_t CircleGen::addOperatorRank(const OperatorParams ¶ms)
380 auto options = circle::CreateRankOptions(_fbb).Union();
381 return addOperatorWithOptions(params, circle::BuiltinOperator_RANK,
382 circle::BuiltinOptions_RankOptions, options);
385 uint32_t CircleGen::addOperatorReduce(const OperatorParams ¶ms,
386 circle::BuiltinOperator reduce_op, bool keep_dims)
390 case circle::BuiltinOperator_REDUCE_ANY:
391 case circle::BuiltinOperator_REDUCE_MIN:
392 case circle::BuiltinOperator_REDUCE_MAX:
393 case circle::BuiltinOperator_REDUCE_PROD:
396 throw std::runtime_error{"Wrong reduce op"};
398 auto options = circle::CreateReducerOptions(_fbb, keep_dims).Union();
399 return addOperatorWithOptions(params, reduce_op, circle::BuiltinOptions_ReducerOptions, options);
402 uint32_t CircleGen::addOperatorRelu(const OperatorParams ¶ms)
404 return addOperatorWithOptions(params, circle::BuiltinOperator_RELU, circle::BuiltinOptions_NONE,
408 uint32_t CircleGen::addOperatorRelu6(const OperatorParams ¶ms)
410 return addOperatorWithOptions(params, circle::BuiltinOperator_RELU6, circle::BuiltinOptions_NONE,
414 uint32_t CircleGen::addOperatorReshape(const OperatorParams ¶ms, const Shape *new_shape)
416 auto options = circle::CreateReshapeOptionsDirect(_fbb, new_shape).Union();
417 return addOperatorWithOptions(params, circle::BuiltinOperator_RESHAPE,
418 circle::BuiltinOptions_ReshapeOptions, options);
421 uint32_t CircleGen::addOperatorResizeBilinear(const OperatorParams ¶ms, bool align_corners,
422 bool half_pixel_centers)
425 circle::CreateResizeBilinearOptions(_fbb, align_corners, half_pixel_centers).Union();
426 return addOperatorWithOptions(params, circle::BuiltinOperator_RESIZE_BILINEAR,
427 circle::BuiltinOptions_ResizeBilinearOptions, options);
430 uint32_t CircleGen::addOperatorResizeNearestNeighbor(const OperatorParams ¶ms)
432 auto options = circle::CreateResizeNearestNeighborOptions(_fbb).Union();
433 return addOperatorWithOptions(params, circle::BuiltinOperator_RESIZE_NEAREST_NEIGHBOR,
434 circle::BuiltinOptions_ResizeNearestNeighborOptions, options);
437 uint32_t CircleGen::addOperatorReverseV2(const OperatorParams ¶ms)
439 auto options = circle::CreateReverseV2Options(_fbb).Union();
440 return addOperatorWithOptions(params, circle::BuiltinOperator_REVERSE_V2,
441 circle::BuiltinOptions_ReverseV2Options, options);
444 uint32_t CircleGen::addOperatorShape(const OperatorParams ¶ms, circle::TensorType type)
446 auto options = circle::CreateShapeOptions(_fbb, type).Union();
447 return addOperatorWithOptions(params, circle::BuiltinOperator_SHAPE,
448 circle::BuiltinOptions_RankOptions, options);
451 uint32_t CircleGen::addOperatorSelect(const OperatorParams ¶ms)
453 auto options = circle::CreateSelectOptions(_fbb).Union();
454 return addOperatorWithOptions(params, circle::BuiltinOperator_SELECT,
455 circle::BuiltinOptions_SelectOptions, options);
458 uint32_t CircleGen::addOperatorSelectV2(const OperatorParams ¶ms)
460 auto options = circle::CreateSelectV2Options(_fbb).Union();
461 return addOperatorWithOptions(params, circle::BuiltinOperator_SELECT_V2,
462 circle::BuiltinOptions_SelectV2Options, options);
465 uint32_t CircleGen::addOperatorSlice(const OperatorParams ¶ms)
467 auto options = circle::CreateSliceOptions(_fbb).Union();
468 return addOperatorWithOptions(params, circle::BuiltinOperator_SLICE,
469 circle::BuiltinOptions_SliceOptions, options);
472 uint32_t CircleGen::addOperatorSoftmax(const OperatorParams ¶ms, float beta)
474 auto options = circle::CreateSoftmaxOptions(_fbb, beta).Union();
475 return addOperatorWithOptions(params, circle::BuiltinOperator_SOFTMAX,
476 circle::BuiltinOptions_SoftmaxOptions, options);
479 uint32_t CircleGen::addOperatorSplit(const OperatorParams ¶ms, int32_t num_split)
481 auto options = circle::CreateSplitOptions(_fbb, num_split).Union();
482 return addOperatorWithOptions(params, circle::BuiltinOperator_SPLIT,
483 circle::BuiltinOptions_SplitOptions, options);
486 uint32_t CircleGen::addOperatorStridedSlice(const OperatorParams ¶ms, int32_t begin_mask,
487 int32_t end_mask, int32_t ellipsis_mask,
488 int32_t new_axis_mask, int32_t shrink_axis_mask)
490 auto options = circle::CreateStridedSliceOptions(_fbb, begin_mask, end_mask, ellipsis_mask,
491 new_axis_mask, shrink_axis_mask)
493 return addOperatorWithOptions(params, circle::BuiltinOperator_STRIDED_SLICE,
494 circle::BuiltinOptions_StridedSliceOptions, options);
497 uint32_t CircleGen::addOperatorSub(const OperatorParams ¶ms,
498 circle::ActivationFunctionType actfn)
500 auto options = circle::CreateSubOptions(_fbb, actfn).Union();
501 return addOperatorWithOptions(params, circle::BuiltinOperator_SUB,
502 circle::BuiltinOptions_SubOptions, options);
505 uint32_t CircleGen::addOperatorTile(const OperatorParams ¶ms)
507 auto options = circle::CreateTileOptions(_fbb).Union();
508 return addOperatorWithOptions(params, circle::BuiltinOperator_TILE,
509 circle::BuiltinOptions_TileOptions, options);
512 uint32_t CircleGen::addOperatorWhile(const OperatorParams ¶ms, uint32_t cond_subg,
515 auto options = circle::CreateWhileOptions(_fbb, cond_subg, body_subg).Union();
516 return addOperatorWithOptions(params, circle::BuiltinOperator_WHILE,
517 circle::BuiltinOptions_WhileOptions, options);
520 uint32_t CircleGen::addOperatorIf(const OperatorParams ¶ms, uint32_t then_subg,
523 auto options = circle::CreateIfOptions(_fbb, then_subg, else_subg).Union();
524 return addOperatorWithOptions(params, circle::BuiltinOperator_IF,
525 circle::BuiltinOptions_IfOptions, options);
528 uint32_t CircleGen::addOperatorInstanceNorm(const OperatorParams ¶ms, float epsilon,
529 circle::ActivationFunctionType actfn)
531 auto options = circle::CreateInstanceNormOptions(_fbb, epsilon, actfn).Union();
532 return addOperatorWithOptions(params, circle::BuiltinOperator_INSTANCE_NORM,
533 circle::BuiltinOptions_InstanceNormOptions, options);
536 uint32_t CircleGen::addOperatorTranspose(const OperatorParams ¶ms)
538 auto options = circle::CreateTransposeOptions(_fbb).Union();
539 return addOperatorWithOptions(params, circle::BuiltinOperator_TRANSPOSE,
540 circle::BuiltinOptions_TransposeOptions, options);
543 uint32_t CircleGen::addOperatorSqrt(const OperatorParams ¶ms)
545 return addOperatorWithOptions(params, circle::BuiltinOperator_SQRT, circle::BuiltinOptions_NONE,
549 uint32_t CircleGen::addOperatorSquare(const OperatorParams ¶ms)
551 auto options = circle::CreateSquareOptions(_fbb).Union();
552 return addOperatorWithOptions(params, circle::BuiltinOperator_SQUARE,
553 circle::BuiltinOptions_SquareOptions, options);
556 uint32_t CircleGen::addOperatorBatchToSpaceND(const OperatorParams ¶ms)
558 auto options = circle::CreateBatchToSpaceNDOptions(_fbb).Union();
559 return addOperatorWithOptions(params, circle::BuiltinOperator_BATCH_TO_SPACE_ND,
560 circle::BuiltinOptions_BatchToSpaceNDOptions, options);
563 // NOTE Please add addOperator functions ABOVE this lie
565 // % How to add a new addOperatorXXX fuction
566 // 0. Copy code from one of the existing addOperatorXXX function
567 // 1. Change the function signature (need BuiltinOperator params)
568 // 2. Change enum BuiltinOperator
569 // 3. Change enum BuiltinOptions
570 // 4. Change CreateXXXOptions accordingly
572 // If operator don't have option table, remove CreateXXXOptions call,
573 // call addOperatorWithOptions with options_type = circle::BuiltinOptions_NONE and options = 0
575 // ===== Add Operator methods end =====
577 uint32_t CircleGen::addOperatorWithOptions(const OperatorParams ¶ms,
578 circle::BuiltinOperator opcode,
579 circle::BuiltinOptions options_type,
580 flatbuffers::Offset<void> options)
582 uint32_t opcode_ind = addOperatorCode(opcode);
583 auto op = circle::CreateOperatorDirect(_fbb, opcode_ind, ¶ms.inputs, ¶ms.outputs,
584 options_type, options);
586 uint32_t ind = curSubgCtx().operators.size();
587 curSubgCtx().operators.emplace_back(op);
591 uint32_t CircleGen::addCustomOperatorWithOptions(
592 const OperatorParams ¶ms, std::string custom_code, circle::BuiltinOptions options_type,
593 flatbuffers::Offset<void> options, const std::vector<uint8_t> *custom_options,
594 circle::CustomOptionsFormat custom_options_format,
595 const std::vector<uint8_t> *mutating_variable_inputs, const std::vector<int32_t> *intermediates)
598 uint32_t opcode_ind = addCustomOperatorCode(custom_code);
599 auto op = circle::CreateOperatorDirect(
600 _fbb, opcode_ind, ¶ms.inputs, ¶ms.outputs, options_type, options, custom_options,
601 custom_options_format, mutating_variable_inputs, intermediates);
603 uint32_t ind = curSubgCtx().operators.size();
604 curSubgCtx().operators.emplace_back(op);
608 uint32_t CircleGen::addOperatorCode(circle::BuiltinOperator opcode)
610 // TODO If the same OperatorCode is registered already, just return it
611 uint32_t ind = _opcodes.size();
612 _opcodes.emplace_back(circle::CreateOperatorCode(_fbb, opcode));
616 uint32_t CircleGen::addCustomOperatorCode(std::string custom_code)
618 // TODO If the same OperatorCode is registered already, just return it
619 uint32_t ind = _opcodes.size();
620 _opcodes.emplace_back(
621 circle::CreateOperatorCodeDirect(_fbb, circle::BuiltinOperator_CUSTOM, custom_code.c_str()));
625 flatbuffers::Offset<circle::Buffer> CircleGen::buildBuffer(const uint8_t *buf, size_t size)
627 if (buf == nullptr && size == 0)
628 return circle::CreateBuffer(_fbb);
629 auto buffer = _fbb.CreateVector(buf, size);
630 return circle::CreateBuffer(_fbb, buffer);
633 flatbuffers::Offset<circle::Tensor> CircleGen::buildTensor(const TensorParams ¶ms)
635 auto shape = _fbb.CreateVector(params.shape);
636 auto name = _fbb.CreateString(params.name);
637 return circle::CreateTensor(_fbb, shape, params.tensor_type, params.buffer, name,
638 0 /* QuantParam */, false /* is_variable */, 0 /* sparsity */,
639 0 /* shape_signature */);
642 flatbuffers::Offset<circle::Tensor> CircleGen::buildTensor(const TensorParams ¶ms, float scale,
645 auto shape = _fbb.CreateVector(params.shape);
646 auto name = _fbb.CreateString(params.name);
647 std::vector<float> scale_vector = {scale};
648 std::vector<int64_t> zero_point_vector = {zero_point};
649 auto quantization = circle::CreateQuantizationParametersDirect(_fbb, nullptr, nullptr,
650 &scale_vector, &zero_point_vector);
651 return circle::CreateTensor(_fbb, shape, params.tensor_type, params.buffer, name, quantization,
652 false /* is_variable */, 0 /* sparsity */, 0 /* shape_signature */);
655 flatbuffers::Offset<circle::Tensor> CircleGen::buildTensor(const TensorParams ¶ms,
656 std::vector<float> &scales,
657 std::vector<int64_t> &zero_points)
659 auto shape = _fbb.CreateVector(params.shape);
660 auto name = _fbb.CreateString(params.name);
662 circle::CreateQuantizationParametersDirect(_fbb, nullptr, nullptr, &scales, &zero_points);
663 return circle::CreateTensor(_fbb, shape, params.tensor_type, params.buffer, name, quantization,
664 false /* is_variable */, 0 /* sparsity */, 0 /* shape_signature */);
667 flatbuffers::Offset<circle::SparsityParameters>
668 CircleGen::buildSparsityParameters(const SparsityParams &sp)
670 flatbuffers::Offset<flatbuffers::Vector<int32_t>> traversal_order;
671 flatbuffers::Offset<flatbuffers::Vector<int32_t>> block_map;
672 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<circle::DimensionMetadata>>>
675 traversal_order = _fbb.CreateVector(sp.traversal_order);
676 block_map = _fbb.CreateVector(sp.block_map);
678 std::vector<flatbuffers::Offset<circle::DimensionMetadata>> dim_metadata_vec;
679 for (auto &it : sp.dim_metadata)
681 auto fb_array_segments = circle::CreateUint16VectorDirect(_fbb, &it._array_segments.u16);
682 auto fb_array_indices = circle::CreateUint16VectorDirect(_fbb, &it._array_indices.u16);
683 auto dim_metadata = circle::CreateDimensionMetadata(
684 _fbb, it._format, it._dense_size, it._array_segments_type, fb_array_segments.Union(),
685 it._array_indices_type, fb_array_indices.Union());
686 dim_metadata_vec.emplace_back(dim_metadata);
688 dim_metadata = _fbb.CreateVector(dim_metadata_vec);
690 return circle::CreateSparsityParameters(_fbb, traversal_order, block_map, dim_metadata);
693 flatbuffers::Offset<circle::Tensor> CircleGen::buildTensor(const TensorParams ¶ms,
694 const SparsityParams &sp)
696 auto shape = _fbb.CreateVector(params.shape);
697 auto name = _fbb.CreateString(params.name);
698 auto sparsity = buildSparsityParameters(sp);
699 return circle::CreateTensor(_fbb, shape, params.tensor_type, params.buffer, name,
700 0 /* QuantParam */, false /* is_variable */, sparsity,
701 0 /* shape_signature */);
704 flatbuffers::Offset<circle::SubGraph> CircleGen::buildSubGraph(const SubgraphContext &ctx)
706 return circle::CreateSubGraphDirect(_fbb, &ctx.tensors, &ctx.inputs, &ctx.outputs, &ctx.operators,