[nnpkg, circle] Define instance_norm in circle_schema.fbs (#8262)

It introduces instance_norm operator in circle schema.
Also, it updates circle_schema_generated.h for circle_loader.

Signed-off-by: Sanggyu Lee <sg5.lee@samsung.com>

diff --git a/nnpackage/schema/circle_schema.fbs b/nnpackage/schema/circle_schema.fbs
index dbb0d35..3de4083 100644 (file)
--- a/nnpackage/schema/circle_schema.fbs
+++ b/nnpackage/schema/circle_schema.fbs
@@ -203,6 +203,7 @@ enum BuiltinOperator : byte {
   MIRROR_PAD = 100,
   ABS = 101,
   SPLIT_V = 102,
+  INSTANCE_NORM = 254,
 }
 
 // Options for the builtin operators.
@@ -286,6 +287,7 @@ union BuiltinOptions {
   MirrorPadOptions,
   AbsOptions,
   SplitVOptions,
+  InstanceNormOptions,
 }
 
 enum Padding : byte { SAME, VALID }
@@ -692,6 +694,11 @@ table MirrorPadOptions {
   mode:MirrorPadMode;
 }
 
+table InstanceNormOptions {
+  epsilon:float;
+  fused_activation_function:ActivationFunctionType;
+}
+
 // An OperatorCode can be an enum value (BuiltinOperator) if the operator is a
 // builtin, or a string if the operator is custom.
 table OperatorCode {

diff --git a/runtimes/neurun/frontend/circle/circle_schema_generated.h b/runtimes/neurun/frontend/circle/circle_schema_generated.h
index 6bda418..9f793b9 100644 (file)
--- a/runtimes/neurun/frontend/circle/circle_schema_generated.h
+++ b/runtimes/neurun/frontend/circle/circle_schema_generated.h
@@ -187,6 +187,8 @@ struct SquaredDifferenceOptions;
 
 struct MirrorPadOptions;
 
+struct InstanceNormOptions;
+
 struct OperatorCode;
 
 struct Operator;
@@ -382,11 +384,12 @@ enum BuiltinOperator
   BuiltinOperator_MIRROR_PAD = 100,
   BuiltinOperator_ABS = 101,
   BuiltinOperator_SPLIT_V = 102,
+  BuiltinOperator_INSTANCE_NORM = 254,
   BuiltinOperator_MIN = BuiltinOperator_ADD,
-  BuiltinOperator_MAX = BuiltinOperator_SPLIT_V
+  BuiltinOperator_MAX = BuiltinOperator_INSTANCE_NORM
 };
 
-inline const BuiltinOperator (&EnumValuesBuiltinOperator())[102]
+inline const BuiltinOperator (&EnumValuesBuiltinOperator())[103]
 {
   static const BuiltinOperator values[] = {BuiltinOperator_ADD,
                                            BuiltinOperator_AVERAGE_POOL_2D,
@@ -489,7 +492,8 @@ inline const BuiltinOperator (&EnumValuesBuiltinOperator())[102]
                                            BuiltinOperator_SQUARED_DIFFERENCE,
                                            BuiltinOperator_MIRROR_PAD,
                                            BuiltinOperator_ABS,
-                                           BuiltinOperator_SPLIT_V};
+                                           BuiltinOperator_SPLIT_V,
+                                           BuiltinOperator_INSTANCE_NORM};
   return values;
 }
 
@@ -598,6 +602,158 @@ inline const char *const *EnumNamesBuiltinOperator()
                                       "MIRROR_PAD",
                                       "ABS",
                                       "SPLIT_V",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "",
+                                      "INSTANCE_NORM",
                                       nullptr};
   return names;
 }
@@ -690,11 +846,12 @@ enum BuiltinOptions
   BuiltinOptions_MirrorPadOptions = 77,
   BuiltinOptions_AbsOptions = 78,
   BuiltinOptions_SplitVOptions = 79,
+  BuiltinOptions_InstanceNormOptions = 80,
   BuiltinOptions_MIN = BuiltinOptions_NONE,
-  BuiltinOptions_MAX = BuiltinOptions_SplitVOptions
+  BuiltinOptions_MAX = BuiltinOptions_InstanceNormOptions
 };
 
-inline const BuiltinOptions (&EnumValuesBuiltinOptions())[80]
+inline const BuiltinOptions (&EnumValuesBuiltinOptions())[81]
 {
   static const BuiltinOptions values[] = {BuiltinOptions_NONE,
                                           BuiltinOptions_Conv2DOptions,
@@ -775,7 +932,8 @@ inline const BuiltinOptions (&EnumValuesBuiltinOptions())[80]
                                           BuiltinOptions_SquaredDifferenceOptions,
                                           BuiltinOptions_MirrorPadOptions,
                                           BuiltinOptions_AbsOptions,
-                                          BuiltinOptions_SplitVOptions};
+                                          BuiltinOptions_SplitVOptions,
+                                          BuiltinOptions_InstanceNormOptions};
   return values;
 }
 
@@ -861,6 +1019,7 @@ inline const char *const *EnumNamesBuiltinOptions()
                                       "MirrorPadOptions",
                                       "AbsOptions",
                                       "SplitVOptions",
+                                      "InstanceNormOptions",
                                       nullptr};
   return names;
 }
@@ -1271,6 +1430,11 @@ template <> struct BuiltinOptionsTraits<SplitVOptions>
   static const BuiltinOptions enum_value = BuiltinOptions_SplitVOptions;
 };
 
+template <> struct BuiltinOptionsTraits<InstanceNormOptions>
+{
+  static const BuiltinOptions enum_value = BuiltinOptions_InstanceNormOptions;
+};
+
 bool VerifyBuiltinOptions(flatbuffers::Verifier &verifier, const void *obj, BuiltinOptions type);
 bool VerifyBuiltinOptionsVector(flatbuffers::Verifier &verifier,
                                 const flatbuffers::Vector<flatbuffers::Offset<void>> *values,
@@ -5376,6 +5540,61 @@ CreateMirrorPadOptions(flatbuffers::FlatBufferBuilder &_fbb,
   return builder_.Finish();
 }
 
+struct InstanceNormOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
+{
+  enum
+  {
+    VT_EPSILON = 4,
+    VT_FUSED_ACTIVATION_FUNCTION = 6
+  };
+  float epsilon() const { return GetField<float>(VT_EPSILON, 0.0f); }
+  ActivationFunctionType fused_activation_function() const
+  {
+    return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0));
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const
+  {
+    return VerifyTableStart(verifier) && VerifyField<float>(verifier, VT_EPSILON) &&
+           VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && verifier.EndTable();
+  }
+};
+
+struct InstanceNormOptionsBuilder
+{
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_epsilon(float epsilon)
+  {
+    fbb_.AddElement<float>(InstanceNormOptions::VT_EPSILON, epsilon, 0.0f);
+  }
+  void add_fused_activation_function(ActivationFunctionType fused_activation_function)
+  {
+    fbb_.AddElement<int8_t>(InstanceNormOptions::VT_FUSED_ACTIVATION_FUNCTION,
+                            static_cast<int8_t>(fused_activation_function), 0);
+  }
+  explicit InstanceNormOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb)
+  {
+    start_ = fbb_.StartTable();
+  }
+  InstanceNormOptionsBuilder &operator=(const InstanceNormOptionsBuilder &);
+  flatbuffers::Offset<InstanceNormOptions> Finish()
+  {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<InstanceNormOptions>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<InstanceNormOptions> CreateInstanceNormOptions(
+    flatbuffers::FlatBufferBuilder &_fbb, float epsilon = 0.0f,
+    ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE)
+{
+  InstanceNormOptionsBuilder builder_(_fbb);
+  builder_.add_epsilon(epsilon);
+  builder_.add_fused_activation_function(fused_activation_function);
+  return builder_.Finish();
+}
+
 struct OperatorCode FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
 {
   enum
@@ -5956,6 +6175,12 @@ struct Operator FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table
                ? static_cast<const SplitVOptions *>(builtin_options())
                : nullptr;
   }
+  const InstanceNormOptions *builtin_options_as_InstanceNormOptions() const
+  {
+    return builtin_options_type() == BuiltinOptions_InstanceNormOptions
+               ? static_cast<const InstanceNormOptions *>(builtin_options())
+               : nullptr;
+  }
   const flatbuffers::Vector<uint8_t> *custom_options() const
   {
     return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_CUSTOM_OPTIONS);
@@ -6407,6 +6632,12 @@ template <> inline const SplitVOptions *Operator::builtin_options_as<SplitVOptio
   return builtin_options_as_SplitVOptions();
 }
 
+template <>
+inline const InstanceNormOptions *Operator::builtin_options_as<InstanceNormOptions>() const
+{
+  return builtin_options_as_InstanceNormOptions();
+}
+
 struct OperatorBuilder
 {
   flatbuffers::FlatBufferBuilder &fbb_;
@@ -7241,6 +7472,11 @@ inline bool VerifyBuiltinOptions(flatbuffers::Verifier &verifier, const void *ob
       auto ptr = reinterpret_cast<const SplitVOptions *>(obj);
       return verifier.VerifyTable(ptr);
     }
+    case BuiltinOptions_InstanceNormOptions:
+    {
+      auto ptr = reinterpret_cast<const InstanceNormOptions *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
     default:
       return false;
   }