compiler/luci/import/include/luci/Import/CircleReader.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 __LUCI_IMPORT_GRAPHREADER_H__
  18 #define __LUCI_IMPORT_GRAPHREADER_H__
  19
  20 #include <mio/circle/schema_generated.h>
  21
  22 #include <luci/IR/AttrFusedActFunc.h>
  23 #include <luci/IR/AttrPadding.h>
  24 #include <luci/IR/CircleNode.h>
  25 #include <luci/IR/CircleQuantParam.h>
  26 #include <luci/IR/SparsityParam.h>
  27
  28 #include <loco.h>
  29
  30 #include <map>
  31 #include <memory>
  32 #include <string>
  33 #include <vector>
  34
  35 namespace luci
  36 {
  37
  38 bool is_valid(const circle::OperatorCodeT &opcode);
  39 bool is_valid(const circle::OperatorCode *opcode);
  40
  41 bool is_custom(const circle::OperatorCodeT &opcode);
  42 bool is_custom(const circle::OperatorCode *opcode);
  43
  44 std::string opcode_name(const circle::OperatorCodeT &opcode);
  45 std::string opcode_name(const circle::OperatorCode *opcode);
  46
  47 const char *tensor_name(const circle::TensorT &tensor);
  48 const char *tensor_name(const circle::Tensor *tensor);
  49
  50 const circle::QuantizationParametersT *tensor_quantization(const circle::TensorT &tensor);
  51 const circle::QuantizationParameters *tensor_quantization(const circle::Tensor *tensor);
  52
  53 loco::DataType luci_datatype(circle::TensorType type);
  54 FusedActFunc luci_actfunc(const circle::ActivationFunctionType type);
  55 Padding luci_padding(const circle::Padding padding);
  56 MirrorPadMode luci_mirrorpad_mode(const circle::MirrorPadMode mode);
  57 luci::CircleFullyConnected::WeightsFormat
  58 luci_weights_format(const circle::FullyConnectedOptionsWeightsFormat weights_format);
  59 std::unique_ptr<CircleQuantParam>
  60 luci_quantparam(const circle::QuantizationParametersT *quantization);
  61 std::unique_ptr<CircleQuantParam>
  62 luci_quantparam(const circle::QuantizationParameters *quantization);
  63
  64 /// @brief Copy common tensor attributes such as name, type, etc. to node.
  65 void copy_tensor_attributes(const circle::TensorT &tensor, CircleNode *node);
  66 void copy_tensor_attributes(const circle::Tensor *tensor, CircleNode *node);
  67
  68 /**
  69  * @brief Wrapper to use flatbuffers::Vector pointer as std::vector entity
  70  */
  71 template <typename T> class VectorWrapper
  72 {
  73 public:
  74   explicit VectorWrapper(const flatbuffers::Vector<T> *ptr);
  75
  76   const T *data() const;
  77   uint32_t size() const;
  78
  79   using iterator = typename flatbuffers::Vector<T>::const_iterator;
  80   iterator begin() const;
  81   iterator end() const;
  82
  83   using value_type = typename flatbuffers::Vector<T>::return_type;
  84   value_type at(uint32_t i) const;
  85   value_type operator[](uint32_t i) const;
  86
  87   bool null() const;
  88   bool empty() const;
  89
  90 private:
  91   const flatbuffers::Vector<T> *_vector;
  92 };
  93
  94 template <typename T> VectorWrapper<T> wrap(const flatbuffers::Vector<T> *vec)
  95 {
  96   return VectorWrapper<T>(vec);
  97 }
  98
  99 /**
 100  * @brief Loads Circle file and provides helpers to access attributes
 101  */
 102 class CircleReader
 103 {
 104 private: // unpack API
 105   using CircleBuffers_t = std::vector<std::unique_ptr<circle::BufferT>>;
 106   using CircleTensors_t = std::vector<std::unique_ptr<circle::TensorT>>;
 107   using CircleOperators_t = std::vector<std::unique_ptr<circle::OperatorT>>;
 108   using CircleOperatorCodes_t = std::vector<std::unique_ptr<circle::OperatorCodeT>>;
 109   using CircleMetadata_t = std::vector<std::unique_ptr<circle::MetadataT>>;
 110
 111 private: // direct API
 112   using CircleBuffers = VectorWrapper<flatbuffers::Offset<circle::Buffer>>;
 113   using CircleTensors = VectorWrapper<flatbuffers::Offset<circle::Tensor>>;
 114   using CircleOperators = VectorWrapper<flatbuffers::Offset<circle::Operator>>;
 115   using CircleOperatorCodes = VectorWrapper<flatbuffers::Offset<circle::OperatorCode>>;
 116   using CircleMetadataSet = VectorWrapper<flatbuffers::Offset<circle::Metadata>>;
 117
 118   using CircleSubGraphsPtr_t = flatbuffers::Vector<flatbuffers::Offset<circle::SubGraph>>;
 119   using CircleTensorsPtr_t = flatbuffers::Vector<flatbuffers::Offset<circle::Tensor>>;
 120
 121 public:
 122   CircleReader() = default;
 123
 124 public: // unpack API
 125   const CircleOperatorCodes_t &opcodes() const { return _model->operator_codes; }
 126   const CircleBuffers_t &buffers() const { return _model->buffers; }
 127   const CircleTensors_t &tensors() const { return _current_subgraph->tensors; }
 128   const CircleOperators_t &operators() const { return _current_subgraph->operators; }
 129   const std::vector<int32_t> &inputs() const { return _current_subgraph->inputs; }
 130   const std::vector<int32_t> &outputs() const { return _current_subgraph->outputs; }
 131   const std::string &name() const { return _current_subgraph->name; }
 132   const circle::DataFormat &data_format() const { return _current_subgraph->data_format; }
 133   const CircleMetadata_t &metadata() const { return _model->metadata; }
 134
 135   const CircleTensorsPtr_t *tensors_ptr() const { return _tensors_ptr; }
 136
 137   uint32_t num_subgraph() const { return _model->subgraphs.size(); }
 138
 139   circle::BuiltinOperator builtin_code(const circle::OperatorT &op) const;
 140   std::string opcode_name(const circle::OperatorT &op) const;
 141
 142 public: // direct API
 143   CircleOperatorCodes native_opcodes() const { return wrap(_native_model->operator_codes()); }
 144   CircleBuffers native_buffers() const { return wrap(_native_model->buffers()); }
 145   CircleTensors native_tensors() const { return wrap(_native_subgraph->tensors()); }
 146   CircleOperators native_operators() const { return wrap(_native_subgraph->operators()); }
 147   VectorWrapper<int32_t> native_inputs() const { return wrap(_native_subgraph->inputs()); }
 148   VectorWrapper<int32_t> native_outputs() const { return wrap(_native_subgraph->outputs()); }
 149   std::string native_name() const { return _native_subgraph->name()->str(); }
 150   circle::DataFormat native_data_format() const { return _native_subgraph->data_format(); }
 151   CircleMetadataSet native_metadata() const { return wrap(_native_model->metadata()); }
 152
 153   circle::BuiltinOperator builtin_code(const circle::Operator *op) const;
 154   std::string opcode_name(const circle::Operator *op) const;
 155
 156 public:
 157   bool parse(const circle::Model *model);
 158   bool select_subgraph(uint32_t subgraph);
 159
 160 private:
 161   std::unique_ptr<const circle::ModelT> _model;
 162   const circle::SubGraphT *_current_subgraph{nullptr};
 163
 164   const circle::Model *_native_model{nullptr};
 165   const CircleTensorsPtr_t *_tensors_ptr{nullptr};
 166   const circle::SubGraph *_native_subgraph{nullptr};
 167 };
 168
 169 } // namespace luci
 170
 171 #endif // __LUCI_IMPORT_GRAPHREADER_H__