From 2de898a85d800f0e812cc13eff6363e27a377cf5 Mon Sep 17 00:00:00 2001 From: Rickard Bolin Date: Mon, 20 Dec 2021 08:35:23 +0000 Subject: MLBEDSW-4870: Update to TensorFlow 2.7 Update the flatbuffers generated code to comply with TensorFlow 2.7 Signed-off-by: Rickard Bolin Change-Id: Iff29b05a6e145245861329b4ff9fc9fbd968da53 --- ethosu/vela/operation.py | 5 ++ ethosu/vela/tflite/AbsOptions.py | 12 ++++- ethosu/vela/tflite/ActivationFunctionType.py | 1 - ethosu/vela/tflite/AddNOptions.py | 12 ++++- ethosu/vela/tflite/AddOptions.py | 16 ++++++- ethosu/vela/tflite/ArgMaxOptions.py | 14 +++++- ethosu/vela/tflite/ArgMinOptions.py | 14 +++++- ethosu/vela/tflite/AssignVariableOptions.py | 36 ++++++++++++++ ethosu/vela/tflite/BatchMatMulOptions.py | 18 ++++++- ethosu/vela/tflite/BatchToSpaceNDOptions.py | 12 ++++- .../tflite/BidirectionalSequenceLSTMOptions.py | 24 +++++++++- .../vela/tflite/BidirectionalSequenceRNNOptions.py | 20 +++++++- ethosu/vela/tflite/BroadcastToOptions.py | 12 ++++- ethosu/vela/tflite/Buffer.py | 16 ++++++- ethosu/vela/tflite/BuiltinOperator.py | 6 ++- ethosu/vela/tflite/BuiltinOptions.py | 5 +- ethosu/vela/tflite/CallOnceOptions.py | 14 +++++- ethosu/vela/tflite/CallOptions.py | 14 +++++- ethosu/vela/tflite/CastOptions.py | 16 ++++++- ethosu/vela/tflite/CombinerType.py | 1 - ethosu/vela/tflite/ConcatEmbeddingsOptions.py | 22 ++++++++- ethosu/vela/tflite/ConcatenationOptions.py | 16 ++++++- ethosu/vela/tflite/Conv2DOptions.py | 24 +++++++++- ethosu/vela/tflite/Conv3DOptions.py | 28 ++++++++++- ethosu/vela/tflite/CosOptions.py | 12 ++++- ethosu/vela/tflite/CumsumOptions.py | 16 ++++++- ethosu/vela/tflite/CustomOptionsFormat.py | 1 - ethosu/vela/tflite/CustomQuantization.py | 16 ++++++- ethosu/vela/tflite/DensifyOptions.py | 12 ++++- ethosu/vela/tflite/DepthToSpaceOptions.py | 14 +++++- ethosu/vela/tflite/DepthwiseConv2DOptions.py | 26 +++++++++- ethosu/vela/tflite/DequantizeOptions.py | 12 ++++- ethosu/vela/tflite/DimensionMetadata.py | 24 +++++++++- ethosu/vela/tflite/DimensionType.py | 1 - ethosu/vela/tflite/DivOptions.py | 14 +++++- ethosu/vela/tflite/EmbeddingLookupSparseOptions.py | 14 +++++- ethosu/vela/tflite/EqualOptions.py | 12 ++++- ethosu/vela/tflite/ExpOptions.py | 12 ++++- ethosu/vela/tflite/ExpandDimsOptions.py | 12 ++++- ethosu/vela/tflite/FakeQuantOptions.py | 20 +++++++- ethosu/vela/tflite/FillOptions.py | 12 ++++- ethosu/vela/tflite/FloorDivOptions.py | 12 ++++- ethosu/vela/tflite/FloorModOptions.py | 12 ++++- ethosu/vela/tflite/FullyConnectedOptions.py | 20 +++++++- .../tflite/FullyConnectedOptionsWeightsFormat.py | 1 - ethosu/vela/tflite/GatherNdOptions.py | 12 ++++- ethosu/vela/tflite/GatherOptions.py | 16 ++++++- ethosu/vela/tflite/GreaterEqualOptions.py | 12 ++++- ethosu/vela/tflite/GreaterOptions.py | 12 ++++- ethosu/vela/tflite/HardSwishOptions.py | 12 ++++- ethosu/vela/tflite/HashtableFindOptions.py | 12 ++++- ethosu/vela/tflite/HashtableImportOptions.py | 12 ++++- ethosu/vela/tflite/HashtableOptions.py | 18 ++++++- ethosu/vela/tflite/HashtableSizeOptions.py | 12 ++++- ethosu/vela/tflite/IfOptions.py | 16 ++++++- ethosu/vela/tflite/Int32Vector.py | 16 ++++++- ethosu/vela/tflite/L2NormOptions.py | 14 +++++- ethosu/vela/tflite/LSHProjectionOptions.py | 14 +++++- ethosu/vela/tflite/LSHProjectionType.py | 1 - ethosu/vela/tflite/LSTMKernelType.py | 1 - ethosu/vela/tflite/LSTMOptions.py | 22 ++++++++- ethosu/vela/tflite/LeakyReluOptions.py | 14 +++++- ethosu/vela/tflite/LessEqualOptions.py | 12 ++++- ethosu/vela/tflite/LessOptions.py | 12 ++++- .../tflite/LocalResponseNormalizationOptions.py | 20 +++++++- ethosu/vela/tflite/LogSoftmaxOptions.py | 12 ++++- ethosu/vela/tflite/LogicalAndOptions.py | 12 ++++- ethosu/vela/tflite/LogicalNotOptions.py | 12 ++++- ethosu/vela/tflite/LogicalOrOptions.py | 12 ++++- ethosu/vela/tflite/MatrixDiagOptions.py | 12 ++++- ethosu/vela/tflite/MatrixSetDiagOptions.py | 12 ++++- ethosu/vela/tflite/MaximumMinimumOptions.py | 12 ++++- ethosu/vela/tflite/Metadata.py | 16 ++++++- ethosu/vela/tflite/MirrorPadMode.py | 1 - ethosu/vela/tflite/MirrorPadOptions.py | 14 +++++- ethosu/vela/tflite/Model.py | 40 +++++++++++++++- ethosu/vela/tflite/MulOptions.py | 14 +++++- ethosu/vela/tflite/NegOptions.py | 12 ++++- ethosu/vela/tflite/NonMaxSuppressionV4Options.py | 12 ++++- ethosu/vela/tflite/NonMaxSuppressionV5Options.py | 12 ++++- ethosu/vela/tflite/NotEqualOptions.py | 12 ++++- ethosu/vela/tflite/OneHotOptions.py | 14 +++++- ethosu/vela/tflite/Operator.py | 40 +++++++++++++++- ethosu/vela/tflite/OperatorCode.py | 20 +++++++- ethosu/vela/tflite/PackOptions.py | 16 ++++++- ethosu/vela/tflite/PadOptions.py | 12 ++++- ethosu/vela/tflite/PadV2Options.py | 12 ++++- ethosu/vela/tflite/Padding.py | 1 - ethosu/vela/tflite/Pool2DOptions.py | 24 +++++++++- ethosu/vela/tflite/PowOptions.py | 12 ++++- ethosu/vela/tflite/QuantizationDetails.py | 1 - ethosu/vela/tflite/QuantizationParameters.py | 32 ++++++++++++- ethosu/vela/tflite/QuantizeOptions.py | 10 +++- ethosu/vela/tflite/RNNOptions.py | 14 +++++- ethosu/vela/tflite/RandomOptions.py | 56 ++++++++++++++++++++++ ethosu/vela/tflite/RangeOptions.py | 10 +++- ethosu/vela/tflite/RankOptions.py | 10 +++- ethosu/vela/tflite/ReadVariableOptions.py | 36 ++++++++++++++ ethosu/vela/tflite/ReducerOptions.py | 12 ++++- ethosu/vela/tflite/ReshapeOptions.py | 14 +++++- ethosu/vela/tflite/ResizeBilinearOptions.py | 14 +++++- ethosu/vela/tflite/ResizeNearestNeighborOptions.py | 14 +++++- ethosu/vela/tflite/ReverseSequenceOptions.py | 14 +++++- ethosu/vela/tflite/ReverseV2Options.py | 10 +++- ethosu/vela/tflite/Rfft2dOptions.py | 10 +++- ethosu/vela/tflite/SVDFOptions.py | 16 ++++++- ethosu/vela/tflite/ScatterNdOptions.py | 10 +++- ethosu/vela/tflite/SegmentSumOptions.py | 10 +++- ethosu/vela/tflite/SelectOptions.py | 10 +++- ethosu/vela/tflite/SelectV2Options.py | 10 +++- ethosu/vela/tflite/SequenceRNNOptions.py | 16 ++++++- ethosu/vela/tflite/ShapeOptions.py | 12 ++++- ethosu/vela/tflite/SignatureDef.py | 42 +++++++++++----- ethosu/vela/tflite/SkipGramOptions.py | 16 ++++++- ethosu/vela/tflite/SliceOptions.py | 10 +++- ethosu/vela/tflite/SoftmaxOptions.py | 12 ++++- ethosu/vela/tflite/SpaceToBatchNDOptions.py | 10 +++- ethosu/vela/tflite/SpaceToDepthOptions.py | 12 ++++- ethosu/vela/tflite/SparseIndexVector.py | 1 - ethosu/vela/tflite/SparseToDenseOptions.py | 12 ++++- ethosu/vela/tflite/SparsityParameters.py | 24 +++++++++- ethosu/vela/tflite/SplitOptions.py | 12 ++++- ethosu/vela/tflite/SplitVOptions.py | 12 ++++- ethosu/vela/tflite/SquareOptions.py | 10 +++- ethosu/vela/tflite/SquaredDifferenceOptions.py | 10 +++- ethosu/vela/tflite/SqueezeOptions.py | 14 +++++- ethosu/vela/tflite/StridedSliceOptions.py | 20 +++++++- ethosu/vela/tflite/SubGraph.py | 28 ++++++++++- ethosu/vela/tflite/SubOptions.py | 14 +++++- ethosu/vela/tflite/Tensor.py | 30 +++++++++++- ethosu/vela/tflite/TensorMap.py | 14 +++++- ethosu/vela/tflite/TensorType.py | 1 - ethosu/vela/tflite/TileOptions.py | 10 +++- ethosu/vela/tflite/TopKV2Options.py | 10 +++- ethosu/vela/tflite/TransposeConvOptions.py | 16 ++++++- ethosu/vela/tflite/TransposeOptions.py | 10 +++- ethosu/vela/tflite/Uint16Vector.py | 14 +++++- ethosu/vela/tflite/Uint8Vector.py | 14 +++++- .../tflite/UnidirectionalSequenceLSTMOptions.py | 20 +++++++- ethosu/vela/tflite/UniqueOptions.py | 12 ++++- ethosu/vela/tflite/UnpackOptions.py | 14 +++++- ethosu/vela/tflite/VarHandleOptions.py | 56 ++++++++++++++++++++++ ethosu/vela/tflite/WhereOptions.py | 10 +++- ethosu/vela/tflite/WhileOptions.py | 14 +++++- ethosu/vela/tflite/ZerosLikeOptions.py | 10 +++- ethosu/vela/tflite_mapping.py | 22 +++++++++ 146 files changed, 1987 insertions(+), 151 deletions(-) create mode 100644 ethosu/vela/tflite/AssignVariableOptions.py create mode 100644 ethosu/vela/tflite/RandomOptions.py create mode 100644 ethosu/vela/tflite/ReadVariableOptions.py create mode 100644 ethosu/vela/tflite/VarHandleOptions.py diff --git a/ethosu/vela/operation.py b/ethosu/vela/operation.py index 1707d318..277f2de5 100644 --- a/ethosu/vela/operation.py +++ b/ethosu/vela/operation.py @@ -307,6 +307,11 @@ class Op(Enum): HashtableSize = OperatorInfo() ReduceAll = OperatorInfo() Conv3DTranspose = OperatorInfo() + VarHandle = OperatorInfo() + ReadVariable = OperatorInfo() + AssignVariable = OperatorInfo() + BroadcastArgs = OperatorInfo() + RandomStandardNormal = OperatorInfo() @property def info(self): diff --git a/ethosu/vela/tflite/AbsOptions.py b/ethosu/vela/tflite/AbsOptions.py index 3da6cb0f..df140416 100644 --- a/ethosu/vela/tflite/AbsOptions.py +++ b/ethosu/vela/tflite/AbsOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class AbsOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsAbsOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = AbsOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsAbsOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def AbsOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -23,4 +29,8 @@ class AbsOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def AbsOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return AbsOptionsStart(builder) def AbsOptionsEnd(builder): return builder.EndObject() +def End(builder): + return AbsOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/ActivationFunctionType.py b/ethosu/vela/tflite/ActivationFunctionType.py index dc177dee..6d8ec952 100644 --- a/ethosu/vela/tflite/ActivationFunctionType.py +++ b/ethosu/vela/tflite/ActivationFunctionType.py @@ -9,4 +9,3 @@ class ActivationFunctionType(object): RELU6 = 3 TANH = 4 SIGN_BIT = 5 - diff --git a/ethosu/vela/tflite/AddNOptions.py b/ethosu/vela/tflite/AddNOptions.py index a29858bd..d3b233d8 100644 --- a/ethosu/vela/tflite/AddNOptions.py +++ b/ethosu/vela/tflite/AddNOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class AddNOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsAddNOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = AddNOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsAddNOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def AddNOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -23,4 +29,8 @@ class AddNOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def AddNOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return AddNOptionsStart(builder) def AddNOptionsEnd(builder): return builder.EndObject() +def End(builder): + return AddNOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/AddOptions.py b/ethosu/vela/tflite/AddOptions.py index f0a232dc..d8a11051 100644 --- a/ethosu/vela/tflite/AddOptions.py +++ b/ethosu/vela/tflite/AddOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class AddOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsAddOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = AddOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsAddOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def AddOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -37,6 +43,14 @@ class AddOptions(object): return True def AddOptionsStart(builder): builder.StartObject(2) +def Start(builder): + return AddOptionsStart(builder) def AddOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(0, fusedActivationFunction, 0) +def AddFusedActivationFunction(builder, fusedActivationFunction): + return AddOptionsAddFusedActivationFunction(builder, fusedActivationFunction) def AddOptionsAddPotScaleInt16(builder, potScaleInt16): builder.PrependBoolSlot(1, potScaleInt16, 1) +def AddPotScaleInt16(builder, potScaleInt16): + return AddOptionsAddPotScaleInt16(builder, potScaleInt16) def AddOptionsEnd(builder): return builder.EndObject() +def End(builder): + return AddOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/ArgMaxOptions.py b/ethosu/vela/tflite/ArgMaxOptions.py index 741135dd..a4728fbb 100644 --- a/ethosu/vela/tflite/ArgMaxOptions.py +++ b/ethosu/vela/tflite/ArgMaxOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class ArgMaxOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsArgMaxOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = ArgMaxOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsArgMaxOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def ArgMaxOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -30,5 +36,11 @@ class ArgMaxOptions(object): return 0 def ArgMaxOptionsStart(builder): builder.StartObject(1) +def Start(builder): + return ArgMaxOptionsStart(builder) def ArgMaxOptionsAddOutputType(builder, outputType): builder.PrependInt8Slot(0, outputType, 0) +def AddOutputType(builder, outputType): + return ArgMaxOptionsAddOutputType(builder, outputType) def ArgMaxOptionsEnd(builder): return builder.EndObject() +def End(builder): + return ArgMaxOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/ArgMinOptions.py b/ethosu/vela/tflite/ArgMinOptions.py index f62455f7..adcdc39c 100644 --- a/ethosu/vela/tflite/ArgMinOptions.py +++ b/ethosu/vela/tflite/ArgMinOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class ArgMinOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsArgMinOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = ArgMinOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsArgMinOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def ArgMinOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -30,5 +36,11 @@ class ArgMinOptions(object): return 0 def ArgMinOptionsStart(builder): builder.StartObject(1) +def Start(builder): + return ArgMinOptionsStart(builder) def ArgMinOptionsAddOutputType(builder, outputType): builder.PrependInt8Slot(0, outputType, 0) +def AddOutputType(builder, outputType): + return ArgMinOptionsAddOutputType(builder, outputType) def ArgMinOptionsEnd(builder): return builder.EndObject() +def End(builder): + return ArgMinOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/AssignVariableOptions.py b/ethosu/vela/tflite/AssignVariableOptions.py new file mode 100644 index 00000000..a06c6291 --- /dev/null +++ b/ethosu/vela/tflite/AssignVariableOptions.py @@ -0,0 +1,36 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class AssignVariableOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = AssignVariableOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsAssignVariableOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def AssignVariableOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # AssignVariableOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + +def AssignVariableOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return AssignVariableOptionsStart(builder) +def AssignVariableOptionsEnd(builder): return builder.EndObject() +def End(builder): + return AssignVariableOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/BatchMatMulOptions.py b/ethosu/vela/tflite/BatchMatMulOptions.py index 771c36e2..061bb0c8 100644 --- a/ethosu/vela/tflite/BatchMatMulOptions.py +++ b/ethosu/vela/tflite/BatchMatMulOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class BatchMatMulOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsBatchMatMulOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = BatchMatMulOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsBatchMatMulOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def BatchMatMulOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -44,7 +50,17 @@ class BatchMatMulOptions(object): return False def BatchMatMulOptionsStart(builder): builder.StartObject(3) +def Start(builder): + return BatchMatMulOptionsStart(builder) def BatchMatMulOptionsAddAdjX(builder, adjX): builder.PrependBoolSlot(0, adjX, 0) +def AddAdjX(builder, adjX): + return BatchMatMulOptionsAddAdjX(builder, adjX) def BatchMatMulOptionsAddAdjY(builder, adjY): builder.PrependBoolSlot(1, adjY, 0) +def AddAdjY(builder, adjY): + return BatchMatMulOptionsAddAdjY(builder, adjY) def BatchMatMulOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): builder.PrependBoolSlot(2, asymmetricQuantizeInputs, 0) +def AddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): + return BatchMatMulOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs) def BatchMatMulOptionsEnd(builder): return builder.EndObject() +def End(builder): + return BatchMatMulOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/BatchToSpaceNDOptions.py b/ethosu/vela/tflite/BatchToSpaceNDOptions.py index 8398ca19..f07813cd 100644 --- a/ethosu/vela/tflite/BatchToSpaceNDOptions.py +++ b/ethosu/vela/tflite/BatchToSpaceNDOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class BatchToSpaceNDOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsBatchToSpaceNDOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = BatchToSpaceNDOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsBatchToSpaceNDOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def BatchToSpaceNDOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -23,4 +29,8 @@ class BatchToSpaceNDOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def BatchToSpaceNDOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return BatchToSpaceNDOptionsStart(builder) def BatchToSpaceNDOptionsEnd(builder): return builder.EndObject() +def End(builder): + return BatchToSpaceNDOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/BidirectionalSequenceLSTMOptions.py b/ethosu/vela/tflite/BidirectionalSequenceLSTMOptions.py index c8af8e2c..25c0c281 100644 --- a/ethosu/vela/tflite/BidirectionalSequenceLSTMOptions.py +++ b/ethosu/vela/tflite/BidirectionalSequenceLSTMOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class BidirectionalSequenceLSTMOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsBidirectionalSequenceLSTMOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = BidirectionalSequenceLSTMOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsBidirectionalSequenceLSTMOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def BidirectionalSequenceLSTMOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -65,10 +71,26 @@ class BidirectionalSequenceLSTMOptions(object): return False def BidirectionalSequenceLSTMOptionsStart(builder): builder.StartObject(6) +def Start(builder): + return BidirectionalSequenceLSTMOptionsStart(builder) def BidirectionalSequenceLSTMOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(0, fusedActivationFunction, 0) +def AddFusedActivationFunction(builder, fusedActivationFunction): + return BidirectionalSequenceLSTMOptionsAddFusedActivationFunction(builder, fusedActivationFunction) def BidirectionalSequenceLSTMOptionsAddCellClip(builder, cellClip): builder.PrependFloat32Slot(1, cellClip, 0.0) +def AddCellClip(builder, cellClip): + return BidirectionalSequenceLSTMOptionsAddCellClip(builder, cellClip) def BidirectionalSequenceLSTMOptionsAddProjClip(builder, projClip): builder.PrependFloat32Slot(2, projClip, 0.0) +def AddProjClip(builder, projClip): + return BidirectionalSequenceLSTMOptionsAddProjClip(builder, projClip) def BidirectionalSequenceLSTMOptionsAddMergeOutputs(builder, mergeOutputs): builder.PrependBoolSlot(3, mergeOutputs, 0) +def AddMergeOutputs(builder, mergeOutputs): + return BidirectionalSequenceLSTMOptionsAddMergeOutputs(builder, mergeOutputs) def BidirectionalSequenceLSTMOptionsAddTimeMajor(builder, timeMajor): builder.PrependBoolSlot(4, timeMajor, 1) +def AddTimeMajor(builder, timeMajor): + return BidirectionalSequenceLSTMOptionsAddTimeMajor(builder, timeMajor) def BidirectionalSequenceLSTMOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): builder.PrependBoolSlot(5, asymmetricQuantizeInputs, 0) +def AddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): + return BidirectionalSequenceLSTMOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs) def BidirectionalSequenceLSTMOptionsEnd(builder): return builder.EndObject() +def End(builder): + return BidirectionalSequenceLSTMOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/BidirectionalSequenceRNNOptions.py b/ethosu/vela/tflite/BidirectionalSequenceRNNOptions.py index 4c6218f3..67c89c8c 100644 --- a/ethosu/vela/tflite/BidirectionalSequenceRNNOptions.py +++ b/ethosu/vela/tflite/BidirectionalSequenceRNNOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class BidirectionalSequenceRNNOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsBidirectionalSequenceRNNOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = BidirectionalSequenceRNNOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsBidirectionalSequenceRNNOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def BidirectionalSequenceRNNOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -51,8 +57,20 @@ class BidirectionalSequenceRNNOptions(object): return False def BidirectionalSequenceRNNOptionsStart(builder): builder.StartObject(4) +def Start(builder): + return BidirectionalSequenceRNNOptionsStart(builder) def BidirectionalSequenceRNNOptionsAddTimeMajor(builder, timeMajor): builder.PrependBoolSlot(0, timeMajor, 0) +def AddTimeMajor(builder, timeMajor): + return BidirectionalSequenceRNNOptionsAddTimeMajor(builder, timeMajor) def BidirectionalSequenceRNNOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(1, fusedActivationFunction, 0) +def AddFusedActivationFunction(builder, fusedActivationFunction): + return BidirectionalSequenceRNNOptionsAddFusedActivationFunction(builder, fusedActivationFunction) def BidirectionalSequenceRNNOptionsAddMergeOutputs(builder, mergeOutputs): builder.PrependBoolSlot(2, mergeOutputs, 0) +def AddMergeOutputs(builder, mergeOutputs): + return BidirectionalSequenceRNNOptionsAddMergeOutputs(builder, mergeOutputs) def BidirectionalSequenceRNNOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): builder.PrependBoolSlot(3, asymmetricQuantizeInputs, 0) +def AddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): + return BidirectionalSequenceRNNOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs) def BidirectionalSequenceRNNOptionsEnd(builder): return builder.EndObject() +def End(builder): + return BidirectionalSequenceRNNOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/BroadcastToOptions.py b/ethosu/vela/tflite/BroadcastToOptions.py index 5d11a9e6..a7f2c707 100644 --- a/ethosu/vela/tflite/BroadcastToOptions.py +++ b/ethosu/vela/tflite/BroadcastToOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class BroadcastToOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsBroadcastToOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = BroadcastToOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsBroadcastToOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def BroadcastToOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -23,4 +29,8 @@ class BroadcastToOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def BroadcastToOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return BroadcastToOptionsStart(builder) def BroadcastToOptionsEnd(builder): return builder.EndObject() +def End(builder): + return BroadcastToOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/Buffer.py b/ethosu/vela/tflite/Buffer.py index 387d7e9a..e9d45a51 100644 --- a/ethosu/vela/tflite/Buffer.py +++ b/ethosu/vela/tflite/Buffer.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class Buffer(object): __slots__ = ['_tab'] @classmethod - def GetRootAsBuffer(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = Buffer() x.Init(buf, n + offset) return x @classmethod + def GetRootAsBuffer(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def BufferBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -50,6 +56,14 @@ class Buffer(object): return o == 0 def BufferStart(builder): builder.StartObject(1) +def Start(builder): + return BufferStart(builder) def BufferAddData(builder, data): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(data), 0) +def AddData(builder, data): + return BufferAddData(builder, data) def BufferStartDataVector(builder, numElems): return builder.StartVector(1, numElems, 1) +def StartDataVector(builder, numElems): + return BufferStartDataVector(builder, numElems) def BufferEnd(builder): return builder.EndObject() +def End(builder): + return BufferEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/BuiltinOperator.py b/ethosu/vela/tflite/BuiltinOperator.py index 46dcab71..47ff6d09 100644 --- a/ethosu/vela/tflite/BuiltinOperator.py +++ b/ethosu/vela/tflite/BuiltinOperator.py @@ -145,4 +145,8 @@ class BuiltinOperator(object): HASHTABLE_SIZE = 139 REDUCE_ALL = 140 CONV_3D_TRANSPOSE = 141 - + VAR_HANDLE = 142 + READ_VARIABLE = 143 + ASSIGN_VARIABLE = 144 + BROADCAST_ARGS = 145 + RANDOM_STANDARD_NORMAL = 146 diff --git a/ethosu/vela/tflite/BuiltinOptions.py b/ethosu/vela/tflite/BuiltinOptions.py index d8076968..120e9b88 100644 --- a/ethosu/vela/tflite/BuiltinOptions.py +++ b/ethosu/vela/tflite/BuiltinOptions.py @@ -114,4 +114,7 @@ class BuiltinOptions(object): HashtableFindOptions = 108 HashtableImportOptions = 109 HashtableSizeOptions = 110 - + VarHandleOptions = 111 + ReadVariableOptions = 112 + AssignVariableOptions = 113 + RandomOptions = 114 diff --git a/ethosu/vela/tflite/CallOnceOptions.py b/ethosu/vela/tflite/CallOnceOptions.py index 5714c330..557979de 100644 --- a/ethosu/vela/tflite/CallOnceOptions.py +++ b/ethosu/vela/tflite/CallOnceOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class CallOnceOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsCallOnceOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = CallOnceOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsCallOnceOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def CallOnceOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -30,5 +36,11 @@ class CallOnceOptions(object): return 0 def CallOnceOptionsStart(builder): builder.StartObject(1) +def Start(builder): + return CallOnceOptionsStart(builder) def CallOnceOptionsAddInitSubgraphIndex(builder, initSubgraphIndex): builder.PrependInt32Slot(0, initSubgraphIndex, 0) +def AddInitSubgraphIndex(builder, initSubgraphIndex): + return CallOnceOptionsAddInitSubgraphIndex(builder, initSubgraphIndex) def CallOnceOptionsEnd(builder): return builder.EndObject() +def End(builder): + return CallOnceOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/CallOptions.py b/ethosu/vela/tflite/CallOptions.py index 3216f8a1..7fa3b555 100644 --- a/ethosu/vela/tflite/CallOptions.py +++ b/ethosu/vela/tflite/CallOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class CallOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsCallOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = CallOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsCallOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def CallOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -30,5 +36,11 @@ class CallOptions(object): return 0 def CallOptionsStart(builder): builder.StartObject(1) +def Start(builder): + return CallOptionsStart(builder) def CallOptionsAddSubgraph(builder, subgraph): builder.PrependUint32Slot(0, subgraph, 0) +def AddSubgraph(builder, subgraph): + return CallOptionsAddSubgraph(builder, subgraph) def CallOptionsEnd(builder): return builder.EndObject() +def End(builder): + return CallOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/CastOptions.py b/ethosu/vela/tflite/CastOptions.py index 1f007650..e97ac8ef 100644 --- a/ethosu/vela/tflite/CastOptions.py +++ b/ethosu/vela/tflite/CastOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class CastOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsCastOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = CastOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsCastOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def CastOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -37,6 +43,14 @@ class CastOptions(object): return 0 def CastOptionsStart(builder): builder.StartObject(2) +def Start(builder): + return CastOptionsStart(builder) def CastOptionsAddInDataType(builder, inDataType): builder.PrependInt8Slot(0, inDataType, 0) +def AddInDataType(builder, inDataType): + return CastOptionsAddInDataType(builder, inDataType) def CastOptionsAddOutDataType(builder, outDataType): builder.PrependInt8Slot(1, outDataType, 0) +def AddOutDataType(builder, outDataType): + return CastOptionsAddOutDataType(builder, outDataType) def CastOptionsEnd(builder): return builder.EndObject() +def End(builder): + return CastOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/CombinerType.py b/ethosu/vela/tflite/CombinerType.py index 17d91510..1e3a61f3 100644 --- a/ethosu/vela/tflite/CombinerType.py +++ b/ethosu/vela/tflite/CombinerType.py @@ -6,4 +6,3 @@ class CombinerType(object): SUM = 0 MEAN = 1 SQRTN = 2 - diff --git a/ethosu/vela/tflite/ConcatEmbeddingsOptions.py b/ethosu/vela/tflite/ConcatEmbeddingsOptions.py index b8d55384..e59bf9b6 100644 --- a/ethosu/vela/tflite/ConcatEmbeddingsOptions.py +++ b/ethosu/vela/tflite/ConcatEmbeddingsOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class ConcatEmbeddingsOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsConcatEmbeddingsOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = ConcatEmbeddingsOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsConcatEmbeddingsOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def ConcatEmbeddingsOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -84,9 +90,23 @@ class ConcatEmbeddingsOptions(object): return o == 0 def ConcatEmbeddingsOptionsStart(builder): builder.StartObject(3) +def Start(builder): + return ConcatEmbeddingsOptionsStart(builder) def ConcatEmbeddingsOptionsAddNumChannels(builder, numChannels): builder.PrependInt32Slot(0, numChannels, 0) +def AddNumChannels(builder, numChannels): + return ConcatEmbeddingsOptionsAddNumChannels(builder, numChannels) def ConcatEmbeddingsOptionsAddNumColumnsPerChannel(builder, numColumnsPerChannel): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(numColumnsPerChannel), 0) +def AddNumColumnsPerChannel(builder, numColumnsPerChannel): + return ConcatEmbeddingsOptionsAddNumColumnsPerChannel(builder, numColumnsPerChannel) def ConcatEmbeddingsOptionsStartNumColumnsPerChannelVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def StartNumColumnsPerChannelVector(builder, numElems): + return ConcatEmbeddingsOptionsStartNumColumnsPerChannelVector(builder, numElems) def ConcatEmbeddingsOptionsAddEmbeddingDimPerChannel(builder, embeddingDimPerChannel): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(embeddingDimPerChannel), 0) +def AddEmbeddingDimPerChannel(builder, embeddingDimPerChannel): + return ConcatEmbeddingsOptionsAddEmbeddingDimPerChannel(builder, embeddingDimPerChannel) def ConcatEmbeddingsOptionsStartEmbeddingDimPerChannelVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def StartEmbeddingDimPerChannelVector(builder, numElems): + return ConcatEmbeddingsOptionsStartEmbeddingDimPerChannelVector(builder, numElems) def ConcatEmbeddingsOptionsEnd(builder): return builder.EndObject() +def End(builder): + return ConcatEmbeddingsOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/ConcatenationOptions.py b/ethosu/vela/tflite/ConcatenationOptions.py index f6928a6b..5016a24e 100644 --- a/ethosu/vela/tflite/ConcatenationOptions.py +++ b/ethosu/vela/tflite/ConcatenationOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class ConcatenationOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsConcatenationOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = ConcatenationOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsConcatenationOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def ConcatenationOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -37,6 +43,14 @@ class ConcatenationOptions(object): return 0 def ConcatenationOptionsStart(builder): builder.StartObject(2) +def Start(builder): + return ConcatenationOptionsStart(builder) def ConcatenationOptionsAddAxis(builder, axis): builder.PrependInt32Slot(0, axis, 0) +def AddAxis(builder, axis): + return ConcatenationOptionsAddAxis(builder, axis) def ConcatenationOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(1, fusedActivationFunction, 0) +def AddFusedActivationFunction(builder, fusedActivationFunction): + return ConcatenationOptionsAddFusedActivationFunction(builder, fusedActivationFunction) def ConcatenationOptionsEnd(builder): return builder.EndObject() +def End(builder): + return ConcatenationOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/Conv2DOptions.py b/ethosu/vela/tflite/Conv2DOptions.py index a05b39cb..5928009f 100644 --- a/ethosu/vela/tflite/Conv2DOptions.py +++ b/ethosu/vela/tflite/Conv2DOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class Conv2DOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsConv2DOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = Conv2DOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsConv2DOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def Conv2DOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -65,10 +71,26 @@ class Conv2DOptions(object): return 1 def Conv2DOptionsStart(builder): builder.StartObject(6) +def Start(builder): + return Conv2DOptionsStart(builder) def Conv2DOptionsAddPadding(builder, padding): builder.PrependInt8Slot(0, padding, 0) +def AddPadding(builder, padding): + return Conv2DOptionsAddPadding(builder, padding) def Conv2DOptionsAddStrideW(builder, strideW): builder.PrependInt32Slot(1, strideW, 0) +def AddStrideW(builder, strideW): + return Conv2DOptionsAddStrideW(builder, strideW) def Conv2DOptionsAddStrideH(builder, strideH): builder.PrependInt32Slot(2, strideH, 0) +def AddStrideH(builder, strideH): + return Conv2DOptionsAddStrideH(builder, strideH) def Conv2DOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(3, fusedActivationFunction, 0) +def AddFusedActivationFunction(builder, fusedActivationFunction): + return Conv2DOptionsAddFusedActivationFunction(builder, fusedActivationFunction) def Conv2DOptionsAddDilationWFactor(builder, dilationWFactor): builder.PrependInt32Slot(4, dilationWFactor, 1) +def AddDilationWFactor(builder, dilationWFactor): + return Conv2DOptionsAddDilationWFactor(builder, dilationWFactor) def Conv2DOptionsAddDilationHFactor(builder, dilationHFactor): builder.PrependInt32Slot(5, dilationHFactor, 1) +def AddDilationHFactor(builder, dilationHFactor): + return Conv2DOptionsAddDilationHFactor(builder, dilationHFactor) def Conv2DOptionsEnd(builder): return builder.EndObject() +def End(builder): + return Conv2DOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/Conv3DOptions.py b/ethosu/vela/tflite/Conv3DOptions.py index 0f998600..a4e604d2 100644 --- a/ethosu/vela/tflite/Conv3DOptions.py +++ b/ethosu/vela/tflite/Conv3DOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class Conv3DOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsConv3DOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = Conv3DOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsConv3DOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def Conv3DOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -79,12 +85,32 @@ class Conv3DOptions(object): return 1 def Conv3DOptionsStart(builder): builder.StartObject(8) +def Start(builder): + return Conv3DOptionsStart(builder) def Conv3DOptionsAddPadding(builder, padding): builder.PrependInt8Slot(0, padding, 0) +def AddPadding(builder, padding): + return Conv3DOptionsAddPadding(builder, padding) def Conv3DOptionsAddStrideD(builder, strideD): builder.PrependInt32Slot(1, strideD, 0) +def AddStrideD(builder, strideD): + return Conv3DOptionsAddStrideD(builder, strideD) def Conv3DOptionsAddStrideW(builder, strideW): builder.PrependInt32Slot(2, strideW, 0) +def AddStrideW(builder, strideW): + return Conv3DOptionsAddStrideW(builder, strideW) def Conv3DOptionsAddStrideH(builder, strideH): builder.PrependInt32Slot(3, strideH, 0) +def AddStrideH(builder, strideH): + return Conv3DOptionsAddStrideH(builder, strideH) def Conv3DOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(4, fusedActivationFunction, 0) +def AddFusedActivationFunction(builder, fusedActivationFunction): + return Conv3DOptionsAddFusedActivationFunction(builder, fusedActivationFunction) def Conv3DOptionsAddDilationDFactor(builder, dilationDFactor): builder.PrependInt32Slot(5, dilationDFactor, 1) +def AddDilationDFactor(builder, dilationDFactor): + return Conv3DOptionsAddDilationDFactor(builder, dilationDFactor) def Conv3DOptionsAddDilationWFactor(builder, dilationWFactor): builder.PrependInt32Slot(6, dilationWFactor, 1) +def AddDilationWFactor(builder, dilationWFactor): + return Conv3DOptionsAddDilationWFactor(builder, dilationWFactor) def Conv3DOptionsAddDilationHFactor(builder, dilationHFactor): builder.PrependInt32Slot(7, dilationHFactor, 1) +def AddDilationHFactor(builder, dilationHFactor): + return Conv3DOptionsAddDilationHFactor(builder, dilationHFactor) def Conv3DOptionsEnd(builder): return builder.EndObject() +def End(builder): + return Conv3DOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/CosOptions.py b/ethosu/vela/tflite/CosOptions.py index 12d49268..e64d5bdd 100644 --- a/ethosu/vela/tflite/CosOptions.py +++ b/ethosu/vela/tflite/CosOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class CosOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsCosOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = CosOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsCosOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def CosOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -23,4 +29,8 @@ class CosOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def CosOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return CosOptionsStart(builder) def CosOptionsEnd(builder): return builder.EndObject() +def End(builder): + return CosOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/CumsumOptions.py b/ethosu/vela/tflite/CumsumOptions.py index 91c45865..de83dfa3 100644 --- a/ethosu/vela/tflite/CumsumOptions.py +++ b/ethosu/vela/tflite/CumsumOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class CumsumOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsCumsumOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = CumsumOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsCumsumOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def CumsumOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -37,6 +43,14 @@ class CumsumOptions(object): return False def CumsumOptionsStart(builder): builder.StartObject(2) +def Start(builder): + return CumsumOptionsStart(builder) def CumsumOptionsAddExclusive(builder, exclusive): builder.PrependBoolSlot(0, exclusive, 0) +def AddExclusive(builder, exclusive): + return CumsumOptionsAddExclusive(builder, exclusive) def CumsumOptionsAddReverse(builder, reverse): builder.PrependBoolSlot(1, reverse, 0) +def AddReverse(builder, reverse): + return CumsumOptionsAddReverse(builder, reverse) def CumsumOptionsEnd(builder): return builder.EndObject() +def End(builder): + return CumsumOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/CustomOptionsFormat.py b/ethosu/vela/tflite/CustomOptionsFormat.py index bef384cf..c2fc07c2 100644 --- a/ethosu/vela/tflite/CustomOptionsFormat.py +++ b/ethosu/vela/tflite/CustomOptionsFormat.py @@ -4,4 +4,3 @@ class CustomOptionsFormat(object): FLEXBUFFERS = 0 - diff --git a/ethosu/vela/tflite/CustomQuantization.py b/ethosu/vela/tflite/CustomQuantization.py index f0ed6f00..35f0aeaf 100644 --- a/ethosu/vela/tflite/CustomQuantization.py +++ b/ethosu/vela/tflite/CustomQuantization.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class CustomQuantization(object): __slots__ = ['_tab'] @classmethod - def GetRootAsCustomQuantization(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = CustomQuantization() x.Init(buf, n + offset) return x @classmethod + def GetRootAsCustomQuantization(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def CustomQuantizationBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -50,6 +56,14 @@ class CustomQuantization(object): return o == 0 def CustomQuantizationStart(builder): builder.StartObject(1) +def Start(builder): + return CustomQuantizationStart(builder) def CustomQuantizationAddCustom(builder, custom): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(custom), 0) +def AddCustom(builder, custom): + return CustomQuantizationAddCustom(builder, custom) def CustomQuantizationStartCustomVector(builder, numElems): return builder.StartVector(1, numElems, 1) +def StartCustomVector(builder, numElems): + return CustomQuantizationStartCustomVector(builder, numElems) def CustomQuantizationEnd(builder): return builder.EndObject() +def End(builder): + return CustomQuantizationEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/DensifyOptions.py b/ethosu/vela/tflite/DensifyOptions.py index 067b871c..9b107176 100644 --- a/ethosu/vela/tflite/DensifyOptions.py +++ b/ethosu/vela/tflite/DensifyOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class DensifyOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsDensifyOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = DensifyOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsDensifyOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def DensifyOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -23,4 +29,8 @@ class DensifyOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def DensifyOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return DensifyOptionsStart(builder) def DensifyOptionsEnd(builder): return builder.EndObject() +def End(builder): + return DensifyOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/DepthToSpaceOptions.py b/ethosu/vela/tflite/DepthToSpaceOptions.py index e6b44f42..779da401 100644 --- a/ethosu/vela/tflite/DepthToSpaceOptions.py +++ b/ethosu/vela/tflite/DepthToSpaceOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class DepthToSpaceOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsDepthToSpaceOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = DepthToSpaceOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsDepthToSpaceOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def DepthToSpaceOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -30,5 +36,11 @@ class DepthToSpaceOptions(object): return 0 def DepthToSpaceOptionsStart(builder): builder.StartObject(1) +def Start(builder): + return DepthToSpaceOptionsStart(builder) def DepthToSpaceOptionsAddBlockSize(builder, blockSize): builder.PrependInt32Slot(0, blockSize, 0) +def AddBlockSize(builder, blockSize): + return DepthToSpaceOptionsAddBlockSize(builder, blockSize) def DepthToSpaceOptionsEnd(builder): return builder.EndObject() +def End(builder): + return DepthToSpaceOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/DepthwiseConv2DOptions.py b/ethosu/vela/tflite/DepthwiseConv2DOptions.py index 50dcdbfb..25ea10ed 100644 --- a/ethosu/vela/tflite/DepthwiseConv2DOptions.py +++ b/ethosu/vela/tflite/DepthwiseConv2DOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class DepthwiseConv2DOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsDepthwiseConv2DOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = DepthwiseConv2DOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsDepthwiseConv2DOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def DepthwiseConv2DOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -72,11 +78,29 @@ class DepthwiseConv2DOptions(object): return 1 def DepthwiseConv2DOptionsStart(builder): builder.StartObject(7) +def Start(builder): + return DepthwiseConv2DOptionsStart(builder) def DepthwiseConv2DOptionsAddPadding(builder, padding): builder.PrependInt8Slot(0, padding, 0) +def AddPadding(builder, padding): + return DepthwiseConv2DOptionsAddPadding(builder, padding) def DepthwiseConv2DOptionsAddStrideW(builder, strideW): builder.PrependInt32Slot(1, strideW, 0) +def AddStrideW(builder, strideW): + return DepthwiseConv2DOptionsAddStrideW(builder, strideW) def DepthwiseConv2DOptionsAddStrideH(builder, strideH): builder.PrependInt32Slot(2, strideH, 0) +def AddStrideH(builder, strideH): + return DepthwiseConv2DOptionsAddStrideH(builder, strideH) def DepthwiseConv2DOptionsAddDepthMultiplier(builder, depthMultiplier): builder.PrependInt32Slot(3, depthMultiplier, 0) +def AddDepthMultiplier(builder, depthMultiplier): + return DepthwiseConv2DOptionsAddDepthMultiplier(builder, depthMultiplier) def DepthwiseConv2DOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(4, fusedActivationFunction, 0) +def AddFusedActivationFunction(builder, fusedActivationFunction): + return DepthwiseConv2DOptionsAddFusedActivationFunction(builder, fusedActivationFunction) def DepthwiseConv2DOptionsAddDilationWFactor(builder, dilationWFactor): builder.PrependInt32Slot(5, dilationWFactor, 1) +def AddDilationWFactor(builder, dilationWFactor): + return DepthwiseConv2DOptionsAddDilationWFactor(builder, dilationWFactor) def DepthwiseConv2DOptionsAddDilationHFactor(builder, dilationHFactor): builder.PrependInt32Slot(6, dilationHFactor, 1) +def AddDilationHFactor(builder, dilationHFactor): + return DepthwiseConv2DOptionsAddDilationHFactor(builder, dilationHFactor) def DepthwiseConv2DOptionsEnd(builder): return builder.EndObject() +def End(builder): + return DepthwiseConv2DOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/DequantizeOptions.py b/ethosu/vela/tflite/DequantizeOptions.py index bd9f2e2d..8361c375 100644 --- a/ethosu/vela/tflite/DequantizeOptions.py +++ b/ethosu/vela/tflite/DequantizeOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class DequantizeOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsDequantizeOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = DequantizeOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsDequantizeOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def DequantizeOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -23,4 +29,8 @@ class DequantizeOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def DequantizeOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return DequantizeOptionsStart(builder) def DequantizeOptionsEnd(builder): return builder.EndObject() +def End(builder): + return DequantizeOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/DimensionMetadata.py b/ethosu/vela/tflite/DimensionMetadata.py index 1f8b60dc..d329dd35 100644 --- a/ethosu/vela/tflite/DimensionMetadata.py +++ b/ethosu/vela/tflite/DimensionMetadata.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class DimensionMetadata(object): __slots__ = ['_tab'] @classmethod - def GetRootAsDimensionMetadata(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = DimensionMetadata() x.Init(buf, n + offset) return x @classmethod + def GetRootAsDimensionMetadata(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def DimensionMetadataBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -71,10 +77,26 @@ class DimensionMetadata(object): return None def DimensionMetadataStart(builder): builder.StartObject(6) +def Start(builder): + return DimensionMetadataStart(builder) def DimensionMetadataAddFormat(builder, format): builder.PrependInt8Slot(0, format, 0) +def AddFormat(builder, format): + return DimensionMetadataAddFormat(builder, format) def DimensionMetadataAddDenseSize(builder, denseSize): builder.PrependInt32Slot(1, denseSize, 0) +def AddDenseSize(builder, denseSize): + return DimensionMetadataAddDenseSize(builder, denseSize) def DimensionMetadataAddArraySegmentsType(builder, arraySegmentsType): builder.PrependUint8Slot(2, arraySegmentsType, 0) +def AddArraySegmentsType(builder, arraySegmentsType): + return DimensionMetadataAddArraySegmentsType(builder, arraySegmentsType) def DimensionMetadataAddArraySegments(builder, arraySegments): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(arraySegments), 0) +def AddArraySegments(builder, arraySegments): + return DimensionMetadataAddArraySegments(builder, arraySegments) def DimensionMetadataAddArrayIndicesType(builder, arrayIndicesType): builder.PrependUint8Slot(4, arrayIndicesType, 0) +def AddArrayIndicesType(builder, arrayIndicesType): + return DimensionMetadataAddArrayIndicesType(builder, arrayIndicesType) def DimensionMetadataAddArrayIndices(builder, arrayIndices): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(arrayIndices), 0) +def AddArrayIndices(builder, arrayIndices): + return DimensionMetadataAddArrayIndices(builder, arrayIndices) def DimensionMetadataEnd(builder): return builder.EndObject() +def End(builder): + return DimensionMetadataEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/DimensionType.py b/ethosu/vela/tflite/DimensionType.py index a27d016f..310d8eed 100644 --- a/ethosu/vela/tflite/DimensionType.py +++ b/ethosu/vela/tflite/DimensionType.py @@ -5,4 +5,3 @@ class DimensionType(object): DENSE = 0 SPARSE_CSR = 1 - diff --git a/ethosu/vela/tflite/DivOptions.py b/ethosu/vela/tflite/DivOptions.py index 2988a8e3..e6b4e240 100644 --- a/ethosu/vela/tflite/DivOptions.py +++ b/ethosu/vela/tflite/DivOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class DivOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsDivOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = DivOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsDivOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def DivOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -30,5 +36,11 @@ class DivOptions(object): return 0 def DivOptionsStart(builder): builder.StartObject(1) +def Start(builder): + return DivOptionsStart(builder) def DivOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(0, fusedActivationFunction, 0) +def AddFusedActivationFunction(builder, fusedActivationFunction): + return DivOptionsAddFusedActivationFunction(builder, fusedActivationFunction) def DivOptionsEnd(builder): return builder.EndObject() +def End(builder): + return DivOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/EmbeddingLookupSparseOptions.py b/ethosu/vela/tflite/EmbeddingLookupSparseOptions.py index eaa83569..6bc0539a 100644 --- a/ethosu/vela/tflite/EmbeddingLookupSparseOptions.py +++ b/ethosu/vela/tflite/EmbeddingLookupSparseOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class EmbeddingLookupSparseOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsEmbeddingLookupSparseOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = EmbeddingLookupSparseOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsEmbeddingLookupSparseOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def EmbeddingLookupSparseOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -30,5 +36,11 @@ class EmbeddingLookupSparseOptions(object): return 0 def EmbeddingLookupSparseOptionsStart(builder): builder.StartObject(1) +def Start(builder): + return EmbeddingLookupSparseOptionsStart(builder) def EmbeddingLookupSparseOptionsAddCombiner(builder, combiner): builder.PrependInt8Slot(0, combiner, 0) +def AddCombiner(builder, combiner): + return EmbeddingLookupSparseOptionsAddCombiner(builder, combiner) def EmbeddingLookupSparseOptionsEnd(builder): return builder.EndObject() +def End(builder): + return EmbeddingLookupSparseOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/EqualOptions.py b/ethosu/vela/tflite/EqualOptions.py index b7b14bb3..99c967d7 100644 --- a/ethosu/vela/tflite/EqualOptions.py +++ b/ethosu/vela/tflite/EqualOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class EqualOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsEqualOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = EqualOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsEqualOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def EqualOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -23,4 +29,8 @@ class EqualOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def EqualOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return EqualOptionsStart(builder) def EqualOptionsEnd(builder): return builder.EndObject() +def End(builder): + return EqualOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/ExpOptions.py b/ethosu/vela/tflite/ExpOptions.py index ea1cfead..557c45c1 100644 --- a/ethosu/vela/tflite/ExpOptions.py +++ b/ethosu/vela/tflite/ExpOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class ExpOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsExpOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = ExpOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsExpOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def ExpOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -23,4 +29,8 @@ class ExpOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def ExpOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return ExpOptionsStart(builder) def ExpOptionsEnd(builder): return builder.EndObject() +def End(builder): + return ExpOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/ExpandDimsOptions.py b/ethosu/vela/tflite/ExpandDimsOptions.py index 2350c6e7..dcfbd191 100644 --- a/ethosu/vela/tflite/ExpandDimsOptions.py +++ b/ethosu/vela/tflite/ExpandDimsOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class ExpandDimsOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsExpandDimsOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = ExpandDimsOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsExpandDimsOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def ExpandDimsOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -23,4 +29,8 @@ class ExpandDimsOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def ExpandDimsOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return ExpandDimsOptionsStart(builder) def ExpandDimsOptionsEnd(builder): return builder.EndObject() +def End(builder): + return ExpandDimsOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/FakeQuantOptions.py b/ethosu/vela/tflite/FakeQuantOptions.py index d97da180..e8d951d5 100644 --- a/ethosu/vela/tflite/FakeQuantOptions.py +++ b/ethosu/vela/tflite/FakeQuantOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class FakeQuantOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsFakeQuantOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = FakeQuantOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsFakeQuantOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def FakeQuantOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -51,8 +57,20 @@ class FakeQuantOptions(object): return False def FakeQuantOptionsStart(builder): builder.StartObject(4) +def Start(builder): + return FakeQuantOptionsStart(builder) def FakeQuantOptionsAddMin(builder, min): builder.PrependFloat32Slot(0, min, 0.0) +def AddMin(builder, min): + return FakeQuantOptionsAddMin(builder, min) def FakeQuantOptionsAddMax(builder, max): builder.PrependFloat32Slot(1, max, 0.0) +def AddMax(builder, max): + return FakeQuantOptionsAddMax(builder, max) def FakeQuantOptionsAddNumBits(builder, numBits): builder.PrependInt32Slot(2, numBits, 0) +def AddNumBits(builder, numBits): + return FakeQuantOptionsAddNumBits(builder, numBits) def FakeQuantOptionsAddNarrowRange(builder, narrowRange): builder.PrependBoolSlot(3, narrowRange, 0) +def AddNarrowRange(builder, narrowRange): + return FakeQuantOptionsAddNarrowRange(builder, narrowRange) def FakeQuantOptionsEnd(builder): return builder.EndObject() +def End(builder): + return FakeQuantOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/FillOptions.py b/ethosu/vela/tflite/FillOptions.py index f6b2ca3a..175c93c0 100644 --- a/ethosu/vela/tflite/FillOptions.py +++ b/ethosu/vela/tflite/FillOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class FillOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsFillOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = FillOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsFillOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def FillOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -23,4 +29,8 @@ class FillOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def FillOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return FillOptionsStart(builder) def FillOptionsEnd(builder): return builder.EndObject() +def End(builder): + return FillOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/FloorDivOptions.py b/ethosu/vela/tflite/FloorDivOptions.py index 53a3c4c6..649eb730 100644 --- a/ethosu/vela/tflite/FloorDivOptions.py +++ b/ethosu/vela/tflite/FloorDivOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class FloorDivOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsFloorDivOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = FloorDivOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsFloorDivOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def FloorDivOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -23,4 +29,8 @@ class FloorDivOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def FloorDivOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return FloorDivOptionsStart(builder) def FloorDivOptionsEnd(builder): return builder.EndObject() +def End(builder): + return FloorDivOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/FloorModOptions.py b/ethosu/vela/tflite/FloorModOptions.py index 6e5f679f..6cfea5d0 100644 --- a/ethosu/vela/tflite/FloorModOptions.py +++ b/ethosu/vela/tflite/FloorModOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class FloorModOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsFloorModOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = FloorModOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsFloorModOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def FloorModOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -23,4 +29,8 @@ class FloorModOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def FloorModOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return FloorModOptionsStart(builder) def FloorModOptionsEnd(builder): return builder.EndObject() +def End(builder): + return FloorModOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/FullyConnectedOptions.py b/ethosu/vela/tflite/FullyConnectedOptions.py index 601b57da..67ca53c4 100644 --- a/ethosu/vela/tflite/FullyConnectedOptions.py +++ b/ethosu/vela/tflite/FullyConnectedOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class FullyConnectedOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsFullyConnectedOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = FullyConnectedOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsFullyConnectedOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def FullyConnectedOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -51,8 +57,20 @@ class FullyConnectedOptions(object): return False def FullyConnectedOptionsStart(builder): builder.StartObject(4) +def Start(builder): + return FullyConnectedOptionsStart(builder) def FullyConnectedOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(0, fusedActivationFunction, 0) +def AddFusedActivationFunction(builder, fusedActivationFunction): + return FullyConnectedOptionsAddFusedActivationFunction(builder, fusedActivationFunction) def FullyConnectedOptionsAddWeightsFormat(builder, weightsFormat): builder.PrependInt8Slot(1, weightsFormat, 0) +def AddWeightsFormat(builder, weightsFormat): + return FullyConnectedOptionsAddWeightsFormat(builder, weightsFormat) def FullyConnectedOptionsAddKeepNumDims(builder, keepNumDims): builder.PrependBoolSlot(2, keepNumDims, 0) +def AddKeepNumDims(builder, keepNumDims): + return FullyConnectedOptionsAddKeepNumDims(builder, keepNumDims) def FullyConnectedOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): builder.PrependBoolSlot(3, asymmetricQuantizeInputs, 0) +def AddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): + return FullyConnectedOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs) def FullyConnectedOptionsEnd(builder): return builder.EndObject() +def End(builder): + return FullyConnectedOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/FullyConnectedOptionsWeightsFormat.py b/ethosu/vela/tflite/FullyConnectedOptionsWeightsFormat.py index 6d81eca1..d9a53887 100644 --- a/ethosu/vela/tflite/FullyConnectedOptionsWeightsFormat.py +++ b/ethosu/vela/tflite/FullyConnectedOptionsWeightsFormat.py @@ -5,4 +5,3 @@ class FullyConnectedOptionsWeightsFormat(object): DEFAULT = 0 SHUFFLED4x16INT8 = 1 - diff --git a/ethosu/vela/tflite/GatherNdOptions.py b/ethosu/vela/tflite/GatherNdOptions.py index db09182b..56967b04 100644 --- a/ethosu/vela/tflite/GatherNdOptions.py +++ b/ethosu/vela/tflite/GatherNdOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class GatherNdOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsGatherNdOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = GatherNdOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsGatherNdOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def GatherNdOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -23,4 +29,8 @@ class GatherNdOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def GatherNdOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return GatherNdOptionsStart(builder) def GatherNdOptionsEnd(builder): return builder.EndObject() +def End(builder): + return GatherNdOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/GatherOptions.py b/ethosu/vela/tflite/GatherOptions.py index 5da9a9b3..9d35523b 100644 --- a/ethosu/vela/tflite/GatherOptions.py +++ b/ethosu/vela/tflite/GatherOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class GatherOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsGatherOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = GatherOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsGatherOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def GatherOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -37,6 +43,14 @@ class GatherOptions(object): return 0 def GatherOptionsStart(builder): builder.StartObject(2) +def Start(builder): + return GatherOptionsStart(builder) def GatherOptionsAddAxis(builder, axis): builder.PrependInt32Slot(0, axis, 0) +def AddAxis(builder, axis): + return GatherOptionsAddAxis(builder, axis) def GatherOptionsAddBatchDims(builder, batchDims): builder.PrependInt32Slot(1, batchDims, 0) +def AddBatchDims(builder, batchDims): + return GatherOptionsAddBatchDims(builder, batchDims) def GatherOptionsEnd(builder): return builder.EndObject() +def End(builder): + return GatherOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/GreaterEqualOptions.py b/ethosu/vela/tflite/GreaterEqualOptions.py index 03a86fa2..53018210 100644 --- a/ethosu/vela/tflite/GreaterEqualOptions.py +++ b/ethosu/vela/tflite/GreaterEqualOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class GreaterEqualOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsGreaterEqualOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = GreaterEqualOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsGreaterEqualOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def GreaterEqualOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -23,4 +29,8 @@ class GreaterEqualOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def GreaterEqualOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return GreaterEqualOptionsStart(builder) def GreaterEqualOptionsEnd(builder): return builder.EndObject() +def End(builder): + return GreaterEqualOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/GreaterOptions.py b/ethosu/vela/tflite/GreaterOptions.py index 593e0d75..3d4c0c93 100644 --- a/ethosu/vela/tflite/GreaterOptions.py +++ b/ethosu/vela/tflite/GreaterOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class GreaterOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsGreaterOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = GreaterOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsGreaterOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def GreaterOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -23,4 +29,8 @@ class GreaterOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def GreaterOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return GreaterOptionsStart(builder) def GreaterOptionsEnd(builder): return builder.EndObject() +def End(builder): + return GreaterOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/HardSwishOptions.py b/ethosu/vela/tflite/HardSwishOptions.py index cbbf99cc..c0c4054f 100644 --- a/ethosu/vela/tflite/HardSwishOptions.py +++ b/ethosu/vela/tflite/HardSwishOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class HardSwishOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsHardSwishOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = HardSwishOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsHardSwishOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def HardSwishOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -23,4 +29,8 @@ class HardSwishOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def HardSwishOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return HardSwishOptionsStart(builder) def HardSwishOptionsEnd(builder): return builder.EndObject() +def End(builder): + return HardSwishOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/HashtableFindOptions.py b/ethosu/vela/tflite/HashtableFindOptions.py index cc74ace2..9078d60b 100644 --- a/ethosu/vela/tflite/HashtableFindOptions.py +++ b/ethosu/vela/tflite/HashtableFindOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class HashtableFindOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsHashtableFindOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = HashtableFindOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsHashtableFindOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def HashtableFindOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -23,4 +29,8 @@ class HashtableFindOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def HashtableFindOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return HashtableFindOptionsStart(builder) def HashtableFindOptionsEnd(builder): return builder.EndObject() +def End(builder): + return HashtableFindOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/HashtableImportOptions.py b/ethosu/vela/tflite/HashtableImportOptions.py index 64763c38..2b45955d 100644 --- a/ethosu/vela/tflite/HashtableImportOptions.py +++ b/ethosu/vela/tflite/HashtableImportOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class HashtableImportOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsHashtableImportOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = HashtableImportOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsHashtableImportOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def HashtableImportOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -23,4 +29,8 @@ class HashtableImportOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def HashtableImportOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return HashtableImportOptionsStart(builder) def HashtableImportOptionsEnd(builder): return builder.EndObject() +def End(builder): + return HashtableImportOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/HashtableOptions.py b/ethosu/vela/tflite/HashtableOptions.py index 646085f4..82ea2a79 100644 --- a/ethosu/vela/tflite/HashtableOptions.py +++ b/ethosu/vela/tflite/HashtableOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class HashtableOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsHashtableOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = HashtableOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsHashtableOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def HashtableOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -44,7 +50,17 @@ class HashtableOptions(object): return 0 def HashtableOptionsStart(builder): builder.StartObject(3) +def Start(builder): + return HashtableOptionsStart(builder) def HashtableOptionsAddTableId(builder, tableId): builder.PrependInt32Slot(0, tableId, 0) +def AddTableId(builder, tableId): + return HashtableOptionsAddTableId(builder, tableId) def HashtableOptionsAddKeyDtype(builder, keyDtype): builder.PrependInt8Slot(1, keyDtype, 0) +def AddKeyDtype(builder, keyDtype): + return HashtableOptionsAddKeyDtype(builder, keyDtype) def HashtableOptionsAddValueDtype(builder, valueDtype): builder.PrependInt8Slot(2, valueDtype, 0) +def AddValueDtype(builder, valueDtype): + return HashtableOptionsAddValueDtype(builder, valueDtype) def HashtableOptionsEnd(builder): return builder.EndObject() +def End(builder): + return HashtableOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/HashtableSizeOptions.py b/ethosu/vela/tflite/HashtableSizeOptions.py index 7baa0192..26c5ceb2 100644 --- a/ethosu/vela/tflite/HashtableSizeOptions.py +++ b/ethosu/vela/tflite/HashtableSizeOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class HashtableSizeOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsHashtableSizeOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = HashtableSizeOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsHashtableSizeOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def HashtableSizeOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -23,4 +29,8 @@ class HashtableSizeOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def HashtableSizeOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return HashtableSizeOptionsStart(builder) def HashtableSizeOptionsEnd(builder): return builder.EndObject() +def End(builder): + return HashtableSizeOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/IfOptions.py b/ethosu/vela/tflite/IfOptions.py index aad72769..230339bd 100644 --- a/ethosu/vela/tflite/IfOptions.py +++ b/ethosu/vela/tflite/IfOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class IfOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsIfOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = IfOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsIfOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def IfOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -37,6 +43,14 @@ class IfOptions(object): return 0 def IfOptionsStart(builder): builder.StartObject(2) +def Start(builder): + return IfOptionsStart(builder) def IfOptionsAddThenSubgraphIndex(builder, thenSubgraphIndex): builder.PrependInt32Slot(0, thenSubgraphIndex, 0) +def AddThenSubgraphIndex(builder, thenSubgraphIndex): + return IfOptionsAddThenSubgraphIndex(builder, thenSubgraphIndex) def IfOptionsAddElseSubgraphIndex(builder, elseSubgraphIndex): builder.PrependInt32Slot(1, elseSubgraphIndex, 0) +def AddElseSubgraphIndex(builder, elseSubgraphIndex): + return IfOptionsAddElseSubgraphIndex(builder, elseSubgraphIndex) def IfOptionsEnd(builder): return builder.EndObject() +def End(builder): + return IfOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/Int32Vector.py b/ethosu/vela/tflite/Int32Vector.py index 0575b2e8..6c2a614c 100644 --- a/ethosu/vela/tflite/Int32Vector.py +++ b/ethosu/vela/tflite/Int32Vector.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class Int32Vector(object): __slots__ = ['_tab'] @classmethod - def GetRootAsInt32Vector(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = Int32Vector() x.Init(buf, n + offset) return x @classmethod + def GetRootAsInt32Vector(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def Int32VectorBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -50,6 +56,14 @@ class Int32Vector(object): return o == 0 def Int32VectorStart(builder): builder.StartObject(1) +def Start(builder): + return Int32VectorStart(builder) def Int32VectorAddValues(builder, values): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(values), 0) +def AddValues(builder, values): + return Int32VectorAddValues(builder, values) def Int32VectorStartValuesVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def StartValuesVector(builder, numElems): + return Int32VectorStartValuesVector(builder, numElems) def Int32VectorEnd(builder): return builder.EndObject() +def End(builder): + return Int32VectorEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/L2NormOptions.py b/ethosu/vela/tflite/L2NormOptions.py index 0b1212fc..c8746a77 100644 --- a/ethosu/vela/tflite/L2NormOptions.py +++ b/ethosu/vela/tflite/L2NormOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class L2NormOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsL2NormOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = L2NormOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsL2NormOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def L2NormOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -30,5 +36,11 @@ class L2NormOptions(object): return 0 def L2NormOptionsStart(builder): builder.StartObject(1) +def Start(builder): + return L2NormOptionsStart(builder) def L2NormOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(0, fusedActivationFunction, 0) +def AddFusedActivationFunction(builder, fusedActivationFunction): + return L2NormOptionsAddFusedActivationFunction(builder, fusedActivationFunction) def L2NormOptionsEnd(builder): return builder.EndObject() +def End(builder): + return L2NormOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/LSHProjectionOptions.py b/ethosu/vela/tflite/LSHProjectionOptions.py index b545e78d..033f8c8e 100644 --- a/ethosu/vela/tflite/LSHProjectionOptions.py +++ b/ethosu/vela/tflite/LSHProjectionOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class LSHProjectionOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsLSHProjectionOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = LSHProjectionOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsLSHProjectionOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def LSHProjectionOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -30,5 +36,11 @@ class LSHProjectionOptions(object): return 0 def LSHProjectionOptionsStart(builder): builder.StartObject(1) +def Start(builder): + return LSHProjectionOptionsStart(builder) def LSHProjectionOptionsAddType(builder, type): builder.PrependInt8Slot(0, type, 0) +def AddType(builder, type): + return LSHProjectionOptionsAddType(builder, type) def LSHProjectionOptionsEnd(builder): return builder.EndObject() +def End(builder): + return LSHProjectionOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/LSHProjectionType.py b/ethosu/vela/tflite/LSHProjectionType.py index d6a136e8..a7d6a313 100644 --- a/ethosu/vela/tflite/LSHProjectionType.py +++ b/ethosu/vela/tflite/LSHProjectionType.py @@ -6,4 +6,3 @@ class LSHProjectionType(object): UNKNOWN = 0 SPARSE = 1 DENSE = 2 - diff --git a/ethosu/vela/tflite/LSTMKernelType.py b/ethosu/vela/tflite/LSTMKernelType.py index 1ca4df0a..fd657998 100644 --- a/ethosu/vela/tflite/LSTMKernelType.py +++ b/ethosu/vela/tflite/LSTMKernelType.py @@ -5,4 +5,3 @@ class LSTMKernelType(object): FULL = 0 BASIC = 1 - diff --git a/ethosu/vela/tflite/LSTMOptions.py b/ethosu/vela/tflite/LSTMOptions.py index 45b4af2c..acaedc74 100644 --- a/ethosu/vela/tflite/LSTMOptions.py +++ b/ethosu/vela/tflite/LSTMOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class LSTMOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsLSTMOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = LSTMOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsLSTMOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def LSTMOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -58,9 +64,23 @@ class LSTMOptions(object): return False def LSTMOptionsStart(builder): builder.StartObject(5) +def Start(builder): + return LSTMOptionsStart(builder) def LSTMOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(0, fusedActivationFunction, 0) +def AddFusedActivationFunction(builder, fusedActivationFunction): + return LSTMOptionsAddFusedActivationFunction(builder, fusedActivationFunction) def LSTMOptionsAddCellClip(builder, cellClip): builder.PrependFloat32Slot(1, cellClip, 0.0) +def AddCellClip(builder, cellClip): + return LSTMOptionsAddCellClip(builder, cellClip) def LSTMOptionsAddProjClip(builder, projClip): builder.PrependFloat32Slot(2, projClip, 0.0) +def AddProjClip(builder, projClip): + return LSTMOptionsAddProjClip(builder, projClip) def LSTMOptionsAddKernelType(builder, kernelType): builder.PrependInt8Slot(3, kernelType, 0) +def AddKernelType(builder, kernelType): + return LSTMOptionsAddKernelType(builder, kernelType) def LSTMOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): builder.PrependBoolSlot(4, asymmetricQuantizeInputs, 0) +def AddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): + return LSTMOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs) def LSTMOptionsEnd(builder): return builder.EndObject() +def End(builder): + return LSTMOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/LeakyReluOptions.py b/ethosu/vela/tflite/LeakyReluOptions.py index 5b8c647a..8550a0f9 100644 --- a/ethosu/vela/tflite/LeakyReluOptions.py +++ b/ethosu/vela/tflite/LeakyReluOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class LeakyReluOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsLeakyReluOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = LeakyReluOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsLeakyReluOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def LeakyReluOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -30,5 +36,11 @@ class LeakyReluOptions(object): return 0.0 def LeakyReluOptionsStart(builder): builder.StartObject(1) +def Start(builder): + return LeakyReluOptionsStart(builder) def LeakyReluOptionsAddAlpha(builder, alpha): builder.PrependFloat32Slot(0, alpha, 0.0) +def AddAlpha(builder, alpha): + return LeakyReluOptionsAddAlpha(builder, alpha) def LeakyReluOptionsEnd(builder): return builder.EndObject() +def End(builder): + return LeakyReluOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/LessEqualOptions.py b/ethosu/vela/tflite/LessEqualOptions.py index 8465ff3e..a6c4a865 100644 --- a/ethosu/vela/tflite/LessEqualOptions.py +++ b/ethosu/vela/tflite/LessEqualOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class LessEqualOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsLessEqualOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = LessEqualOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsLessEqualOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def LessEqualOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -23,4 +29,8 @@ class LessEqualOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def LessEqualOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return LessEqualOptionsStart(builder) def LessEqualOptionsEnd(builder): return builder.EndObject() +def End(builder): + return LessEqualOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/LessOptions.py b/ethosu/vela/tflite/LessOptions.py index 93f3edcd..765a245d 100644 --- a/ethosu/vela/tflite/LessOptions.py +++ b/ethosu/vela/tflite/LessOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class LessOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsLessOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = LessOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsLessOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def LessOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -23,4 +29,8 @@ class LessOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def LessOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return LessOptionsStart(builder) def LessOptionsEnd(builder): return builder.EndObject() +def End(builder): + return LessOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/LocalResponseNormalizationOptions.py b/ethosu/vela/tflite/LocalResponseNormalizationOptions.py index 5f4399a3..834aed4b 100644 --- a/ethosu/vela/tflite/LocalResponseNormalizationOptions.py +++ b/ethosu/vela/tflite/LocalResponseNormalizationOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class LocalResponseNormalizationOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsLocalResponseNormalizationOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = LocalResponseNormalizationOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsLocalResponseNormalizationOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def LocalResponseNormalizationOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -51,8 +57,20 @@ class LocalResponseNormalizationOptions(object): return 0.0 def LocalResponseNormalizationOptionsStart(builder): builder.StartObject(4) +def Start(builder): + return LocalResponseNormalizationOptionsStart(builder) def LocalResponseNormalizationOptionsAddRadius(builder, radius): builder.PrependInt32Slot(0, radius, 0) +def AddRadius(builder, radius): + return LocalResponseNormalizationOptionsAddRadius(builder, radius) def LocalResponseNormalizationOptionsAddBias(builder, bias): builder.PrependFloat32Slot(1, bias, 0.0) +def AddBias(builder, bias): + return LocalResponseNormalizationOptionsAddBias(builder, bias) def LocalResponseNormalizationOptionsAddAlpha(builder, alpha): builder.PrependFloat32Slot(2, alpha, 0.0) +def AddAlpha(builder, alpha): + return LocalResponseNormalizationOptionsAddAlpha(builder, alpha) def LocalResponseNormalizationOptionsAddBeta(builder, beta): builder.PrependFloat32Slot(3, beta, 0.0) +def AddBeta(builder, beta): + return LocalResponseNormalizationOptionsAddBeta(builder, beta) def LocalResponseNormalizationOptionsEnd(builder): return builder.EndObject() +def End(builder): + return LocalResponseNormalizationOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/LogSoftmaxOptions.py b/ethosu/vela/tflite/LogSoftmaxOptions.py index 584d628c..a5c81056 100644 --- a/ethosu/vela/tflite/LogSoftmaxOptions.py +++ b/ethosu/vela/tflite/LogSoftmaxOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class LogSoftmaxOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsLogSoftmaxOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = LogSoftmaxOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsLogSoftmaxOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def LogSoftmaxOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -23,4 +29,8 @@ class LogSoftmaxOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def LogSoftmaxOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return LogSoftmaxOptionsStart(builder) def LogSoftmaxOptionsEnd(builder): return builder.EndObject() +def End(builder): + return LogSoftmaxOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/LogicalAndOptions.py b/ethosu/vela/tflite/LogicalAndOptions.py index 1ec0e6e4..a786dbe7 100644 --- a/ethosu/vela/tflite/LogicalAndOptions.py +++ b/ethosu/vela/tflite/LogicalAndOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class LogicalAndOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsLogicalAndOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = LogicalAndOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsLogicalAndOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def LogicalAndOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -23,4 +29,8 @@ class LogicalAndOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def LogicalAndOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return LogicalAndOptionsStart(builder) def LogicalAndOptionsEnd(builder): return builder.EndObject() +def End(builder): + return LogicalAndOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/LogicalNotOptions.py b/ethosu/vela/tflite/LogicalNotOptions.py index ce66ec3b..4c29fdf3 100644 --- a/ethosu/vela/tflite/LogicalNotOptions.py +++ b/ethosu/vela/tflite/LogicalNotOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class LogicalNotOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsLogicalNotOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = LogicalNotOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsLogicalNotOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def LogicalNotOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -23,4 +29,8 @@ class LogicalNotOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def LogicalNotOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return LogicalNotOptionsStart(builder) def LogicalNotOptionsEnd(builder): return builder.EndObject() +def End(builder): + return LogicalNotOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/LogicalOrOptions.py b/ethosu/vela/tflite/LogicalOrOptions.py index ae4b36b0..b058a3b9 100644 --- a/ethosu/vela/tflite/LogicalOrOptions.py +++ b/ethosu/vela/tflite/LogicalOrOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class LogicalOrOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsLogicalOrOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = LogicalOrOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsLogicalOrOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def LogicalOrOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -23,4 +29,8 @@ class LogicalOrOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def LogicalOrOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return LogicalOrOptionsStart(builder) def LogicalOrOptionsEnd(builder): return builder.EndObject() +def End(builder): + return LogicalOrOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/MatrixDiagOptions.py b/ethosu/vela/tflite/MatrixDiagOptions.py index 85113659..0f2d3199 100644 --- a/ethosu/vela/tflite/MatrixDiagOptions.py +++ b/ethosu/vela/tflite/MatrixDiagOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class MatrixDiagOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsMatrixDiagOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = MatrixDiagOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsMatrixDiagOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def MatrixDiagOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -23,4 +29,8 @@ class MatrixDiagOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def MatrixDiagOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return MatrixDiagOptionsStart(builder) def MatrixDiagOptionsEnd(builder): return builder.EndObject() +def End(builder): + return MatrixDiagOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/MatrixSetDiagOptions.py b/ethosu/vela/tflite/MatrixSetDiagOptions.py index 361d3b69..37f496a1 100644 --- a/ethosu/vela/tflite/MatrixSetDiagOptions.py +++ b/ethosu/vela/tflite/MatrixSetDiagOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class MatrixSetDiagOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsMatrixSetDiagOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = MatrixSetDiagOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsMatrixSetDiagOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def MatrixSetDiagOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -23,4 +29,8 @@ class MatrixSetDiagOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def MatrixSetDiagOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return MatrixSetDiagOptionsStart(builder) def MatrixSetDiagOptionsEnd(builder): return builder.EndObject() +def End(builder): + return MatrixSetDiagOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/MaximumMinimumOptions.py b/ethosu/vela/tflite/MaximumMinimumOptions.py index 86b94f9e..e961e71d 100644 --- a/ethosu/vela/tflite/MaximumMinimumOptions.py +++ b/ethosu/vela/tflite/MaximumMinimumOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class MaximumMinimumOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsMaximumMinimumOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = MaximumMinimumOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsMaximumMinimumOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def MaximumMinimumOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -23,4 +29,8 @@ class MaximumMinimumOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def MaximumMinimumOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return MaximumMinimumOptionsStart(builder) def MaximumMinimumOptionsEnd(builder): return builder.EndObject() +def End(builder): + return MaximumMinimumOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/Metadata.py b/ethosu/vela/tflite/Metadata.py index bd2bcfd2..0ff8bf46 100644 --- a/ethosu/vela/tflite/Metadata.py +++ b/ethosu/vela/tflite/Metadata.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class Metadata(object): __slots__ = ['_tab'] @classmethod - def GetRootAsMetadata(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = Metadata() x.Init(buf, n + offset) return x @classmethod + def GetRootAsMetadata(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def MetadataBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -37,6 +43,14 @@ class Metadata(object): return 0 def MetadataStart(builder): builder.StartObject(2) +def Start(builder): + return MetadataStart(builder) def MetadataAddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) +def AddName(builder, name): + return MetadataAddName(builder, name) def MetadataAddBuffer(builder, buffer): builder.PrependUint32Slot(1, buffer, 0) +def AddBuffer(builder, buffer): + return MetadataAddBuffer(builder, buffer) def MetadataEnd(builder): return builder.EndObject() +def End(builder): + return MetadataEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/MirrorPadMode.py b/ethosu/vela/tflite/MirrorPadMode.py index ce7579d2..8fb6396f 100644 --- a/ethosu/vela/tflite/MirrorPadMode.py +++ b/ethosu/vela/tflite/MirrorPadMode.py @@ -5,4 +5,3 @@ class MirrorPadMode(object): REFLECT = 0 SYMMETRIC = 1 - diff --git a/ethosu/vela/tflite/MirrorPadOptions.py b/ethosu/vela/tflite/MirrorPadOptions.py index fa408556..b440117a 100644 --- a/ethosu/vela/tflite/MirrorPadOptions.py +++ b/ethosu/vela/tflite/MirrorPadOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class MirrorPadOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsMirrorPadOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = MirrorPadOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsMirrorPadOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def MirrorPadOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -30,5 +36,11 @@ class MirrorPadOptions(object): return 0 def MirrorPadOptionsStart(builder): builder.StartObject(1) +def Start(builder): + return MirrorPadOptionsStart(builder) def MirrorPadOptionsAddMode(builder, mode): builder.PrependInt8Slot(0, mode, 0) +def AddMode(builder, mode): + return MirrorPadOptionsAddMode(builder, mode) def MirrorPadOptionsEnd(builder): return builder.EndObject() +def End(builder): + return MirrorPadOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/Model.py b/ethosu/vela/tflite/Model.py index 2593752a..e81aa8fe 100644 --- a/ethosu/vela/tflite/Model.py +++ b/ethosu/vela/tflite/Model.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class Model(object): __slots__ = ['_tab'] @classmethod - def GetRootAsModel(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = Model() x.Init(buf, n + offset) return x @classmethod + def GetRootAsModel(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def ModelBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -189,18 +195,50 @@ class Model(object): return o == 0 def ModelStart(builder): builder.StartObject(8) +def Start(builder): + return ModelStart(builder) def ModelAddVersion(builder, version): builder.PrependUint32Slot(0, version, 0) +def AddVersion(builder, version): + return ModelAddVersion(builder, version) def ModelAddOperatorCodes(builder, operatorCodes): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(operatorCodes), 0) +def AddOperatorCodes(builder, operatorCodes): + return ModelAddOperatorCodes(builder, operatorCodes) def ModelStartOperatorCodesVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def StartOperatorCodesVector(builder, numElems): + return ModelStartOperatorCodesVector(builder, numElems) def ModelAddSubgraphs(builder, subgraphs): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(subgraphs), 0) +def AddSubgraphs(builder, subgraphs): + return ModelAddSubgraphs(builder, subgraphs) def ModelStartSubgraphsVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def StartSubgraphsVector(builder, numElems): + return ModelStartSubgraphsVector(builder, numElems) def ModelAddDescription(builder, description): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(description), 0) +def AddDescription(builder, description): + return ModelAddDescription(builder, description) def ModelAddBuffers(builder, buffers): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(buffers), 0) +def AddBuffers(builder, buffers): + return ModelAddBuffers(builder, buffers) def ModelStartBuffersVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def StartBuffersVector(builder, numElems): + return ModelStartBuffersVector(builder, numElems) def ModelAddMetadataBuffer(builder, metadataBuffer): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(metadataBuffer), 0) +def AddMetadataBuffer(builder, metadataBuffer): + return ModelAddMetadataBuffer(builder, metadataBuffer) def ModelStartMetadataBufferVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def StartMetadataBufferVector(builder, numElems): + return ModelStartMetadataBufferVector(builder, numElems) def ModelAddMetadata(builder, metadata): builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(metadata), 0) +def AddMetadata(builder, metadata): + return ModelAddMetadata(builder, metadata) def ModelStartMetadataVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def StartMetadataVector(builder, numElems): + return ModelStartMetadataVector(builder, numElems) def ModelAddSignatureDefs(builder, signatureDefs): builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(signatureDefs), 0) +def AddSignatureDefs(builder, signatureDefs): + return ModelAddSignatureDefs(builder, signatureDefs) def ModelStartSignatureDefsVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def StartSignatureDefsVector(builder, numElems): + return ModelStartSignatureDefsVector(builder, numElems) def ModelEnd(builder): return builder.EndObject() +def End(builder): + return ModelEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/MulOptions.py b/ethosu/vela/tflite/MulOptions.py index 5b53c4bb..70fb6872 100644 --- a/ethosu/vela/tflite/MulOptions.py +++ b/ethosu/vela/tflite/MulOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class MulOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsMulOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = MulOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsMulOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def MulOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -30,5 +36,11 @@ class MulOptions(object): return 0 def MulOptionsStart(builder): builder.StartObject(1) +def Start(builder): + return MulOptionsStart(builder) def MulOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(0, fusedActivationFunction, 0) +def AddFusedActivationFunction(builder, fusedActivationFunction): + return MulOptionsAddFusedActivationFunction(builder, fusedActivationFunction) def MulOptionsEnd(builder): return builder.EndObject() +def End(builder): + return MulOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/NegOptions.py b/ethosu/vela/tflite/NegOptions.py index 9cf217cc..d005cab5 100644 --- a/ethosu/vela/tflite/NegOptions.py +++ b/ethosu/vela/tflite/NegOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class NegOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsNegOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = NegOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsNegOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def NegOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -23,4 +29,8 @@ class NegOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def NegOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return NegOptionsStart(builder) def NegOptionsEnd(builder): return builder.EndObject() +def End(builder): + return NegOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/NonMaxSuppressionV4Options.py b/ethosu/vela/tflite/NonMaxSuppressionV4Options.py index 4764bc00..b25913a8 100644 --- a/ethosu/vela/tflite/NonMaxSuppressionV4Options.py +++ b/ethosu/vela/tflite/NonMaxSuppressionV4Options.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class NonMaxSuppressionV4Options(object): __slots__ = ['_tab'] @classmethod - def GetRootAsNonMaxSuppressionV4Options(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = NonMaxSuppressionV4Options() x.Init(buf, n + offset) return x @classmethod + def GetRootAsNonMaxSuppressionV4Options(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def NonMaxSuppressionV4OptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -23,4 +29,8 @@ class NonMaxSuppressionV4Options(object): self._tab = flatbuffers.table.Table(buf, pos) def NonMaxSuppressionV4OptionsStart(builder): builder.StartObject(0) +def Start(builder): + return NonMaxSuppressionV4OptionsStart(builder) def NonMaxSuppressionV4OptionsEnd(builder): return builder.EndObject() +def End(builder): + return NonMaxSuppressionV4OptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/NonMaxSuppressionV5Options.py b/ethosu/vela/tflite/NonMaxSuppressionV5Options.py index ce84c863..b51bd97d 100644 --- a/ethosu/vela/tflite/NonMaxSuppressionV5Options.py +++ b/ethosu/vela/tflite/NonMaxSuppressionV5Options.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class NonMaxSuppressionV5Options(object): __slots__ = ['_tab'] @classmethod - def GetRootAsNonMaxSuppressionV5Options(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = NonMaxSuppressionV5Options() x.Init(buf, n + offset) return x @classmethod + def GetRootAsNonMaxSuppressionV5Options(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def NonMaxSuppressionV5OptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -23,4 +29,8 @@ class NonMaxSuppressionV5Options(object): self._tab = flatbuffers.table.Table(buf, pos) def NonMaxSuppressionV5OptionsStart(builder): builder.StartObject(0) +def Start(builder): + return NonMaxSuppressionV5OptionsStart(builder) def NonMaxSuppressionV5OptionsEnd(builder): return builder.EndObject() +def End(builder): + return NonMaxSuppressionV5OptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/NotEqualOptions.py b/ethosu/vela/tflite/NotEqualOptions.py index b99152df..a1c6dba1 100644 --- a/ethosu/vela/tflite/NotEqualOptions.py +++ b/ethosu/vela/tflite/NotEqualOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class NotEqualOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsNotEqualOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = NotEqualOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsNotEqualOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def NotEqualOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -23,4 +29,8 @@ class NotEqualOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def NotEqualOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return NotEqualOptionsStart(builder) def NotEqualOptionsEnd(builder): return builder.EndObject() +def End(builder): + return NotEqualOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/OneHotOptions.py b/ethosu/vela/tflite/OneHotOptions.py index 7bc9ba36..873e01ec 100644 --- a/ethosu/vela/tflite/OneHotOptions.py +++ b/ethosu/vela/tflite/OneHotOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class OneHotOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsOneHotOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = OneHotOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsOneHotOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def OneHotOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -30,5 +36,11 @@ class OneHotOptions(object): return 0 def OneHotOptionsStart(builder): builder.StartObject(1) +def Start(builder): + return OneHotOptionsStart(builder) def OneHotOptionsAddAxis(builder, axis): builder.PrependInt32Slot(0, axis, 0) +def AddAxis(builder, axis): + return OneHotOptionsAddAxis(builder, axis) def OneHotOptionsEnd(builder): return builder.EndObject() +def End(builder): + return OneHotOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/Operator.py b/ethosu/vela/tflite/Operator.py index edec83bc..2af3f8ce 100644 --- a/ethosu/vela/tflite/Operator.py +++ b/ethosu/vela/tflite/Operator.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class Operator(object): __slots__ = ['_tab'] @classmethod - def GetRootAsOperator(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = Operator() x.Init(buf, n + offset) return x @classmethod + def GetRootAsOperator(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def OperatorBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -189,18 +195,50 @@ class Operator(object): return o == 0 def OperatorStart(builder): builder.StartObject(9) +def Start(builder): + return OperatorStart(builder) def OperatorAddOpcodeIndex(builder, opcodeIndex): builder.PrependUint32Slot(0, opcodeIndex, 0) +def AddOpcodeIndex(builder, opcodeIndex): + return OperatorAddOpcodeIndex(builder, opcodeIndex) def OperatorAddInputs(builder, inputs): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(inputs), 0) +def AddInputs(builder, inputs): + return OperatorAddInputs(builder, inputs) def OperatorStartInputsVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def StartInputsVector(builder, numElems): + return OperatorStartInputsVector(builder, numElems) def OperatorAddOutputs(builder, outputs): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(outputs), 0) +def AddOutputs(builder, outputs): + return OperatorAddOutputs(builder, outputs) def OperatorStartOutputsVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def StartOutputsVector(builder, numElems): + return OperatorStartOutputsVector(builder, numElems) def OperatorAddBuiltinOptionsType(builder, builtinOptionsType): builder.PrependUint8Slot(3, builtinOptionsType, 0) +def AddBuiltinOptionsType(builder, builtinOptionsType): + return OperatorAddBuiltinOptionsType(builder, builtinOptionsType) def OperatorAddBuiltinOptions(builder, builtinOptions): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(builtinOptions), 0) +def AddBuiltinOptions(builder, builtinOptions): + return OperatorAddBuiltinOptions(builder, builtinOptions) def OperatorAddCustomOptions(builder, customOptions): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(customOptions), 0) +def AddCustomOptions(builder, customOptions): + return OperatorAddCustomOptions(builder, customOptions) def OperatorStartCustomOptionsVector(builder, numElems): return builder.StartVector(1, numElems, 1) +def StartCustomOptionsVector(builder, numElems): + return OperatorStartCustomOptionsVector(builder, numElems) def OperatorAddCustomOptionsFormat(builder, customOptionsFormat): builder.PrependInt8Slot(6, customOptionsFormat, 0) +def AddCustomOptionsFormat(builder, customOptionsFormat): + return OperatorAddCustomOptionsFormat(builder, customOptionsFormat) def OperatorAddMutatingVariableInputs(builder, mutatingVariableInputs): builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(mutatingVariableInputs), 0) +def AddMutatingVariableInputs(builder, mutatingVariableInputs): + return OperatorAddMutatingVariableInputs(builder, mutatingVariableInputs) def OperatorStartMutatingVariableInputsVector(builder, numElems): return builder.StartVector(1, numElems, 1) +def StartMutatingVariableInputsVector(builder, numElems): + return OperatorStartMutatingVariableInputsVector(builder, numElems) def OperatorAddIntermediates(builder, intermediates): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(intermediates), 0) +def AddIntermediates(builder, intermediates): + return OperatorAddIntermediates(builder, intermediates) def OperatorStartIntermediatesVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def StartIntermediatesVector(builder, numElems): + return OperatorStartIntermediatesVector(builder, numElems) def OperatorEnd(builder): return builder.EndObject() +def End(builder): + return OperatorEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/OperatorCode.py b/ethosu/vela/tflite/OperatorCode.py index 880c1a5d..a250e7c1 100644 --- a/ethosu/vela/tflite/OperatorCode.py +++ b/ethosu/vela/tflite/OperatorCode.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class OperatorCode(object): __slots__ = ['_tab'] @classmethod - def GetRootAsOperatorCode(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = OperatorCode() x.Init(buf, n + offset) return x @classmethod + def GetRootAsOperatorCode(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def OperatorCodeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -51,8 +57,20 @@ class OperatorCode(object): return 0 def OperatorCodeStart(builder): builder.StartObject(4) +def Start(builder): + return OperatorCodeStart(builder) def OperatorCodeAddDeprecatedBuiltinCode(builder, deprecatedBuiltinCode): builder.PrependInt8Slot(0, deprecatedBuiltinCode, 0) +def AddDeprecatedBuiltinCode(builder, deprecatedBuiltinCode): + return OperatorCodeAddDeprecatedBuiltinCode(builder, deprecatedBuiltinCode) def OperatorCodeAddCustomCode(builder, customCode): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(customCode), 0) +def AddCustomCode(builder, customCode): + return OperatorCodeAddCustomCode(builder, customCode) def OperatorCodeAddVersion(builder, version): builder.PrependInt32Slot(2, version, 1) +def AddVersion(builder, version): + return OperatorCodeAddVersion(builder, version) def OperatorCodeAddBuiltinCode(builder, builtinCode): builder.PrependInt32Slot(3, builtinCode, 0) +def AddBuiltinCode(builder, builtinCode): + return OperatorCodeAddBuiltinCode(builder, builtinCode) def OperatorCodeEnd(builder): return builder.EndObject() +def End(builder): + return OperatorCodeEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/PackOptions.py b/ethosu/vela/tflite/PackOptions.py index 2d590c52..1591f15d 100644 --- a/ethosu/vela/tflite/PackOptions.py +++ b/ethosu/vela/tflite/PackOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class PackOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsPackOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = PackOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsPackOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def PackOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -37,6 +43,14 @@ class PackOptions(object): return 0 def PackOptionsStart(builder): builder.StartObject(2) +def Start(builder): + return PackOptionsStart(builder) def PackOptionsAddValuesCount(builder, valuesCount): builder.PrependInt32Slot(0, valuesCount, 0) +def AddValuesCount(builder, valuesCount): + return PackOptionsAddValuesCount(builder, valuesCount) def PackOptionsAddAxis(builder, axis): builder.PrependInt32Slot(1, axis, 0) +def AddAxis(builder, axis): + return PackOptionsAddAxis(builder, axis) def PackOptionsEnd(builder): return builder.EndObject() +def End(builder): + return PackOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/PadOptions.py b/ethosu/vela/tflite/PadOptions.py index 58d33e54..b73f51d8 100644 --- a/ethosu/vela/tflite/PadOptions.py +++ b/ethosu/vela/tflite/PadOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class PadOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsPadOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = PadOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsPadOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def PadOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -23,4 +29,8 @@ class PadOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def PadOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return PadOptionsStart(builder) def PadOptionsEnd(builder): return builder.EndObject() +def End(builder): + return PadOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/PadV2Options.py b/ethosu/vela/tflite/PadV2Options.py index 2b81bdd5..aaa67935 100644 --- a/ethosu/vela/tflite/PadV2Options.py +++ b/ethosu/vela/tflite/PadV2Options.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class PadV2Options(object): __slots__ = ['_tab'] @classmethod - def GetRootAsPadV2Options(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = PadV2Options() x.Init(buf, n + offset) return x @classmethod + def GetRootAsPadV2Options(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def PadV2OptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -23,4 +29,8 @@ class PadV2Options(object): self._tab = flatbuffers.table.Table(buf, pos) def PadV2OptionsStart(builder): builder.StartObject(0) +def Start(builder): + return PadV2OptionsStart(builder) def PadV2OptionsEnd(builder): return builder.EndObject() +def End(builder): + return PadV2OptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/Padding.py b/ethosu/vela/tflite/Padding.py index 6027f4b5..168bf74c 100644 --- a/ethosu/vela/tflite/Padding.py +++ b/ethosu/vela/tflite/Padding.py @@ -5,4 +5,3 @@ class Padding(object): SAME = 0 VALID = 1 - diff --git a/ethosu/vela/tflite/Pool2DOptions.py b/ethosu/vela/tflite/Pool2DOptions.py index 031629bb..169c13c6 100644 --- a/ethosu/vela/tflite/Pool2DOptions.py +++ b/ethosu/vela/tflite/Pool2DOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class Pool2DOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsPool2DOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = Pool2DOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsPool2DOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def Pool2DOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -65,10 +71,26 @@ class Pool2DOptions(object): return 0 def Pool2DOptionsStart(builder): builder.StartObject(6) +def Start(builder): + return Pool2DOptionsStart(builder) def Pool2DOptionsAddPadding(builder, padding): builder.PrependInt8Slot(0, padding, 0) +def AddPadding(builder, padding): + return Pool2DOptionsAddPadding(builder, padding) def Pool2DOptionsAddStrideW(builder, strideW): builder.PrependInt32Slot(1, strideW, 0) +def AddStrideW(builder, strideW): + return Pool2DOptionsAddStrideW(builder, strideW) def Pool2DOptionsAddStrideH(builder, strideH): builder.PrependInt32Slot(2, strideH, 0) +def AddStrideH(builder, strideH): + return Pool2DOptionsAddStrideH(builder, strideH) def Pool2DOptionsAddFilterWidth(builder, filterWidth): builder.PrependInt32Slot(3, filterWidth, 0) +def AddFilterWidth(builder, filterWidth): + return Pool2DOptionsAddFilterWidth(builder, filterWidth) def Pool2DOptionsAddFilterHeight(builder, filterHeight): builder.PrependInt32Slot(4, filterHeight, 0) +def AddFilterHeight(builder, filterHeight): + return Pool2DOptionsAddFilterHeight(builder, filterHeight) def Pool2DOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(5, fusedActivationFunction, 0) +def AddFusedActivationFunction(builder, fusedActivationFunction): + return Pool2DOptionsAddFusedActivationFunction(builder, fusedActivationFunction) def Pool2DOptionsEnd(builder): return builder.EndObject() +def End(builder): + return Pool2DOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/PowOptions.py b/ethosu/vela/tflite/PowOptions.py index b9c9f848..4d9fd3db 100644 --- a/ethosu/vela/tflite/PowOptions.py +++ b/ethosu/vela/tflite/PowOptions.py @@ -3,18 +3,24 @@ # namespace: tflite import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class PowOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsPowOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = PowOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsPowOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def PowOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -23,4 +29,8 @@ class PowOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def PowOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return PowOptionsStart(builder) def PowOptionsEnd(builder): return builder.EndObject() +def End(builder): + return PowOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/QuantizationDetails.py b/ethosu/vela/tflite/QuantizationDetails.py index 7159efbd..8d53af96 100644 --- a/ethosu/vela/tflite/QuantizationDetails.py +++ b/ethosu/vela/tflite/QuantizationDetails.py @@ -5,4 +5,3 @@ class QuantizationDetails(object): NONE = 0 CustomQuantization = 1 - diff --git a/ethosu/vela/tflite/QuantizationParameters.py b/ethosu/vela/tflite/QuantizationParameters.py index 50acb835..0a27af0e 100644 --- a/ethosu/vela/tflite/QuantizationParameters.py +++ b/ethosu/vela/tflite/QuantizationParameters.py @@ -10,13 +10,17 @@ class QuantizationParameters(object): __slots__ = ['_tab'] @classmethod - def GetRootAsQuantizationParameters(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = QuantizationParameters() x.Init(buf, n + offset) return x @classmethod + def GetRootAsQuantizationParameters(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def QuantizationParametersBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -157,15 +161,41 @@ class QuantizationParameters(object): return 0 def QuantizationParametersStart(builder): builder.StartObject(7) +def Start(builder): + return QuantizationParametersStart(builder) def QuantizationParametersAddMin(builder, min): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(min), 0) +def AddMin(builder, min): + return QuantizationParametersAddMin(builder, min) def QuantizationParametersStartMinVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def StartMinVector(builder, numElems): + return QuantizationParametersStartMinVector(builder, numElems) def QuantizationParametersAddMax(builder, max): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(max), 0) +def AddMax(builder, max): + return QuantizationParametersAddMax(builder, max) def QuantizationParametersStartMaxVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def StartMaxVector(builder, numElems): + return QuantizationParametersStartMaxVector(builder, numElems) def QuantizationParametersAddScale(builder, scale): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(scale), 0) +def AddScale(builder, scale): + return QuantizationParametersAddScale(builder, scale) def QuantizationParametersStartScaleVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def StartScaleVector(builder, numElems): + return QuantizationParametersStartScaleVector(builder, numElems) def QuantizationParametersAddZeroPoint(builder, zeroPoint): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(zeroPoint), 0) +def AddZeroPoint(builder, zeroPoint): + return QuantizationParametersAddZeroPoint(builder, zeroPoint) def QuantizationParametersStartZeroPointVector(builder, numElems): return builder.StartVector(8, numElems, 8) +def StartZeroPointVector(builder, numElems): + return QuantizationParametersStartZeroPointVector(builder, numElems) def QuantizationParametersAddDetailsType(builder, detailsType): builder.PrependUint8Slot(4, detailsType, 0) +def AddDetailsType(builder, detailsType): + return QuantizationParametersAddDetailsType(builder, detailsType) def QuantizationParametersAddDetails(builder, details): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(details), 0) +def AddDetails(builder, details): + return QuantizationParametersAddDetails(builder, details) def QuantizationParametersAddQuantizedDimension(builder, quantizedDimension): builder.PrependInt32Slot(6, quantizedDimension, 0) +def AddQuantizedDimension(builder, quantizedDimension): + return QuantizationParametersAddQuantizedDimension(builder, quantizedDimension) def QuantizationParametersEnd(builder): return builder.EndObject() +def End(builder): + return QuantizationParametersEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/QuantizeOptions.py b/ethosu/vela/tflite/QuantizeOptions.py index a2a6babc..f7469290 100644 --- a/ethosu/vela/tflite/QuantizeOptions.py +++ b/ethosu/vela/tflite/QuantizeOptions.py @@ -10,13 +10,17 @@ class QuantizeOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsQuantizeOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = QuantizeOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsQuantizeOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def QuantizeOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -25,4 +29,8 @@ class QuantizeOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def QuantizeOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return QuantizeOptionsStart(builder) def QuantizeOptionsEnd(builder): return builder.EndObject() +def End(builder): + return QuantizeOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/RNNOptions.py b/ethosu/vela/tflite/RNNOptions.py index 67bbe78f..c891508d 100644 --- a/ethosu/vela/tflite/RNNOptions.py +++ b/ethosu/vela/tflite/RNNOptions.py @@ -10,13 +10,17 @@ class RNNOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsRNNOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = RNNOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsRNNOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def RNNOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -39,6 +43,14 @@ class RNNOptions(object): return False def RNNOptionsStart(builder): builder.StartObject(2) +def Start(builder): + return RNNOptionsStart(builder) def RNNOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(0, fusedActivationFunction, 0) +def AddFusedActivationFunction(builder, fusedActivationFunction): + return RNNOptionsAddFusedActivationFunction(builder, fusedActivationFunction) def RNNOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): builder.PrependBoolSlot(1, asymmetricQuantizeInputs, 0) +def AddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): + return RNNOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs) def RNNOptionsEnd(builder): return builder.EndObject() +def End(builder): + return RNNOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/RandomOptions.py b/ethosu/vela/tflite/RandomOptions.py new file mode 100644 index 00000000..e107dcda --- /dev/null +++ b/ethosu/vela/tflite/RandomOptions.py @@ -0,0 +1,56 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class RandomOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = RandomOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsRandomOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def RandomOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # RandomOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # RandomOptions + def Seed(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + + # RandomOptions + def Seed2(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + +def RandomOptionsStart(builder): builder.StartObject(2) +def Start(builder): + return RandomOptionsStart(builder) +def RandomOptionsAddSeed(builder, seed): builder.PrependInt32Slot(0, seed, 0) +def AddSeed(builder, seed): + return RandomOptionsAddSeed(builder, seed) +def RandomOptionsAddSeed2(builder, seed2): builder.PrependInt32Slot(1, seed2, 0) +def AddSeed2(builder, seed2): + return RandomOptionsAddSeed2(builder, seed2) +def RandomOptionsEnd(builder): return builder.EndObject() +def End(builder): + return RandomOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/RangeOptions.py b/ethosu/vela/tflite/RangeOptions.py index 1a5bd0f3..d6907971 100644 --- a/ethosu/vela/tflite/RangeOptions.py +++ b/ethosu/vela/tflite/RangeOptions.py @@ -10,13 +10,17 @@ class RangeOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsRangeOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = RangeOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsRangeOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def RangeOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -25,4 +29,8 @@ class RangeOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def RangeOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return RangeOptionsStart(builder) def RangeOptionsEnd(builder): return builder.EndObject() +def End(builder): + return RangeOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/RankOptions.py b/ethosu/vela/tflite/RankOptions.py index 37ad8a61..dde41498 100644 --- a/ethosu/vela/tflite/RankOptions.py +++ b/ethosu/vela/tflite/RankOptions.py @@ -10,13 +10,17 @@ class RankOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsRankOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = RankOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsRankOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def RankOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -25,4 +29,8 @@ class RankOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def RankOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return RankOptionsStart(builder) def RankOptionsEnd(builder): return builder.EndObject() +def End(builder): + return RankOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/ReadVariableOptions.py b/ethosu/vela/tflite/ReadVariableOptions.py new file mode 100644 index 00000000..14421790 --- /dev/null +++ b/ethosu/vela/tflite/ReadVariableOptions.py @@ -0,0 +1,36 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class ReadVariableOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = ReadVariableOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsReadVariableOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def ReadVariableOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # ReadVariableOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + +def ReadVariableOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return ReadVariableOptionsStart(builder) +def ReadVariableOptionsEnd(builder): return builder.EndObject() +def End(builder): + return ReadVariableOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/ReducerOptions.py b/ethosu/vela/tflite/ReducerOptions.py index 56174b04..e5f37d78 100644 --- a/ethosu/vela/tflite/ReducerOptions.py +++ b/ethosu/vela/tflite/ReducerOptions.py @@ -10,13 +10,17 @@ class ReducerOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsReducerOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = ReducerOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsReducerOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def ReducerOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -32,5 +36,11 @@ class ReducerOptions(object): return False def ReducerOptionsStart(builder): builder.StartObject(1) +def Start(builder): + return ReducerOptionsStart(builder) def ReducerOptionsAddKeepDims(builder, keepDims): builder.PrependBoolSlot(0, keepDims, 0) +def AddKeepDims(builder, keepDims): + return ReducerOptionsAddKeepDims(builder, keepDims) def ReducerOptionsEnd(builder): return builder.EndObject() +def End(builder): + return ReducerOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/ReshapeOptions.py b/ethosu/vela/tflite/ReshapeOptions.py index 234f4384..d22a91b8 100644 --- a/ethosu/vela/tflite/ReshapeOptions.py +++ b/ethosu/vela/tflite/ReshapeOptions.py @@ -10,13 +10,17 @@ class ReshapeOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsReshapeOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = ReshapeOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsReshapeOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def ReshapeOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -52,6 +56,14 @@ class ReshapeOptions(object): return o == 0 def ReshapeOptionsStart(builder): builder.StartObject(1) +def Start(builder): + return ReshapeOptionsStart(builder) def ReshapeOptionsAddNewShape(builder, newShape): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(newShape), 0) +def AddNewShape(builder, newShape): + return ReshapeOptionsAddNewShape(builder, newShape) def ReshapeOptionsStartNewShapeVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def StartNewShapeVector(builder, numElems): + return ReshapeOptionsStartNewShapeVector(builder, numElems) def ReshapeOptionsEnd(builder): return builder.EndObject() +def End(builder): + return ReshapeOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/ResizeBilinearOptions.py b/ethosu/vela/tflite/ResizeBilinearOptions.py index d974adbf..c481a8aa 100644 --- a/ethosu/vela/tflite/ResizeBilinearOptions.py +++ b/ethosu/vela/tflite/ResizeBilinearOptions.py @@ -10,13 +10,17 @@ class ResizeBilinearOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsResizeBilinearOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = ResizeBilinearOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsResizeBilinearOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def ResizeBilinearOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -39,6 +43,14 @@ class ResizeBilinearOptions(object): return False def ResizeBilinearOptionsStart(builder): builder.StartObject(4) +def Start(builder): + return ResizeBilinearOptionsStart(builder) def ResizeBilinearOptionsAddAlignCorners(builder, alignCorners): builder.PrependBoolSlot(2, alignCorners, 0) +def AddAlignCorners(builder, alignCorners): + return ResizeBilinearOptionsAddAlignCorners(builder, alignCorners) def ResizeBilinearOptionsAddHalfPixelCenters(builder, halfPixelCenters): builder.PrependBoolSlot(3, halfPixelCenters, 0) +def AddHalfPixelCenters(builder, halfPixelCenters): + return ResizeBilinearOptionsAddHalfPixelCenters(builder, halfPixelCenters) def ResizeBilinearOptionsEnd(builder): return builder.EndObject() +def End(builder): + return ResizeBilinearOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/ResizeNearestNeighborOptions.py b/ethosu/vela/tflite/ResizeNearestNeighborOptions.py index 9044279d..84b888a8 100644 --- a/ethosu/vela/tflite/ResizeNearestNeighborOptions.py +++ b/ethosu/vela/tflite/ResizeNearestNeighborOptions.py @@ -10,13 +10,17 @@ class ResizeNearestNeighborOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsResizeNearestNeighborOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = ResizeNearestNeighborOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsResizeNearestNeighborOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def ResizeNearestNeighborOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -39,6 +43,14 @@ class ResizeNearestNeighborOptions(object): return False def ResizeNearestNeighborOptionsStart(builder): builder.StartObject(2) +def Start(builder): + return ResizeNearestNeighborOptionsStart(builder) def ResizeNearestNeighborOptionsAddAlignCorners(builder, alignCorners): builder.PrependBoolSlot(0, alignCorners, 0) +def AddAlignCorners(builder, alignCorners): + return ResizeNearestNeighborOptionsAddAlignCorners(builder, alignCorners) def ResizeNearestNeighborOptionsAddHalfPixelCenters(builder, halfPixelCenters): builder.PrependBoolSlot(1, halfPixelCenters, 0) +def AddHalfPixelCenters(builder, halfPixelCenters): + return ResizeNearestNeighborOptionsAddHalfPixelCenters(builder, halfPixelCenters) def ResizeNearestNeighborOptionsEnd(builder): return builder.EndObject() +def End(builder): + return ResizeNearestNeighborOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/ReverseSequenceOptions.py b/ethosu/vela/tflite/ReverseSequenceOptions.py index 4f4e5d2f..63c449bb 100644 --- a/ethosu/vela/tflite/ReverseSequenceOptions.py +++ b/ethosu/vela/tflite/ReverseSequenceOptions.py @@ -10,13 +10,17 @@ class ReverseSequenceOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsReverseSequenceOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = ReverseSequenceOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsReverseSequenceOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def ReverseSequenceOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -39,6 +43,14 @@ class ReverseSequenceOptions(object): return 0 def ReverseSequenceOptionsStart(builder): builder.StartObject(2) +def Start(builder): + return ReverseSequenceOptionsStart(builder) def ReverseSequenceOptionsAddSeqDim(builder, seqDim): builder.PrependInt32Slot(0, seqDim, 0) +def AddSeqDim(builder, seqDim): + return ReverseSequenceOptionsAddSeqDim(builder, seqDim) def ReverseSequenceOptionsAddBatchDim(builder, batchDim): builder.PrependInt32Slot(1, batchDim, 0) +def AddBatchDim(builder, batchDim): + return ReverseSequenceOptionsAddBatchDim(builder, batchDim) def ReverseSequenceOptionsEnd(builder): return builder.EndObject() +def End(builder): + return ReverseSequenceOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/ReverseV2Options.py b/ethosu/vela/tflite/ReverseV2Options.py index 02d148e4..2d6d516d 100644 --- a/ethosu/vela/tflite/ReverseV2Options.py +++ b/ethosu/vela/tflite/ReverseV2Options.py @@ -10,13 +10,17 @@ class ReverseV2Options(object): __slots__ = ['_tab'] @classmethod - def GetRootAsReverseV2Options(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = ReverseV2Options() x.Init(buf, n + offset) return x @classmethod + def GetRootAsReverseV2Options(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def ReverseV2OptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -25,4 +29,8 @@ class ReverseV2Options(object): self._tab = flatbuffers.table.Table(buf, pos) def ReverseV2OptionsStart(builder): builder.StartObject(0) +def Start(builder): + return ReverseV2OptionsStart(builder) def ReverseV2OptionsEnd(builder): return builder.EndObject() +def End(builder): + return ReverseV2OptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/Rfft2dOptions.py b/ethosu/vela/tflite/Rfft2dOptions.py index da062ec9..d6a3d903 100644 --- a/ethosu/vela/tflite/Rfft2dOptions.py +++ b/ethosu/vela/tflite/Rfft2dOptions.py @@ -10,13 +10,17 @@ class Rfft2dOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsRfft2dOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = Rfft2dOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsRfft2dOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def Rfft2dOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -25,4 +29,8 @@ class Rfft2dOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def Rfft2dOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return Rfft2dOptionsStart(builder) def Rfft2dOptionsEnd(builder): return builder.EndObject() +def End(builder): + return Rfft2dOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/SVDFOptions.py b/ethosu/vela/tflite/SVDFOptions.py index b5e59038..3dbbad90 100644 --- a/ethosu/vela/tflite/SVDFOptions.py +++ b/ethosu/vela/tflite/SVDFOptions.py @@ -10,13 +10,17 @@ class SVDFOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsSVDFOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = SVDFOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsSVDFOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def SVDFOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -46,7 +50,17 @@ class SVDFOptions(object): return False def SVDFOptionsStart(builder): builder.StartObject(3) +def Start(builder): + return SVDFOptionsStart(builder) def SVDFOptionsAddRank(builder, rank): builder.PrependInt32Slot(0, rank, 0) +def AddRank(builder, rank): + return SVDFOptionsAddRank(builder, rank) def SVDFOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(1, fusedActivationFunction, 0) +def AddFusedActivationFunction(builder, fusedActivationFunction): + return SVDFOptionsAddFusedActivationFunction(builder, fusedActivationFunction) def SVDFOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): builder.PrependBoolSlot(2, asymmetricQuantizeInputs, 0) +def AddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): + return SVDFOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs) def SVDFOptionsEnd(builder): return builder.EndObject() +def End(builder): + return SVDFOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/ScatterNdOptions.py b/ethosu/vela/tflite/ScatterNdOptions.py index 0a8adc17..682e629d 100644 --- a/ethosu/vela/tflite/ScatterNdOptions.py +++ b/ethosu/vela/tflite/ScatterNdOptions.py @@ -10,13 +10,17 @@ class ScatterNdOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsScatterNdOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = ScatterNdOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsScatterNdOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def ScatterNdOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -25,4 +29,8 @@ class ScatterNdOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def ScatterNdOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return ScatterNdOptionsStart(builder) def ScatterNdOptionsEnd(builder): return builder.EndObject() +def End(builder): + return ScatterNdOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/SegmentSumOptions.py b/ethosu/vela/tflite/SegmentSumOptions.py index 3b231262..a6f499f1 100644 --- a/ethosu/vela/tflite/SegmentSumOptions.py +++ b/ethosu/vela/tflite/SegmentSumOptions.py @@ -10,13 +10,17 @@ class SegmentSumOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsSegmentSumOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = SegmentSumOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsSegmentSumOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def SegmentSumOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -25,4 +29,8 @@ class SegmentSumOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def SegmentSumOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return SegmentSumOptionsStart(builder) def SegmentSumOptionsEnd(builder): return builder.EndObject() +def End(builder): + return SegmentSumOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/SelectOptions.py b/ethosu/vela/tflite/SelectOptions.py index 6176d0cf..fc61c13e 100644 --- a/ethosu/vela/tflite/SelectOptions.py +++ b/ethosu/vela/tflite/SelectOptions.py @@ -10,13 +10,17 @@ class SelectOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsSelectOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = SelectOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsSelectOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def SelectOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -25,4 +29,8 @@ class SelectOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def SelectOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return SelectOptionsStart(builder) def SelectOptionsEnd(builder): return builder.EndObject() +def End(builder): + return SelectOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/SelectV2Options.py b/ethosu/vela/tflite/SelectV2Options.py index cc01eced..59e4b247 100644 --- a/ethosu/vela/tflite/SelectV2Options.py +++ b/ethosu/vela/tflite/SelectV2Options.py @@ -10,13 +10,17 @@ class SelectV2Options(object): __slots__ = ['_tab'] @classmethod - def GetRootAsSelectV2Options(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = SelectV2Options() x.Init(buf, n + offset) return x @classmethod + def GetRootAsSelectV2Options(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def SelectV2OptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -25,4 +29,8 @@ class SelectV2Options(object): self._tab = flatbuffers.table.Table(buf, pos) def SelectV2OptionsStart(builder): builder.StartObject(0) +def Start(builder): + return SelectV2OptionsStart(builder) def SelectV2OptionsEnd(builder): return builder.EndObject() +def End(builder): + return SelectV2OptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/SequenceRNNOptions.py b/ethosu/vela/tflite/SequenceRNNOptions.py index 636ba1cb..3cc448a9 100644 --- a/ethosu/vela/tflite/SequenceRNNOptions.py +++ b/ethosu/vela/tflite/SequenceRNNOptions.py @@ -10,13 +10,17 @@ class SequenceRNNOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsSequenceRNNOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = SequenceRNNOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsSequenceRNNOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def SequenceRNNOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -46,7 +50,17 @@ class SequenceRNNOptions(object): return False def SequenceRNNOptionsStart(builder): builder.StartObject(3) +def Start(builder): + return SequenceRNNOptionsStart(builder) def SequenceRNNOptionsAddTimeMajor(builder, timeMajor): builder.PrependBoolSlot(0, timeMajor, 0) +def AddTimeMajor(builder, timeMajor): + return SequenceRNNOptionsAddTimeMajor(builder, timeMajor) def SequenceRNNOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(1, fusedActivationFunction, 0) +def AddFusedActivationFunction(builder, fusedActivationFunction): + return SequenceRNNOptionsAddFusedActivationFunction(builder, fusedActivationFunction) def SequenceRNNOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): builder.PrependBoolSlot(2, asymmetricQuantizeInputs, 0) +def AddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): + return SequenceRNNOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs) def SequenceRNNOptionsEnd(builder): return builder.EndObject() +def End(builder): + return SequenceRNNOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/ShapeOptions.py b/ethosu/vela/tflite/ShapeOptions.py index e3f64d6c..6a9d6f90 100644 --- a/ethosu/vela/tflite/ShapeOptions.py +++ b/ethosu/vela/tflite/ShapeOptions.py @@ -10,13 +10,17 @@ class ShapeOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsShapeOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = ShapeOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsShapeOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def ShapeOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -32,5 +36,11 @@ class ShapeOptions(object): return 0 def ShapeOptionsStart(builder): builder.StartObject(1) +def Start(builder): + return ShapeOptionsStart(builder) def ShapeOptionsAddOutType(builder, outType): builder.PrependInt8Slot(0, outType, 0) +def AddOutType(builder, outType): + return ShapeOptionsAddOutType(builder, outType) def ShapeOptionsEnd(builder): return builder.EndObject() +def End(builder): + return ShapeOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/SignatureDef.py b/ethosu/vela/tflite/SignatureDef.py index 295ec854..2f0ac97c 100644 --- a/ethosu/vela/tflite/SignatureDef.py +++ b/ethosu/vela/tflite/SignatureDef.py @@ -10,13 +10,17 @@ class SignatureDef(object): __slots__ = ['_tab'] @classmethod - def GetRootAsSignatureDef(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = SignatureDef() x.Init(buf, n + offset) return x @classmethod + def GetRootAsSignatureDef(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def SignatureDefBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -31,7 +35,7 @@ class SignatureDef(object): x = self._tab.Vector(o) x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 x = self._tab.Indirect(x) - from .TensorMap import TensorMap + from tflite.TensorMap import TensorMap obj = TensorMap() obj.Init(self._tab.Bytes, x) return obj @@ -56,7 +60,7 @@ class SignatureDef(object): x = self._tab.Vector(o) x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 x = self._tab.Indirect(x) - from .TensorMap import TensorMap + from tflite.TensorMap import TensorMap obj = TensorMap() obj.Init(self._tab.Bytes, x) return obj @@ -75,24 +79,40 @@ class SignatureDef(object): return o == 0 # SignatureDef - def MethodName(self): + def SignatureKey(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) if o != 0: return self._tab.String(o + self._tab.Pos) return None # SignatureDef - def Key(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + def SubgraphIndex(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) if o != 0: - return self._tab.String(o + self._tab.Pos) - return None + return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) + return 0 -def SignatureDefStart(builder): builder.StartObject(4) +def SignatureDefStart(builder): builder.StartObject(5) +def Start(builder): + return SignatureDefStart(builder) def SignatureDefAddInputs(builder, inputs): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(inputs), 0) +def AddInputs(builder, inputs): + return SignatureDefAddInputs(builder, inputs) def SignatureDefStartInputsVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def StartInputsVector(builder, numElems): + return SignatureDefStartInputsVector(builder, numElems) def SignatureDefAddOutputs(builder, outputs): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(outputs), 0) +def AddOutputs(builder, outputs): + return SignatureDefAddOutputs(builder, outputs) def SignatureDefStartOutputsVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def SignatureDefAddMethodName(builder, methodName): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(methodName), 0) -def SignatureDefAddKey(builder, key): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(key), 0) +def StartOutputsVector(builder, numElems): + return SignatureDefStartOutputsVector(builder, numElems) +def SignatureDefAddSignatureKey(builder, signatureKey): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(signatureKey), 0) +def AddSignatureKey(builder, signatureKey): + return SignatureDefAddSignatureKey(builder, signatureKey) +def SignatureDefAddSubgraphIndex(builder, subgraphIndex): builder.PrependUint32Slot(4, subgraphIndex, 0) +def AddSubgraphIndex(builder, subgraphIndex): + return SignatureDefAddSubgraphIndex(builder, subgraphIndex) def SignatureDefEnd(builder): return builder.EndObject() +def End(builder): + return SignatureDefEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/SkipGramOptions.py b/ethosu/vela/tflite/SkipGramOptions.py index cd66e119..19a59b64 100644 --- a/ethosu/vela/tflite/SkipGramOptions.py +++ b/ethosu/vela/tflite/SkipGramOptions.py @@ -10,13 +10,17 @@ class SkipGramOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsSkipGramOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = SkipGramOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsSkipGramOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def SkipGramOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -46,7 +50,17 @@ class SkipGramOptions(object): return False def SkipGramOptionsStart(builder): builder.StartObject(3) +def Start(builder): + return SkipGramOptionsStart(builder) def SkipGramOptionsAddNgramSize(builder, ngramSize): builder.PrependInt32Slot(0, ngramSize, 0) +def AddNgramSize(builder, ngramSize): + return SkipGramOptionsAddNgramSize(builder, ngramSize) def SkipGramOptionsAddMaxSkipSize(builder, maxSkipSize): builder.PrependInt32Slot(1, maxSkipSize, 0) +def AddMaxSkipSize(builder, maxSkipSize): + return SkipGramOptionsAddMaxSkipSize(builder, maxSkipSize) def SkipGramOptionsAddIncludeAllNgrams(builder, includeAllNgrams): builder.PrependBoolSlot(2, includeAllNgrams, 0) +def AddIncludeAllNgrams(builder, includeAllNgrams): + return SkipGramOptionsAddIncludeAllNgrams(builder, includeAllNgrams) def SkipGramOptionsEnd(builder): return builder.EndObject() +def End(builder): + return SkipGramOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/SliceOptions.py b/ethosu/vela/tflite/SliceOptions.py index ef16bb12..334b7e40 100644 --- a/ethosu/vela/tflite/SliceOptions.py +++ b/ethosu/vela/tflite/SliceOptions.py @@ -10,13 +10,17 @@ class SliceOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsSliceOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = SliceOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsSliceOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def SliceOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -25,4 +29,8 @@ class SliceOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def SliceOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return SliceOptionsStart(builder) def SliceOptionsEnd(builder): return builder.EndObject() +def End(builder): + return SliceOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/SoftmaxOptions.py b/ethosu/vela/tflite/SoftmaxOptions.py index 7ee4a19f..063b1c10 100644 --- a/ethosu/vela/tflite/SoftmaxOptions.py +++ b/ethosu/vela/tflite/SoftmaxOptions.py @@ -10,13 +10,17 @@ class SoftmaxOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsSoftmaxOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = SoftmaxOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsSoftmaxOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def SoftmaxOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -32,5 +36,11 @@ class SoftmaxOptions(object): return 0.0 def SoftmaxOptionsStart(builder): builder.StartObject(1) +def Start(builder): + return SoftmaxOptionsStart(builder) def SoftmaxOptionsAddBeta(builder, beta): builder.PrependFloat32Slot(0, beta, 0.0) +def AddBeta(builder, beta): + return SoftmaxOptionsAddBeta(builder, beta) def SoftmaxOptionsEnd(builder): return builder.EndObject() +def End(builder): + return SoftmaxOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/SpaceToBatchNDOptions.py b/ethosu/vela/tflite/SpaceToBatchNDOptions.py index e066d610..18031b7e 100644 --- a/ethosu/vela/tflite/SpaceToBatchNDOptions.py +++ b/ethosu/vela/tflite/SpaceToBatchNDOptions.py @@ -10,13 +10,17 @@ class SpaceToBatchNDOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsSpaceToBatchNDOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = SpaceToBatchNDOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsSpaceToBatchNDOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def SpaceToBatchNDOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -25,4 +29,8 @@ class SpaceToBatchNDOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def SpaceToBatchNDOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return SpaceToBatchNDOptionsStart(builder) def SpaceToBatchNDOptionsEnd(builder): return builder.EndObject() +def End(builder): + return SpaceToBatchNDOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/SpaceToDepthOptions.py b/ethosu/vela/tflite/SpaceToDepthOptions.py index 80f9f8ac..505e6d2f 100644 --- a/ethosu/vela/tflite/SpaceToDepthOptions.py +++ b/ethosu/vela/tflite/SpaceToDepthOptions.py @@ -10,13 +10,17 @@ class SpaceToDepthOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsSpaceToDepthOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = SpaceToDepthOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsSpaceToDepthOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def SpaceToDepthOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -32,5 +36,11 @@ class SpaceToDepthOptions(object): return 0 def SpaceToDepthOptionsStart(builder): builder.StartObject(1) +def Start(builder): + return SpaceToDepthOptionsStart(builder) def SpaceToDepthOptionsAddBlockSize(builder, blockSize): builder.PrependInt32Slot(0, blockSize, 0) +def AddBlockSize(builder, blockSize): + return SpaceToDepthOptionsAddBlockSize(builder, blockSize) def SpaceToDepthOptionsEnd(builder): return builder.EndObject() +def End(builder): + return SpaceToDepthOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/SparseIndexVector.py b/ethosu/vela/tflite/SparseIndexVector.py index fd35a03b..e2c9db78 100644 --- a/ethosu/vela/tflite/SparseIndexVector.py +++ b/ethosu/vela/tflite/SparseIndexVector.py @@ -7,4 +7,3 @@ class SparseIndexVector(object): Int32Vector = 1 Uint16Vector = 2 Uint8Vector = 3 - diff --git a/ethosu/vela/tflite/SparseToDenseOptions.py b/ethosu/vela/tflite/SparseToDenseOptions.py index 328aadf4..185b2a0c 100644 --- a/ethosu/vela/tflite/SparseToDenseOptions.py +++ b/ethosu/vela/tflite/SparseToDenseOptions.py @@ -10,13 +10,17 @@ class SparseToDenseOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsSparseToDenseOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = SparseToDenseOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsSparseToDenseOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def SparseToDenseOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -32,5 +36,11 @@ class SparseToDenseOptions(object): return False def SparseToDenseOptionsStart(builder): builder.StartObject(1) +def Start(builder): + return SparseToDenseOptionsStart(builder) def SparseToDenseOptionsAddValidateIndices(builder, validateIndices): builder.PrependBoolSlot(0, validateIndices, 0) +def AddValidateIndices(builder, validateIndices): + return SparseToDenseOptionsAddValidateIndices(builder, validateIndices) def SparseToDenseOptionsEnd(builder): return builder.EndObject() +def End(builder): + return SparseToDenseOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/SparsityParameters.py b/ethosu/vela/tflite/SparsityParameters.py index b4d4c1c7..75e8b127 100644 --- a/ethosu/vela/tflite/SparsityParameters.py +++ b/ethosu/vela/tflite/SparsityParameters.py @@ -10,13 +10,17 @@ class SparsityParameters(object): __slots__ = ['_tab'] @classmethod - def GetRootAsSparsityParameters(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = SparsityParameters() x.Init(buf, n + offset) return x @classmethod + def GetRootAsSparsityParameters(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def SparsityParametersBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -85,7 +89,7 @@ class SparsityParameters(object): x = self._tab.Vector(o) x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 x = self._tab.Indirect(x) - from .DimensionMetadata import DimensionMetadata + from tflite.DimensionMetadata import DimensionMetadata obj = DimensionMetadata() obj.Init(self._tab.Bytes, x) return obj @@ -104,10 +108,26 @@ class SparsityParameters(object): return o == 0 def SparsityParametersStart(builder): builder.StartObject(3) +def Start(builder): + return SparsityParametersStart(builder) def SparsityParametersAddTraversalOrder(builder, traversalOrder): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(traversalOrder), 0) +def AddTraversalOrder(builder, traversalOrder): + return SparsityParametersAddTraversalOrder(builder, traversalOrder) def SparsityParametersStartTraversalOrderVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def StartTraversalOrderVector(builder, numElems): + return SparsityParametersStartTraversalOrderVector(builder, numElems) def SparsityParametersAddBlockMap(builder, blockMap): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(blockMap), 0) +def AddBlockMap(builder, blockMap): + return SparsityParametersAddBlockMap(builder, blockMap) def SparsityParametersStartBlockMapVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def StartBlockMapVector(builder, numElems): + return SparsityParametersStartBlockMapVector(builder, numElems) def SparsityParametersAddDimMetadata(builder, dimMetadata): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(dimMetadata), 0) +def AddDimMetadata(builder, dimMetadata): + return SparsityParametersAddDimMetadata(builder, dimMetadata) def SparsityParametersStartDimMetadataVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def StartDimMetadataVector(builder, numElems): + return SparsityParametersStartDimMetadataVector(builder, numElems) def SparsityParametersEnd(builder): return builder.EndObject() +def End(builder): + return SparsityParametersEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/SplitOptions.py b/ethosu/vela/tflite/SplitOptions.py index 54ce1b3b..c7dd92f9 100644 --- a/ethosu/vela/tflite/SplitOptions.py +++ b/ethosu/vela/tflite/SplitOptions.py @@ -10,13 +10,17 @@ class SplitOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsSplitOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = SplitOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsSplitOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def SplitOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -32,5 +36,11 @@ class SplitOptions(object): return 0 def SplitOptionsStart(builder): builder.StartObject(1) +def Start(builder): + return SplitOptionsStart(builder) def SplitOptionsAddNumSplits(builder, numSplits): builder.PrependInt32Slot(0, numSplits, 0) +def AddNumSplits(builder, numSplits): + return SplitOptionsAddNumSplits(builder, numSplits) def SplitOptionsEnd(builder): return builder.EndObject() +def End(builder): + return SplitOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/SplitVOptions.py b/ethosu/vela/tflite/SplitVOptions.py index 90f0d2e8..64355061 100644 --- a/ethosu/vela/tflite/SplitVOptions.py +++ b/ethosu/vela/tflite/SplitVOptions.py @@ -10,13 +10,17 @@ class SplitVOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsSplitVOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = SplitVOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsSplitVOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def SplitVOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -32,5 +36,11 @@ class SplitVOptions(object): return 0 def SplitVOptionsStart(builder): builder.StartObject(1) +def Start(builder): + return SplitVOptionsStart(builder) def SplitVOptionsAddNumSplits(builder, numSplits): builder.PrependInt32Slot(0, numSplits, 0) +def AddNumSplits(builder, numSplits): + return SplitVOptionsAddNumSplits(builder, numSplits) def SplitVOptionsEnd(builder): return builder.EndObject() +def End(builder): + return SplitVOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/SquareOptions.py b/ethosu/vela/tflite/SquareOptions.py index fb72154e..c1bdca8e 100644 --- a/ethosu/vela/tflite/SquareOptions.py +++ b/ethosu/vela/tflite/SquareOptions.py @@ -10,13 +10,17 @@ class SquareOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsSquareOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = SquareOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsSquareOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def SquareOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -25,4 +29,8 @@ class SquareOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def SquareOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return SquareOptionsStart(builder) def SquareOptionsEnd(builder): return builder.EndObject() +def End(builder): + return SquareOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/SquaredDifferenceOptions.py b/ethosu/vela/tflite/SquaredDifferenceOptions.py index dd1969a2..115455b5 100644 --- a/ethosu/vela/tflite/SquaredDifferenceOptions.py +++ b/ethosu/vela/tflite/SquaredDifferenceOptions.py @@ -10,13 +10,17 @@ class SquaredDifferenceOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsSquaredDifferenceOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = SquaredDifferenceOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsSquaredDifferenceOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def SquaredDifferenceOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -25,4 +29,8 @@ class SquaredDifferenceOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def SquaredDifferenceOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return SquaredDifferenceOptionsStart(builder) def SquaredDifferenceOptionsEnd(builder): return builder.EndObject() +def End(builder): + return SquaredDifferenceOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/SqueezeOptions.py b/ethosu/vela/tflite/SqueezeOptions.py index 1904abf1..1a8a6af4 100644 --- a/ethosu/vela/tflite/SqueezeOptions.py +++ b/ethosu/vela/tflite/SqueezeOptions.py @@ -10,13 +10,17 @@ class SqueezeOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsSqueezeOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = SqueezeOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsSqueezeOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def SqueezeOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -52,6 +56,14 @@ class SqueezeOptions(object): return o == 0 def SqueezeOptionsStart(builder): builder.StartObject(1) +def Start(builder): + return SqueezeOptionsStart(builder) def SqueezeOptionsAddSqueezeDims(builder, squeezeDims): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(squeezeDims), 0) +def AddSqueezeDims(builder, squeezeDims): + return SqueezeOptionsAddSqueezeDims(builder, squeezeDims) def SqueezeOptionsStartSqueezeDimsVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def StartSqueezeDimsVector(builder, numElems): + return SqueezeOptionsStartSqueezeDimsVector(builder, numElems) def SqueezeOptionsEnd(builder): return builder.EndObject() +def End(builder): + return SqueezeOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/StridedSliceOptions.py b/ethosu/vela/tflite/StridedSliceOptions.py index c6cb7908..ccc2701c 100644 --- a/ethosu/vela/tflite/StridedSliceOptions.py +++ b/ethosu/vela/tflite/StridedSliceOptions.py @@ -10,13 +10,17 @@ class StridedSliceOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsStridedSliceOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = StridedSliceOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsStridedSliceOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def StridedSliceOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -60,9 +64,23 @@ class StridedSliceOptions(object): return 0 def StridedSliceOptionsStart(builder): builder.StartObject(5) +def Start(builder): + return StridedSliceOptionsStart(builder) def StridedSliceOptionsAddBeginMask(builder, beginMask): builder.PrependInt32Slot(0, beginMask, 0) +def AddBeginMask(builder, beginMask): + return StridedSliceOptionsAddBeginMask(builder, beginMask) def StridedSliceOptionsAddEndMask(builder, endMask): builder.PrependInt32Slot(1, endMask, 0) +def AddEndMask(builder, endMask): + return StridedSliceOptionsAddEndMask(builder, endMask) def StridedSliceOptionsAddEllipsisMask(builder, ellipsisMask): builder.PrependInt32Slot(2, ellipsisMask, 0) +def AddEllipsisMask(builder, ellipsisMask): + return StridedSliceOptionsAddEllipsisMask(builder, ellipsisMask) def StridedSliceOptionsAddNewAxisMask(builder, newAxisMask): builder.PrependInt32Slot(3, newAxisMask, 0) +def AddNewAxisMask(builder, newAxisMask): + return StridedSliceOptionsAddNewAxisMask(builder, newAxisMask) def StridedSliceOptionsAddShrinkAxisMask(builder, shrinkAxisMask): builder.PrependInt32Slot(4, shrinkAxisMask, 0) +def AddShrinkAxisMask(builder, shrinkAxisMask): + return StridedSliceOptionsAddShrinkAxisMask(builder, shrinkAxisMask) def StridedSliceOptionsEnd(builder): return builder.EndObject() +def End(builder): + return StridedSliceOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/SubGraph.py b/ethosu/vela/tflite/SubGraph.py index 163124d6..6ceb2772 100644 --- a/ethosu/vela/tflite/SubGraph.py +++ b/ethosu/vela/tflite/SubGraph.py @@ -10,13 +10,17 @@ class SubGraph(object): __slots__ = ['_tab'] @classmethod - def GetRootAsSubGraph(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = SubGraph() x.Init(buf, n + offset) return x @classmethod + def GetRootAsSubGraph(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def SubGraphBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -136,13 +140,35 @@ class SubGraph(object): return None def SubGraphStart(builder): builder.StartObject(5) +def Start(builder): + return SubGraphStart(builder) def SubGraphAddTensors(builder, tensors): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(tensors), 0) +def AddTensors(builder, tensors): + return SubGraphAddTensors(builder, tensors) def SubGraphStartTensorsVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def StartTensorsVector(builder, numElems): + return SubGraphStartTensorsVector(builder, numElems) def SubGraphAddInputs(builder, inputs): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(inputs), 0) +def AddInputs(builder, inputs): + return SubGraphAddInputs(builder, inputs) def SubGraphStartInputsVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def StartInputsVector(builder, numElems): + return SubGraphStartInputsVector(builder, numElems) def SubGraphAddOutputs(builder, outputs): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(outputs), 0) +def AddOutputs(builder, outputs): + return SubGraphAddOutputs(builder, outputs) def SubGraphStartOutputsVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def StartOutputsVector(builder, numElems): + return SubGraphStartOutputsVector(builder, numElems) def SubGraphAddOperators(builder, operators): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(operators), 0) +def AddOperators(builder, operators): + return SubGraphAddOperators(builder, operators) def SubGraphStartOperatorsVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def StartOperatorsVector(builder, numElems): + return SubGraphStartOperatorsVector(builder, numElems) def SubGraphAddName(builder, name): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) +def AddName(builder, name): + return SubGraphAddName(builder, name) def SubGraphEnd(builder): return builder.EndObject() +def End(builder): + return SubGraphEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/SubOptions.py b/ethosu/vela/tflite/SubOptions.py index 1a9ba978..65e9f5a0 100644 --- a/ethosu/vela/tflite/SubOptions.py +++ b/ethosu/vela/tflite/SubOptions.py @@ -10,13 +10,17 @@ class SubOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsSubOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = SubOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsSubOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def SubOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -39,6 +43,14 @@ class SubOptions(object): return True def SubOptionsStart(builder): builder.StartObject(2) +def Start(builder): + return SubOptionsStart(builder) def SubOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(0, fusedActivationFunction, 0) +def AddFusedActivationFunction(builder, fusedActivationFunction): + return SubOptionsAddFusedActivationFunction(builder, fusedActivationFunction) def SubOptionsAddPotScaleInt16(builder, potScaleInt16): builder.PrependBoolSlot(1, potScaleInt16, 1) +def AddPotScaleInt16(builder, potScaleInt16): + return SubOptionsAddPotScaleInt16(builder, potScaleInt16) def SubOptionsEnd(builder): return builder.EndObject() +def End(builder): + return SubOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/Tensor.py b/ethosu/vela/tflite/Tensor.py index 6a947849..335599e5 100644 --- a/ethosu/vela/tflite/Tensor.py +++ b/ethosu/vela/tflite/Tensor.py @@ -10,13 +10,17 @@ class Tensor(object): __slots__ = ['_tab'] @classmethod - def GetRootAsTensor(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = Tensor() x.Init(buf, n + offset) return x @classmethod + def GetRootAsTensor(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def TensorBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -129,14 +133,38 @@ class Tensor(object): return o == 0 def TensorStart(builder): builder.StartObject(8) +def Start(builder): + return TensorStart(builder) def TensorAddShape(builder, shape): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(shape), 0) +def AddShape(builder, shape): + return TensorAddShape(builder, shape) def TensorStartShapeVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def StartShapeVector(builder, numElems): + return TensorStartShapeVector(builder, numElems) def TensorAddType(builder, type): builder.PrependInt8Slot(1, type, 0) +def AddType(builder, type): + return TensorAddType(builder, type) def TensorAddBuffer(builder, buffer): builder.PrependUint32Slot(2, buffer, 0) +def AddBuffer(builder, buffer): + return TensorAddBuffer(builder, buffer) def TensorAddName(builder, name): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) +def AddName(builder, name): + return TensorAddName(builder, name) def TensorAddQuantization(builder, quantization): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(quantization), 0) +def AddQuantization(builder, quantization): + return TensorAddQuantization(builder, quantization) def TensorAddIsVariable(builder, isVariable): builder.PrependBoolSlot(5, isVariable, 0) +def AddIsVariable(builder, isVariable): + return TensorAddIsVariable(builder, isVariable) def TensorAddSparsity(builder, sparsity): builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(sparsity), 0) +def AddSparsity(builder, sparsity): + return TensorAddSparsity(builder, sparsity) def TensorAddShapeSignature(builder, shapeSignature): builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(shapeSignature), 0) +def AddShapeSignature(builder, shapeSignature): + return TensorAddShapeSignature(builder, shapeSignature) def TensorStartShapeSignatureVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def StartShapeSignatureVector(builder, numElems): + return TensorStartShapeSignatureVector(builder, numElems) def TensorEnd(builder): return builder.EndObject() +def End(builder): + return TensorEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/TensorMap.py b/ethosu/vela/tflite/TensorMap.py index 9b41e0b9..3ade6fa7 100644 --- a/ethosu/vela/tflite/TensorMap.py +++ b/ethosu/vela/tflite/TensorMap.py @@ -10,13 +10,17 @@ class TensorMap(object): __slots__ = ['_tab'] @classmethod - def GetRootAsTensorMap(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = TensorMap() x.Init(buf, n + offset) return x @classmethod + def GetRootAsTensorMap(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def TensorMapBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -39,6 +43,14 @@ class TensorMap(object): return 0 def TensorMapStart(builder): builder.StartObject(2) +def Start(builder): + return TensorMapStart(builder) def TensorMapAddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) +def AddName(builder, name): + return TensorMapAddName(builder, name) def TensorMapAddTensorIndex(builder, tensorIndex): builder.PrependUint32Slot(1, tensorIndex, 0) +def AddTensorIndex(builder, tensorIndex): + return TensorMapAddTensorIndex(builder, tensorIndex) def TensorMapEnd(builder): return builder.EndObject() +def End(builder): + return TensorMapEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/TensorType.py b/ethosu/vela/tflite/TensorType.py index a5235f45..373cd7b4 100644 --- a/ethosu/vela/tflite/TensorType.py +++ b/ethosu/vela/tflite/TensorType.py @@ -19,4 +19,3 @@ class TensorType(object): RESOURCE = 13 VARIANT = 14 UINT32 = 15 - diff --git a/ethosu/vela/tflite/TileOptions.py b/ethosu/vela/tflite/TileOptions.py index 73eebc64..645cf34a 100644 --- a/ethosu/vela/tflite/TileOptions.py +++ b/ethosu/vela/tflite/TileOptions.py @@ -10,13 +10,17 @@ class TileOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsTileOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = TileOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsTileOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def TileOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -25,4 +29,8 @@ class TileOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def TileOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return TileOptionsStart(builder) def TileOptionsEnd(builder): return builder.EndObject() +def End(builder): + return TileOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/TopKV2Options.py b/ethosu/vela/tflite/TopKV2Options.py index c8c13369..da080741 100644 --- a/ethosu/vela/tflite/TopKV2Options.py +++ b/ethosu/vela/tflite/TopKV2Options.py @@ -10,13 +10,17 @@ class TopKV2Options(object): __slots__ = ['_tab'] @classmethod - def GetRootAsTopKV2Options(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = TopKV2Options() x.Init(buf, n + offset) return x @classmethod + def GetRootAsTopKV2Options(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def TopKV2OptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -25,4 +29,8 @@ class TopKV2Options(object): self._tab = flatbuffers.table.Table(buf, pos) def TopKV2OptionsStart(builder): builder.StartObject(0) +def Start(builder): + return TopKV2OptionsStart(builder) def TopKV2OptionsEnd(builder): return builder.EndObject() +def End(builder): + return TopKV2OptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/TransposeConvOptions.py b/ethosu/vela/tflite/TransposeConvOptions.py index f291141f..a11a79e9 100644 --- a/ethosu/vela/tflite/TransposeConvOptions.py +++ b/ethosu/vela/tflite/TransposeConvOptions.py @@ -10,13 +10,17 @@ class TransposeConvOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsTransposeConvOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = TransposeConvOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsTransposeConvOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def TransposeConvOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -46,7 +50,17 @@ class TransposeConvOptions(object): return 0 def TransposeConvOptionsStart(builder): builder.StartObject(3) +def Start(builder): + return TransposeConvOptionsStart(builder) def TransposeConvOptionsAddPadding(builder, padding): builder.PrependInt8Slot(0, padding, 0) +def AddPadding(builder, padding): + return TransposeConvOptionsAddPadding(builder, padding) def TransposeConvOptionsAddStrideW(builder, strideW): builder.PrependInt32Slot(1, strideW, 0) +def AddStrideW(builder, strideW): + return TransposeConvOptionsAddStrideW(builder, strideW) def TransposeConvOptionsAddStrideH(builder, strideH): builder.PrependInt32Slot(2, strideH, 0) +def AddStrideH(builder, strideH): + return TransposeConvOptionsAddStrideH(builder, strideH) def TransposeConvOptionsEnd(builder): return builder.EndObject() +def End(builder): + return TransposeConvOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/TransposeOptions.py b/ethosu/vela/tflite/TransposeOptions.py index 02969653..7dd90ff7 100644 --- a/ethosu/vela/tflite/TransposeOptions.py +++ b/ethosu/vela/tflite/TransposeOptions.py @@ -10,13 +10,17 @@ class TransposeOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsTransposeOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = TransposeOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsTransposeOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def TransposeOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -25,4 +29,8 @@ class TransposeOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def TransposeOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return TransposeOptionsStart(builder) def TransposeOptionsEnd(builder): return builder.EndObject() +def End(builder): + return TransposeOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/Uint16Vector.py b/ethosu/vela/tflite/Uint16Vector.py index 247fada7..61549c5d 100644 --- a/ethosu/vela/tflite/Uint16Vector.py +++ b/ethosu/vela/tflite/Uint16Vector.py @@ -10,13 +10,17 @@ class Uint16Vector(object): __slots__ = ['_tab'] @classmethod - def GetRootAsUint16Vector(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = Uint16Vector() x.Init(buf, n + offset) return x @classmethod + def GetRootAsUint16Vector(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def Uint16VectorBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -52,6 +56,14 @@ class Uint16Vector(object): return o == 0 def Uint16VectorStart(builder): builder.StartObject(1) +def Start(builder): + return Uint16VectorStart(builder) def Uint16VectorAddValues(builder, values): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(values), 0) +def AddValues(builder, values): + return Uint16VectorAddValues(builder, values) def Uint16VectorStartValuesVector(builder, numElems): return builder.StartVector(2, numElems, 2) +def StartValuesVector(builder, numElems): + return Uint16VectorStartValuesVector(builder, numElems) def Uint16VectorEnd(builder): return builder.EndObject() +def End(builder): + return Uint16VectorEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/Uint8Vector.py b/ethosu/vela/tflite/Uint8Vector.py index ce3895e1..1f29c600 100644 --- a/ethosu/vela/tflite/Uint8Vector.py +++ b/ethosu/vela/tflite/Uint8Vector.py @@ -10,13 +10,17 @@ class Uint8Vector(object): __slots__ = ['_tab'] @classmethod - def GetRootAsUint8Vector(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = Uint8Vector() x.Init(buf, n + offset) return x @classmethod + def GetRootAsUint8Vector(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def Uint8VectorBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -52,6 +56,14 @@ class Uint8Vector(object): return o == 0 def Uint8VectorStart(builder): builder.StartObject(1) +def Start(builder): + return Uint8VectorStart(builder) def Uint8VectorAddValues(builder, values): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(values), 0) +def AddValues(builder, values): + return Uint8VectorAddValues(builder, values) def Uint8VectorStartValuesVector(builder, numElems): return builder.StartVector(1, numElems, 1) +def StartValuesVector(builder, numElems): + return Uint8VectorStartValuesVector(builder, numElems) def Uint8VectorEnd(builder): return builder.EndObject() +def End(builder): + return Uint8VectorEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/UnidirectionalSequenceLSTMOptions.py b/ethosu/vela/tflite/UnidirectionalSequenceLSTMOptions.py index b945aa9f..16641a74 100644 --- a/ethosu/vela/tflite/UnidirectionalSequenceLSTMOptions.py +++ b/ethosu/vela/tflite/UnidirectionalSequenceLSTMOptions.py @@ -10,13 +10,17 @@ class UnidirectionalSequenceLSTMOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsUnidirectionalSequenceLSTMOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = UnidirectionalSequenceLSTMOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsUnidirectionalSequenceLSTMOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def UnidirectionalSequenceLSTMOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -60,9 +64,23 @@ class UnidirectionalSequenceLSTMOptions(object): return False def UnidirectionalSequenceLSTMOptionsStart(builder): builder.StartObject(5) +def Start(builder): + return UnidirectionalSequenceLSTMOptionsStart(builder) def UnidirectionalSequenceLSTMOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(0, fusedActivationFunction, 0) +def AddFusedActivationFunction(builder, fusedActivationFunction): + return UnidirectionalSequenceLSTMOptionsAddFusedActivationFunction(builder, fusedActivationFunction) def UnidirectionalSequenceLSTMOptionsAddCellClip(builder, cellClip): builder.PrependFloat32Slot(1, cellClip, 0.0) +def AddCellClip(builder, cellClip): + return UnidirectionalSequenceLSTMOptionsAddCellClip(builder, cellClip) def UnidirectionalSequenceLSTMOptionsAddProjClip(builder, projClip): builder.PrependFloat32Slot(2, projClip, 0.0) +def AddProjClip(builder, projClip): + return UnidirectionalSequenceLSTMOptionsAddProjClip(builder, projClip) def UnidirectionalSequenceLSTMOptionsAddTimeMajor(builder, timeMajor): builder.PrependBoolSlot(3, timeMajor, 0) +def AddTimeMajor(builder, timeMajor): + return UnidirectionalSequenceLSTMOptionsAddTimeMajor(builder, timeMajor) def UnidirectionalSequenceLSTMOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): builder.PrependBoolSlot(4, asymmetricQuantizeInputs, 0) +def AddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): + return UnidirectionalSequenceLSTMOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs) def UnidirectionalSequenceLSTMOptionsEnd(builder): return builder.EndObject() +def End(builder): + return UnidirectionalSequenceLSTMOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/UniqueOptions.py b/ethosu/vela/tflite/UniqueOptions.py index 1088ef7d..7b21d095 100644 --- a/ethosu/vela/tflite/UniqueOptions.py +++ b/ethosu/vela/tflite/UniqueOptions.py @@ -10,13 +10,17 @@ class UniqueOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsUniqueOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = UniqueOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsUniqueOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def UniqueOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -32,5 +36,11 @@ class UniqueOptions(object): return 2 def UniqueOptionsStart(builder): builder.StartObject(1) +def Start(builder): + return UniqueOptionsStart(builder) def UniqueOptionsAddIdxOutType(builder, idxOutType): builder.PrependInt8Slot(0, idxOutType, 2) +def AddIdxOutType(builder, idxOutType): + return UniqueOptionsAddIdxOutType(builder, idxOutType) def UniqueOptionsEnd(builder): return builder.EndObject() +def End(builder): + return UniqueOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/UnpackOptions.py b/ethosu/vela/tflite/UnpackOptions.py index a8cc597b..f7c2a0dc 100644 --- a/ethosu/vela/tflite/UnpackOptions.py +++ b/ethosu/vela/tflite/UnpackOptions.py @@ -10,13 +10,17 @@ class UnpackOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsUnpackOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = UnpackOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsUnpackOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def UnpackOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -39,6 +43,14 @@ class UnpackOptions(object): return 0 def UnpackOptionsStart(builder): builder.StartObject(2) +def Start(builder): + return UnpackOptionsStart(builder) def UnpackOptionsAddNum(builder, num): builder.PrependInt32Slot(0, num, 0) +def AddNum(builder, num): + return UnpackOptionsAddNum(builder, num) def UnpackOptionsAddAxis(builder, axis): builder.PrependInt32Slot(1, axis, 0) +def AddAxis(builder, axis): + return UnpackOptionsAddAxis(builder, axis) def UnpackOptionsEnd(builder): return builder.EndObject() +def End(builder): + return UnpackOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/VarHandleOptions.py b/ethosu/vela/tflite/VarHandleOptions.py new file mode 100644 index 00000000..57305602 --- /dev/null +++ b/ethosu/vela/tflite/VarHandleOptions.py @@ -0,0 +1,56 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class VarHandleOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = VarHandleOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsVarHandleOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def VarHandleOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # VarHandleOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # VarHandleOptions + def Container(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.String(o + self._tab.Pos) + return None + + # VarHandleOptions + def SharedName(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.String(o + self._tab.Pos) + return None + +def VarHandleOptionsStart(builder): builder.StartObject(2) +def Start(builder): + return VarHandleOptionsStart(builder) +def VarHandleOptionsAddContainer(builder, container): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(container), 0) +def AddContainer(builder, container): + return VarHandleOptionsAddContainer(builder, container) +def VarHandleOptionsAddSharedName(builder, sharedName): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(sharedName), 0) +def AddSharedName(builder, sharedName): + return VarHandleOptionsAddSharedName(builder, sharedName) +def VarHandleOptionsEnd(builder): return builder.EndObject() +def End(builder): + return VarHandleOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/WhereOptions.py b/ethosu/vela/tflite/WhereOptions.py index fd4f4408..6c6f509e 100644 --- a/ethosu/vela/tflite/WhereOptions.py +++ b/ethosu/vela/tflite/WhereOptions.py @@ -10,13 +10,17 @@ class WhereOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsWhereOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = WhereOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsWhereOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def WhereOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -25,4 +29,8 @@ class WhereOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def WhereOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return WhereOptionsStart(builder) def WhereOptionsEnd(builder): return builder.EndObject() +def End(builder): + return WhereOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/WhileOptions.py b/ethosu/vela/tflite/WhileOptions.py index 49f32a2e..40a386a0 100644 --- a/ethosu/vela/tflite/WhileOptions.py +++ b/ethosu/vela/tflite/WhileOptions.py @@ -10,13 +10,17 @@ class WhileOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsWhileOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = WhileOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsWhileOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def WhileOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -39,6 +43,14 @@ class WhileOptions(object): return 0 def WhileOptionsStart(builder): builder.StartObject(2) +def Start(builder): + return WhileOptionsStart(builder) def WhileOptionsAddCondSubgraphIndex(builder, condSubgraphIndex): builder.PrependInt32Slot(0, condSubgraphIndex, 0) +def AddCondSubgraphIndex(builder, condSubgraphIndex): + return WhileOptionsAddCondSubgraphIndex(builder, condSubgraphIndex) def WhileOptionsAddBodySubgraphIndex(builder, bodySubgraphIndex): builder.PrependInt32Slot(1, bodySubgraphIndex, 0) +def AddBodySubgraphIndex(builder, bodySubgraphIndex): + return WhileOptionsAddBodySubgraphIndex(builder, bodySubgraphIndex) def WhileOptionsEnd(builder): return builder.EndObject() +def End(builder): + return WhileOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite/ZerosLikeOptions.py b/ethosu/vela/tflite/ZerosLikeOptions.py index 098d0512..62f60511 100644 --- a/ethosu/vela/tflite/ZerosLikeOptions.py +++ b/ethosu/vela/tflite/ZerosLikeOptions.py @@ -10,13 +10,17 @@ class ZerosLikeOptions(object): __slots__ = ['_tab'] @classmethod - def GetRootAsZerosLikeOptions(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = ZerosLikeOptions() x.Init(buf, n + offset) return x @classmethod + def GetRootAsZerosLikeOptions(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def ZerosLikeOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) @@ -25,4 +29,8 @@ class ZerosLikeOptions(object): self._tab = flatbuffers.table.Table(buf, pos) def ZerosLikeOptionsStart(builder): builder.StartObject(0) +def Start(builder): + return ZerosLikeOptionsStart(builder) def ZerosLikeOptionsEnd(builder): return builder.EndObject() +def End(builder): + return ZerosLikeOptionsEnd(builder) \ No newline at end of file diff --git a/ethosu/vela/tflite_mapping.py b/ethosu/vela/tflite_mapping.py index 396ed5ec..2a70b06c 100644 --- a/ethosu/vela/tflite_mapping.py +++ b/ethosu/vela/tflite_mapping.py @@ -31,6 +31,7 @@ from .tflite import AddNOptions from .tflite import AddOptions from .tflite import ArgMaxOptions from .tflite import ArgMinOptions +from .tflite import AssignVariableOptions from .tflite import BatchMatMulOptions from .tflite import BatchToSpaceNDOptions from .tflite import BidirectionalSequenceLSTMOptions @@ -96,8 +97,10 @@ from .tflite import PadV2Options from .tflite import Pool2DOptions from .tflite import PowOptions from .tflite import QuantizeOptions +from .tflite import RandomOptions from .tflite import RangeOptions from .tflite import RankOptions +from .tflite import ReadVariableOptions from .tflite import ReducerOptions from .tflite import ReshapeOptions from .tflite import ResizeBilinearOptions @@ -133,6 +136,7 @@ from .tflite import TransposeOptions from .tflite import UnidirectionalSequenceLSTMOptions from .tflite import UniqueOptions from .tflite import UnpackOptions +from .tflite import VarHandleOptions from .tflite import WhereOptions from .tflite import WhileOptions from .tflite import ZerosLikeOptions @@ -305,8 +309,13 @@ builtin_options_map = { BuiltinOptions.HashtableFindOptions: HashtableFindOptions.HashtableFindOptions, BuiltinOptions.HashtableImportOptions: HashtableImportOptions.HashtableImportOptions, BuiltinOptions.HashtableSizeOptions: HashtableSizeOptions.HashtableSizeOptions, + BuiltinOptions.VarHandleOptions: VarHandleOptions.VarHandleOptions, + BuiltinOptions.ReadVariableOptions: ReadVariableOptions.ReadVariableOptions, + BuiltinOptions.AssignVariableOptions: AssignVariableOptions.AssignVariableOptions, + BuiltinOptions.RandomOptions: RandomOptions.RandomOptions, } + builtin_options_inv_map = inverse_map(builtin_options_map) @@ -904,6 +913,19 @@ builtin_operator_map = { ), TFLITE_NO_INDICES, ), + BuiltinOperator.VAR_HANDLE: ( + Op.VarHandle, + OptionsSerializer("VarHandleOptions", ("container", "shared_name",),), + TFLITE_NO_INDICES, + ), + BuiltinOperator.READ_VARIABLE: (Op.ReadVariable, OptionsSerializer("ReadVariableOptions"), TFLITE_NO_INDICES), + BuiltinOperator.ASSIGN_VARIABLE: (Op.AssignVariable, OptionsSerializer("AssignVariableOptions"), TFLITE_NO_INDICES), + BuiltinOperator.BROADCAST_ARGS: (Op.BroadcastArgs, None, TFLITE_NO_INDICES), + BuiltinOperator.RANDOM_STANDARD_NORMAL: ( + Op.RandomStandardNormal, + OptionsSerializer("RandomOptions", ("seed", "seed2",),), + TFLITE_NO_INDICES, + ), BuiltinOperator.CUSTOM: (Op.Custom, CustomOptionsSerializer(), TFLITE_NO_INDICES), } -- cgit v1.2.1