diff options
40 files changed, 2083 insertions, 567 deletions
diff --git a/ethosu/vela/tosa/ArithmeticRightShiftAttribute.py b/ethosu/vela/tosa/ArithmeticRightShiftAttribute.py index ad7b9b0..f2aaeb5 100644 --- a/ethosu/vela/tosa/ArithmeticRightShiftAttribute.py +++ b/ethosu/vela/tosa/ArithmeticRightShiftAttribute.py @@ -3,17 +3,27 @@ # namespace: tosa import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class ArithmeticRightShiftAttribute(object): __slots__ = ['_tab'] @classmethod - def GetRootAsArithmeticRightShiftAttribute(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = ArithmeticRightShiftAttribute() x.Init(buf, n + offset) return x + @classmethod + def GetRootAsArithmeticRightShiftAttribute(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def ArithmeticRightShiftAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) + # ArithmeticRightShiftAttribute def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) @@ -25,6 +35,20 @@ class ArithmeticRightShiftAttribute(object): return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) return False -def ArithmeticRightShiftAttributeStart(builder): builder.StartObject(1) -def ArithmeticRightShiftAttributeAddRound(builder, round): builder.PrependBoolSlot(0, round, 0) -def ArithmeticRightShiftAttributeEnd(builder): return builder.EndObject() +def ArithmeticRightShiftAttributeStart(builder): + builder.StartObject(1) + +def Start(builder): + ArithmeticRightShiftAttributeStart(builder) + +def ArithmeticRightShiftAttributeAddRound(builder, round): + builder.PrependBoolSlot(0, round, 0) + +def AddRound(builder, round): + ArithmeticRightShiftAttributeAddRound(builder, round) + +def ArithmeticRightShiftAttributeEnd(builder): + return builder.EndObject() + +def End(builder): + return ArithmeticRightShiftAttributeEnd(builder) diff --git a/ethosu/vela/tosa/Attribute.py b/ethosu/vela/tosa/Attribute.py index b26ef48..25ade44 100644 --- a/ethosu/vela/tosa/Attribute.py +++ b/ethosu/vela/tosa/Attribute.py @@ -7,7 +7,7 @@ class Attribute(object): PoolAttribute = 1 ConvAttribute = 2 TransposeConvAttribute = 3 - ReluNAttribute = 4 + PadAttribute = 4 AxisAttribute = 5 ReshapeAttribute = 6 SliceAttribute = 7 @@ -19,4 +19,10 @@ class Attribute(object): ArithmeticRightShiftAttribute = 13 CondIfAttribute = 14 WhileLoopAttribute = 15 - + TransposeAttribute = 16 + TableAttribute = 17 + MatMulAttribute = 18 + FullyConnectedAttribute = 19 + NegateAttribute = 20 + CustomAttribute = 21 + FFTAttribute = 22 diff --git a/ethosu/vela/tosa/AxisAttribute.py b/ethosu/vela/tosa/AxisAttribute.py index 77f1bca..7ce4a63 100644 --- a/ethosu/vela/tosa/AxisAttribute.py +++ b/ethosu/vela/tosa/AxisAttribute.py @@ -3,17 +3,27 @@ # namespace: tosa import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class AxisAttribute(object): __slots__ = ['_tab'] @classmethod - def GetRootAsAxisAttribute(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = AxisAttribute() x.Init(buf, n + offset) return x + @classmethod + def GetRootAsAxisAttribute(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def AxisAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) + # AxisAttribute def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) @@ -25,6 +35,20 @@ class AxisAttribute(object): return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) return 0 -def AxisAttributeStart(builder): builder.StartObject(1) -def AxisAttributeAddAxis(builder, axis): builder.PrependInt32Slot(0, axis, 0) -def AxisAttributeEnd(builder): return builder.EndObject() +def AxisAttributeStart(builder): + builder.StartObject(1) + +def Start(builder): + AxisAttributeStart(builder) + +def AxisAttributeAddAxis(builder, axis): + builder.PrependInt32Slot(0, axis, 0) + +def AddAxis(builder, axis): + AxisAttributeAddAxis(builder, axis) + +def AxisAttributeEnd(builder): + return builder.EndObject() + +def End(builder): + return AxisAttributeEnd(builder) diff --git a/ethosu/vela/tosa/ClampAttribute.py b/ethosu/vela/tosa/ClampAttribute.py index 9cc8d4d..40e7d2e 100644 --- a/ethosu/vela/tosa/ClampAttribute.py +++ b/ethosu/vela/tosa/ClampAttribute.py @@ -3,17 +3,27 @@ # namespace: tosa import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class ClampAttribute(object): __slots__ = ['_tab'] @classmethod - def GetRootAsClampAttribute(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = ClampAttribute() x.Init(buf, n + offset) return x + @classmethod + def GetRootAsClampAttribute(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def ClampAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) + # ClampAttribute def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) @@ -33,22 +43,103 @@ class ClampAttribute(object): return 0 # ClampAttribute - def MinFp(self): + def MinFp(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)) + return 0 + + # ClampAttribute + def MinFpAsNumpy(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos) - return 0.0 + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o) + return 0 + + # ClampAttribute + def MinFpLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # ClampAttribute + def MinFpIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + return o == 0 + + # ClampAttribute + def MaxFp(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)) + return 0 + + # ClampAttribute + def MaxFpAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o) + return 0 # ClampAttribute - def MaxFp(self): + def MaxFpLength(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) if o != 0: - return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos) - return 0.0 + return self._tab.VectorLen(o) + return 0 + + # ClampAttribute + def MaxFpIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + return o == 0 + +def ClampAttributeStart(builder): + builder.StartObject(4) + +def Start(builder): + ClampAttributeStart(builder) + +def ClampAttributeAddMinInt(builder, minInt): + builder.PrependInt32Slot(0, minInt, 0) + +def AddMinInt(builder, minInt): + ClampAttributeAddMinInt(builder, minInt) + +def ClampAttributeAddMaxInt(builder, maxInt): + builder.PrependInt32Slot(1, maxInt, 0) + +def AddMaxInt(builder, maxInt): + ClampAttributeAddMaxInt(builder, maxInt) + +def ClampAttributeAddMinFp(builder, minFp): + builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(minFp), 0) + +def AddMinFp(builder, minFp): + ClampAttributeAddMinFp(builder, minFp) + +def ClampAttributeStartMinFpVector(builder, numElems): + return builder.StartVector(1, numElems, 1) + +def StartMinFpVector(builder, numElems: int) -> int: + return ClampAttributeStartMinFpVector(builder, numElems) + +def ClampAttributeAddMaxFp(builder, maxFp): + builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(maxFp), 0) + +def AddMaxFp(builder, maxFp): + ClampAttributeAddMaxFp(builder, maxFp) + +def ClampAttributeStartMaxFpVector(builder, numElems): + return builder.StartVector(1, numElems, 1) + +def StartMaxFpVector(builder, numElems: int) -> int: + return ClampAttributeStartMaxFpVector(builder, numElems) + +def ClampAttributeEnd(builder): + return builder.EndObject() -def ClampAttributeStart(builder): builder.StartObject(4) -def ClampAttributeAddMinInt(builder, minInt): builder.PrependInt32Slot(0, minInt, 0) -def ClampAttributeAddMaxInt(builder, maxInt): builder.PrependInt32Slot(1, maxInt, 0) -def ClampAttributeAddMinFp(builder, minFp): builder.PrependFloat32Slot(2, minFp, 0.0) -def ClampAttributeAddMaxFp(builder, maxFp): builder.PrependFloat32Slot(3, maxFp, 0.0) -def ClampAttributeEnd(builder): return builder.EndObject() +def End(builder): + return ClampAttributeEnd(builder) diff --git a/ethosu/vela/tosa/CondIfAttribute.py b/ethosu/vela/tosa/CondIfAttribute.py index bc19b95..cdecec6 100644 --- a/ethosu/vela/tosa/CondIfAttribute.py +++ b/ethosu/vela/tosa/CondIfAttribute.py @@ -3,17 +3,27 @@ # namespace: tosa import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class CondIfAttribute(object): __slots__ = ['_tab'] @classmethod - def GetRootAsCondIfAttribute(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = CondIfAttribute() x.Init(buf, n + offset) return x + @classmethod + def GetRootAsCondIfAttribute(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def CondIfAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) + # CondIfAttribute def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) @@ -32,7 +42,26 @@ class CondIfAttribute(object): return self._tab.String(o + self._tab.Pos) return None -def CondIfAttributeStart(builder): builder.StartObject(2) -def CondIfAttributeAddThenBranch(builder, thenBranch): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(thenBranch), 0) -def CondIfAttributeAddElseBranch(builder, elseBranch): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(elseBranch), 0) -def CondIfAttributeEnd(builder): return builder.EndObject() +def CondIfAttributeStart(builder): + builder.StartObject(2) + +def Start(builder): + CondIfAttributeStart(builder) + +def CondIfAttributeAddThenBranch(builder, thenBranch): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(thenBranch), 0) + +def AddThenBranch(builder, thenBranch): + CondIfAttributeAddThenBranch(builder, thenBranch) + +def CondIfAttributeAddElseBranch(builder, elseBranch): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(elseBranch), 0) + +def AddElseBranch(builder, elseBranch): + CondIfAttributeAddElseBranch(builder, elseBranch) + +def CondIfAttributeEnd(builder): + return builder.EndObject() + +def End(builder): + return CondIfAttributeEnd(builder) diff --git a/ethosu/vela/tosa/ConvAttribute.py b/ethosu/vela/tosa/ConvAttribute.py index d67ae5f..6db82d7 100644 --- a/ethosu/vela/tosa/ConvAttribute.py +++ b/ethosu/vela/tosa/ConvAttribute.py @@ -3,23 +3,33 @@ # namespace: tosa import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class ConvAttribute(object): __slots__ = ['_tab'] @classmethod - def GetRootAsConvAttribute(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = ConvAttribute() x.Init(buf, n + offset) return x + @classmethod + def GetRootAsConvAttribute(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def ConvAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) + # ConvAttribute def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) # ConvAttribute - def Padding(self, j): + def Pad(self, j): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: a = self._tab.Vector(o) @@ -27,20 +37,25 @@ class ConvAttribute(object): return 0 # ConvAttribute - def PaddingAsNumpy(self): + def PadAsNumpy(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) return 0 # ConvAttribute - def PaddingLength(self): + def PadLength(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: return self._tab.VectorLen(o) return 0 # ConvAttribute + def PadIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + + # ConvAttribute def Stride(self, j): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) if o != 0: @@ -63,6 +78,11 @@ class ConvAttribute(object): return 0 # ConvAttribute + def StrideIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + return o == 0 + + # ConvAttribute def Dilation(self, j): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) if o != 0: @@ -84,11 +104,81 @@ class ConvAttribute(object): return self._tab.VectorLen(o) return 0 -def ConvAttributeStart(builder): builder.StartObject(3) -def ConvAttributeAddPadding(builder, padding): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(padding), 0) -def ConvAttributeStartPaddingVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def ConvAttributeAddStride(builder, stride): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(stride), 0) -def ConvAttributeStartStrideVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def ConvAttributeAddDilation(builder, dilation): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(dilation), 0) -def ConvAttributeStartDilationVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def ConvAttributeEnd(builder): return builder.EndObject() + # ConvAttribute + def DilationIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + return o == 0 + + # ConvAttribute + def InputZp(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + + # ConvAttribute + def WeightZp(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + +def ConvAttributeStart(builder): + builder.StartObject(5) + +def Start(builder): + ConvAttributeStart(builder) + +def ConvAttributeAddPad(builder, pad): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pad), 0) + +def AddPad(builder, pad): + ConvAttributeAddPad(builder, pad) + +def ConvAttributeStartPadVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StartPadVector(builder, numElems: int) -> int: + return ConvAttributeStartPadVector(builder, numElems) + +def ConvAttributeAddStride(builder, stride): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(stride), 0) + +def AddStride(builder, stride): + ConvAttributeAddStride(builder, stride) + +def ConvAttributeStartStrideVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StartStrideVector(builder, numElems: int) -> int: + return ConvAttributeStartStrideVector(builder, numElems) + +def ConvAttributeAddDilation(builder, dilation): + builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(dilation), 0) + +def AddDilation(builder, dilation): + ConvAttributeAddDilation(builder, dilation) + +def ConvAttributeStartDilationVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StartDilationVector(builder, numElems: int) -> int: + return ConvAttributeStartDilationVector(builder, numElems) + +def ConvAttributeAddInputZp(builder, inputZp): + builder.PrependInt32Slot(3, inputZp, 0) + +def AddInputZp(builder, inputZp): + ConvAttributeAddInputZp(builder, inputZp) + +def ConvAttributeAddWeightZp(builder, weightZp): + builder.PrependInt32Slot(4, weightZp, 0) + +def AddWeightZp(builder, weightZp): + ConvAttributeAddWeightZp(builder, weightZp) + +def ConvAttributeEnd(builder): + return builder.EndObject() + +def End(builder): + return ConvAttributeEnd(builder) diff --git a/ethosu/vela/tosa/ConvQuantInfo.py b/ethosu/vela/tosa/ConvQuantInfo.py deleted file mode 100644 index 9f785b3..0000000 --- a/ethosu/vela/tosa/ConvQuantInfo.py +++ /dev/null @@ -1,38 +0,0 @@ -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tosa - -import flatbuffers - -class ConvQuantInfo(object): - __slots__ = ['_tab'] - - @classmethod - def GetRootAsConvQuantInfo(cls, buf, offset): - n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = ConvQuantInfo() - x.Init(buf, n + offset) - return x - - # ConvQuantInfo - def Init(self, buf, pos): - self._tab = flatbuffers.table.Table(buf, pos) - - # ConvQuantInfo - def InputZp(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 - - # ConvQuantInfo - def WeightZp(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 ConvQuantInfoStart(builder): builder.StartObject(2) -def ConvQuantInfoAddInputZp(builder, inputZp): builder.PrependInt32Slot(0, inputZp, 0) -def ConvQuantInfoAddWeightZp(builder, weightZp): builder.PrependInt32Slot(1, weightZp, 0) -def ConvQuantInfoEnd(builder): return builder.EndObject() diff --git a/ethosu/vela/tosa/CustomAttribute.py b/ethosu/vela/tosa/CustomAttribute.py new file mode 100644 index 0000000..de81970 --- /dev/null +++ b/ethosu/vela/tosa/CustomAttribute.py @@ -0,0 +1,106 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tosa + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class CustomAttribute(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = CustomAttribute() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsCustomAttribute(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def CustomAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) + + # CustomAttribute + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # CustomAttribute + def Identifier(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 + + # CustomAttribute + def Config(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 + + # CustomAttribute + def ImplementationAttrs(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)) + return 0 + + # CustomAttribute + def ImplementationAttrsAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o) + return 0 + + # CustomAttribute + def ImplementationAttrsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # CustomAttribute + def ImplementationAttrsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + return o == 0 + +def CustomAttributeStart(builder): + builder.StartObject(3) + +def Start(builder): + CustomAttributeStart(builder) + +def CustomAttributeAddIdentifier(builder, identifier): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(identifier), 0) + +def AddIdentifier(builder, identifier): + CustomAttributeAddIdentifier(builder, identifier) + +def CustomAttributeAddConfig(builder, config): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(config), 0) + +def AddConfig(builder, config): + CustomAttributeAddConfig(builder, config) + +def CustomAttributeAddImplementationAttrs(builder, implementationAttrs): + builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(implementationAttrs), 0) + +def AddImplementationAttrs(builder, implementationAttrs): + CustomAttributeAddImplementationAttrs(builder, implementationAttrs) + +def CustomAttributeStartImplementationAttrsVector(builder, numElems): + return builder.StartVector(1, numElems, 1) + +def StartImplementationAttrsVector(builder, numElems: int) -> int: + return CustomAttributeStartImplementationAttrsVector(builder, numElems) + +def CustomAttributeEnd(builder): + return builder.EndObject() + +def End(builder): + return CustomAttributeEnd(builder) diff --git a/ethosu/vela/tosa/DType.py b/ethosu/vela/tosa/DType.py index 65432db..6df2dcb 100644 --- a/ethosu/vela/tosa/DType.py +++ b/ethosu/vela/tosa/DType.py @@ -11,5 +11,8 @@ class DType(object): INT16 = 5 INT32 = 6 INT48 = 7 - FLOAT = 8 - + FP32 = 8 + UINT16 = 9 + FP16 = 10 + BF16 = 11 + SHAPE = 12 diff --git a/ethosu/vela/tosa/FFTAttribute.py b/ethosu/vela/tosa/FFTAttribute.py new file mode 100644 index 0000000..0f22aa7 --- /dev/null +++ b/ethosu/vela/tosa/FFTAttribute.py @@ -0,0 +1,54 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tosa + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class FFTAttribute(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = FFTAttribute() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsFFTAttribute(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def FFTAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) + + # FFTAttribute + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # FFTAttribute + def Inverse(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False + +def FFTAttributeStart(builder): + builder.StartObject(1) + +def Start(builder): + FFTAttributeStart(builder) + +def FFTAttributeAddInverse(builder, inverse): + builder.PrependBoolSlot(0, inverse, 0) + +def AddInverse(builder, inverse): + FFTAttributeAddInverse(builder, inverse) + +def FFTAttributeEnd(builder): + return builder.EndObject() + +def End(builder): + return FFTAttributeEnd(builder) diff --git a/ethosu/vela/tosa/FullyConnectedAttribute.py b/ethosu/vela/tosa/FullyConnectedAttribute.py new file mode 100644 index 0000000..8854503 --- /dev/null +++ b/ethosu/vela/tosa/FullyConnectedAttribute.py @@ -0,0 +1,67 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tosa + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class FullyConnectedAttribute(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = FullyConnectedAttribute() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsFullyConnectedAttribute(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def FullyConnectedAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) + + # FullyConnectedAttribute + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # FullyConnectedAttribute + def InputZp(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 + + # FullyConnectedAttribute + def WeightZp(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 FullyConnectedAttributeStart(builder): + builder.StartObject(2) + +def Start(builder): + FullyConnectedAttributeStart(builder) + +def FullyConnectedAttributeAddInputZp(builder, inputZp): + builder.PrependInt32Slot(0, inputZp, 0) + +def AddInputZp(builder, inputZp): + FullyConnectedAttributeAddInputZp(builder, inputZp) + +def FullyConnectedAttributeAddWeightZp(builder, weightZp): + builder.PrependInt32Slot(1, weightZp, 0) + +def AddWeightZp(builder, weightZp): + FullyConnectedAttributeAddWeightZp(builder, weightZp) + +def FullyConnectedAttributeEnd(builder): + return builder.EndObject() + +def End(builder): + return FullyConnectedAttributeEnd(builder) diff --git a/ethosu/vela/tosa/MatMulAttribute.py b/ethosu/vela/tosa/MatMulAttribute.py new file mode 100644 index 0000000..325428a --- /dev/null +++ b/ethosu/vela/tosa/MatMulAttribute.py @@ -0,0 +1,67 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tosa + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class MatMulAttribute(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = MatMulAttribute() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsMatMulAttribute(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def MatMulAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) + + # MatMulAttribute + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # MatMulAttribute + def AZp(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 + + # MatMulAttribute + def BZp(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 MatMulAttributeStart(builder): + builder.StartObject(2) + +def Start(builder): + MatMulAttributeStart(builder) + +def MatMulAttributeAddAZp(builder, aZp): + builder.PrependInt32Slot(0, aZp, 0) + +def AddAZp(builder, aZp): + MatMulAttributeAddAZp(builder, aZp) + +def MatMulAttributeAddBZp(builder, bZp): + builder.PrependInt32Slot(1, bZp, 0) + +def AddBZp(builder, bZp): + MatMulAttributeAddBZp(builder, bZp) + +def MatMulAttributeEnd(builder): + return builder.EndObject() + +def End(builder): + return MatMulAttributeEnd(builder) diff --git a/ethosu/vela/tosa/MatMulQuantInfo.py b/ethosu/vela/tosa/MatMulQuantInfo.py deleted file mode 100644 index 6cc3a72..0000000 --- a/ethosu/vela/tosa/MatMulQuantInfo.py +++ /dev/null @@ -1,38 +0,0 @@ -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tosa - -import flatbuffers - -class MatMulQuantInfo(object): - __slots__ = ['_tab'] - - @classmethod - def GetRootAsMatMulQuantInfo(cls, buf, offset): - n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = MatMulQuantInfo() - x.Init(buf, n + offset) - return x - - # MatMulQuantInfo - def Init(self, buf, pos): - self._tab = flatbuffers.table.Table(buf, pos) - - # MatMulQuantInfo - def AZp(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 - - # MatMulQuantInfo - def BZp(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 MatMulQuantInfoStart(builder): builder.StartObject(2) -def MatMulQuantInfoAddAZp(builder, aZp): builder.PrependInt32Slot(0, aZp, 0) -def MatMulQuantInfoAddBZp(builder, bZp): builder.PrependInt32Slot(1, bZp, 0) -def MatMulQuantInfoEnd(builder): return builder.EndObject() diff --git a/ethosu/vela/tosa/MulAttribute.py b/ethosu/vela/tosa/MulAttribute.py index c08f684..236d3f5 100644 --- a/ethosu/vela/tosa/MulAttribute.py +++ b/ethosu/vela/tosa/MulAttribute.py @@ -3,17 +3,27 @@ # namespace: tosa import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class MulAttribute(object): __slots__ = ['_tab'] @classmethod - def GetRootAsMulAttribute(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = MulAttribute() x.Init(buf, n + offset) return x + @classmethod + def GetRootAsMulAttribute(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def MulAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) + # MulAttribute def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) @@ -25,6 +35,20 @@ class MulAttribute(object): return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) return 0 -def MulAttributeStart(builder): builder.StartObject(1) -def MulAttributeAddShift(builder, shift): builder.PrependInt32Slot(0, shift, 0) -def MulAttributeEnd(builder): return builder.EndObject() +def MulAttributeStart(builder): + builder.StartObject(1) + +def Start(builder): + MulAttributeStart(builder) + +def MulAttributeAddShift(builder, shift): + builder.PrependInt32Slot(0, shift, 0) + +def AddShift(builder, shift): + MulAttributeAddShift(builder, shift) + +def MulAttributeEnd(builder): + return builder.EndObject() + +def End(builder): + return MulAttributeEnd(builder) diff --git a/ethosu/vela/tosa/NegateAttribute.py b/ethosu/vela/tosa/NegateAttribute.py new file mode 100644 index 0000000..eae46f5 --- /dev/null +++ b/ethosu/vela/tosa/NegateAttribute.py @@ -0,0 +1,67 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tosa + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class NegateAttribute(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = NegateAttribute() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsNegateAttribute(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def NegateAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) + + # NegateAttribute + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # NegateAttribute + def Input1Zp(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 + + # NegateAttribute + def OutputZp(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 NegateAttributeStart(builder): + builder.StartObject(2) + +def Start(builder): + NegateAttributeStart(builder) + +def NegateAttributeAddInput1Zp(builder, input1Zp): + builder.PrependInt32Slot(0, input1Zp, 0) + +def AddInput1Zp(builder, input1Zp): + NegateAttributeAddInput1Zp(builder, input1Zp) + +def NegateAttributeAddOutputZp(builder, outputZp): + builder.PrependInt32Slot(1, outputZp, 0) + +def AddOutputZp(builder, outputZp): + NegateAttributeAddOutputZp(builder, outputZp) + +def NegateAttributeEnd(builder): + return builder.EndObject() + +def End(builder): + return NegateAttributeEnd(builder) diff --git a/ethosu/vela/tosa/Op.py b/ethosu/vela/tosa/Op.py index 8b4af89..d628479 100644 --- a/ethosu/vela/tosa/Op.py +++ b/ethosu/vela/tosa/Op.py @@ -14,7 +14,7 @@ class Op(object): MAX_POOL2D = 8 TRANSPOSE_CONV2D = 9 CLAMP = 10 - RELUN = 11 + RESERVED = 11 SIGMOID = 12 TANH = 13 ADD = 14 @@ -72,4 +72,7 @@ class Op(object): CUSTOM = 66 COND_IF = 67 WHILE_LOOP = 68 - + FFT2D = 69 + RFFT2D = 70 + ERF = 71 + DIM = 72 diff --git a/ethosu/vela/tosa/PadAttribute.py b/ethosu/vela/tosa/PadAttribute.py new file mode 100644 index 0000000..fc843bb --- /dev/null +++ b/ethosu/vela/tosa/PadAttribute.py @@ -0,0 +1,132 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tosa + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class PadAttribute(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = PadAttribute() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsPadAttribute(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def PadAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) + + # PadAttribute + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # PadAttribute + def Padding(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return 0 + + # PadAttribute + def PaddingAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return 0 + + # PadAttribute + def PaddingLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # PadAttribute + def PaddingIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + + # PadAttribute + def PadConstInt(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 + + # PadAttribute + def PadConstFp(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)) + return 0 + + # PadAttribute + def PadConstFpAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o) + return 0 + + # PadAttribute + def PadConstFpLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # PadAttribute + def PadConstFpIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + return o == 0 + +def PadAttributeStart(builder): + builder.StartObject(3) + +def Start(builder): + PadAttributeStart(builder) + +def PadAttributeAddPadding(builder, padding): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(padding), 0) + +def AddPadding(builder, padding): + PadAttributeAddPadding(builder, padding) + +def PadAttributeStartPaddingVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StartPaddingVector(builder, numElems: int) -> int: + return PadAttributeStartPaddingVector(builder, numElems) + +def PadAttributeAddPadConstInt(builder, padConstInt): + builder.PrependInt32Slot(1, padConstInt, 0) + +def AddPadConstInt(builder, padConstInt): + PadAttributeAddPadConstInt(builder, padConstInt) + +def PadAttributeAddPadConstFp(builder, padConstFp): + builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(padConstFp), 0) + +def AddPadConstFp(builder, padConstFp): + PadAttributeAddPadConstFp(builder, padConstFp) + +def PadAttributeStartPadConstFpVector(builder, numElems): + return builder.StartVector(1, numElems, 1) + +def StartPadConstFpVector(builder, numElems: int) -> int: + return PadAttributeStartPadConstFpVector(builder, numElems) + +def PadAttributeEnd(builder): + return builder.EndObject() + +def End(builder): + return PadAttributeEnd(builder) diff --git a/ethosu/vela/tosa/PadQuantInfo.py b/ethosu/vela/tosa/PadQuantInfo.py deleted file mode 100644 index 825b72c..0000000 --- a/ethosu/vela/tosa/PadQuantInfo.py +++ /dev/null @@ -1,30 +0,0 @@ -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tosa - -import flatbuffers - -class PadQuantInfo(object): - __slots__ = ['_tab'] - - @classmethod - def GetRootAsPadQuantInfo(cls, buf, offset): - n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = PadQuantInfo() - x.Init(buf, n + offset) - return x - - # PadQuantInfo - def Init(self, buf, pos): - self._tab = flatbuffers.table.Table(buf, pos) - - # PadQuantInfo - def InputZp(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 - -def PadQuantInfoStart(builder): builder.StartObject(1) -def PadQuantInfoAddInputZp(builder, inputZp): builder.PrependInt32Slot(0, inputZp, 0) -def PadQuantInfoEnd(builder): return builder.EndObject() diff --git a/ethosu/vela/tosa/PoolAttribute.py b/ethosu/vela/tosa/PoolAttribute.py index f6d17ec..ea31544 100644 --- a/ethosu/vela/tosa/PoolAttribute.py +++ b/ethosu/vela/tosa/PoolAttribute.py @@ -3,23 +3,33 @@ # namespace: tosa import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class PoolAttribute(object): __slots__ = ['_tab'] @classmethod - def GetRootAsPoolAttribute(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = PoolAttribute() x.Init(buf, n + offset) return x + @classmethod + def GetRootAsPoolAttribute(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def PoolAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) + # PoolAttribute def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) # PoolAttribute - def Padding(self, j): + def Pad(self, j): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: a = self._tab.Vector(o) @@ -27,20 +37,25 @@ class PoolAttribute(object): return 0 # PoolAttribute - def PaddingAsNumpy(self): + def PadAsNumpy(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) return 0 # PoolAttribute - def PaddingLength(self): + def PadLength(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: return self._tab.VectorLen(o) return 0 # PoolAttribute + def PadIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + + # PoolAttribute def Kernel(self, j): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) if o != 0: @@ -63,6 +78,11 @@ class PoolAttribute(object): return 0 # PoolAttribute + def KernelIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + return o == 0 + + # PoolAttribute def Stride(self, j): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) if o != 0: @@ -84,11 +104,94 @@ class PoolAttribute(object): return self._tab.VectorLen(o) return 0 -def PoolAttributeStart(builder): builder.StartObject(3) -def PoolAttributeAddPadding(builder, padding): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(padding), 0) -def PoolAttributeStartPaddingVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def PoolAttributeAddKernel(builder, kernel): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(kernel), 0) -def PoolAttributeStartKernelVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def PoolAttributeAddStride(builder, stride): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(stride), 0) -def PoolAttributeStartStrideVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def PoolAttributeEnd(builder): return builder.EndObject() + # PoolAttribute + def StrideIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + return o == 0 + + # PoolAttribute + def InputZp(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + + # PoolAttribute + def OutputZp(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + + # PoolAttribute + def AccumDtype(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) + return 0 + +def PoolAttributeStart(builder): + builder.StartObject(6) + +def Start(builder): + PoolAttributeStart(builder) + +def PoolAttributeAddPad(builder, pad): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pad), 0) + +def AddPad(builder, pad): + PoolAttributeAddPad(builder, pad) + +def PoolAttributeStartPadVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StartPadVector(builder, numElems: int) -> int: + return PoolAttributeStartPadVector(builder, numElems) + +def PoolAttributeAddKernel(builder, kernel): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(kernel), 0) + +def AddKernel(builder, kernel): + PoolAttributeAddKernel(builder, kernel) + +def PoolAttributeStartKernelVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StartKernelVector(builder, numElems: int) -> int: + return PoolAttributeStartKernelVector(builder, numElems) + +def PoolAttributeAddStride(builder, stride): + builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(stride), 0) + +def AddStride(builder, stride): + PoolAttributeAddStride(builder, stride) + +def PoolAttributeStartStrideVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StartStrideVector(builder, numElems: int) -> int: + return PoolAttributeStartStrideVector(builder, numElems) + +def PoolAttributeAddInputZp(builder, inputZp): + builder.PrependInt32Slot(3, inputZp, 0) + +def AddInputZp(builder, inputZp): + PoolAttributeAddInputZp(builder, inputZp) + +def PoolAttributeAddOutputZp(builder, outputZp): + builder.PrependInt32Slot(4, outputZp, 0) + +def AddOutputZp(builder, outputZp): + PoolAttributeAddOutputZp(builder, outputZp) + +def PoolAttributeAddAccumDtype(builder, accumDtype): + builder.PrependUint32Slot(5, accumDtype, 0) + +def AddAccumDtype(builder, accumDtype): + PoolAttributeAddAccumDtype(builder, accumDtype) + +def PoolAttributeEnd(builder): + return builder.EndObject() + +def End(builder): + return PoolAttributeEnd(builder) diff --git a/ethosu/vela/tosa/QuantInfo.py b/ethosu/vela/tosa/QuantInfo.py deleted file mode 100644 index ffdfd32..0000000 --- a/ethosu/vela/tosa/QuantInfo.py +++ /dev/null @@ -1,11 +0,0 @@ -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tosa - -class QuantInfo(object): - NONE = 0 - UnaryQuantInfo = 1 - ConvQuantInfo = 2 - MatMulQuantInfo = 3 - PadQuantInfo = 4 - diff --git a/ethosu/vela/tosa/ReluNAttribute.py b/ethosu/vela/tosa/ReluNAttribute.py deleted file mode 100644 index 008b535..0000000 --- a/ethosu/vela/tosa/ReluNAttribute.py +++ /dev/null @@ -1,38 +0,0 @@ -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tosa - -import flatbuffers - -class ReluNAttribute(object): - __slots__ = ['_tab'] - - @classmethod - def GetRootAsReluNAttribute(cls, buf, offset): - n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = ReluNAttribute() - x.Init(buf, n + offset) - return x - - # ReluNAttribute - def Init(self, buf, pos): - self._tab = flatbuffers.table.Table(buf, pos) - - # ReluNAttribute - def MaxInt(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 - - # ReluNAttribute - def MaxFp(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos) - return 0.0 - -def ReluNAttributeStart(builder): builder.StartObject(2) -def ReluNAttributeAddMaxInt(builder, maxInt): builder.PrependInt32Slot(0, maxInt, 0) -def ReluNAttributeAddMaxFp(builder, maxFp): builder.PrependFloat32Slot(1, maxFp, 0.0) -def ReluNAttributeEnd(builder): return builder.EndObject() diff --git a/ethosu/vela/tosa/RescaleAttribute.py b/ethosu/vela/tosa/RescaleAttribute.py index 1aa6707..beec2e7 100644 --- a/ethosu/vela/tosa/RescaleAttribute.py +++ b/ethosu/vela/tosa/RescaleAttribute.py @@ -3,17 +3,27 @@ # namespace: tosa import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class RescaleAttribute(object): __slots__ = ['_tab'] @classmethod - def GetRootAsRescaleAttribute(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = RescaleAttribute() x.Init(buf, n + offset) return x + @classmethod + def GetRootAsRescaleAttribute(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def RescaleAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) + # RescaleAttribute def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) @@ -55,6 +65,11 @@ class RescaleAttribute(object): return 0 # RescaleAttribute + def MultiplierIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + return o == 0 + + # RescaleAttribute def Shift(self, j): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) if o != 0: @@ -77,6 +92,11 @@ class RescaleAttribute(object): return 0 # RescaleAttribute + def ShiftIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + return o == 0 + + # RescaleAttribute def Scale32(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) if o != 0: @@ -97,14 +117,68 @@ class RescaleAttribute(object): return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) return False -def RescaleAttributeStart(builder): builder.StartObject(7) -def RescaleAttributeAddInputZp(builder, inputZp): builder.PrependInt32Slot(0, inputZp, 0) -def RescaleAttributeAddOutputZp(builder, outputZp): builder.PrependInt32Slot(1, outputZp, 0) -def RescaleAttributeAddMultiplier(builder, multiplier): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(multiplier), 0) -def RescaleAttributeStartMultiplierVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def RescaleAttributeAddShift(builder, shift): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(shift), 0) -def RescaleAttributeStartShiftVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def RescaleAttributeAddScale32(builder, scale32): builder.PrependBoolSlot(4, scale32, 0) -def RescaleAttributeAddDoubleRound(builder, doubleRound): builder.PrependBoolSlot(5, doubleRound, 0) -def RescaleAttributeAddPerChannel(builder, perChannel): builder.PrependBoolSlot(6, perChannel, 0) -def RescaleAttributeEnd(builder): return builder.EndObject() +def RescaleAttributeStart(builder): + builder.StartObject(7) + +def Start(builder): + RescaleAttributeStart(builder) + +def RescaleAttributeAddInputZp(builder, inputZp): + builder.PrependInt32Slot(0, inputZp, 0) + +def AddInputZp(builder, inputZp): + RescaleAttributeAddInputZp(builder, inputZp) + +def RescaleAttributeAddOutputZp(builder, outputZp): + builder.PrependInt32Slot(1, outputZp, 0) + +def AddOutputZp(builder, outputZp): + RescaleAttributeAddOutputZp(builder, outputZp) + +def RescaleAttributeAddMultiplier(builder, multiplier): + builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(multiplier), 0) + +def AddMultiplier(builder, multiplier): + RescaleAttributeAddMultiplier(builder, multiplier) + +def RescaleAttributeStartMultiplierVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StartMultiplierVector(builder, numElems: int) -> int: + return RescaleAttributeStartMultiplierVector(builder, numElems) + +def RescaleAttributeAddShift(builder, shift): + builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(shift), 0) + +def AddShift(builder, shift): + RescaleAttributeAddShift(builder, shift) + +def RescaleAttributeStartShiftVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StartShiftVector(builder, numElems: int) -> int: + return RescaleAttributeStartShiftVector(builder, numElems) + +def RescaleAttributeAddScale32(builder, scale32): + builder.PrependBoolSlot(4, scale32, 0) + +def AddScale32(builder, scale32): + RescaleAttributeAddScale32(builder, scale32) + +def RescaleAttributeAddDoubleRound(builder, doubleRound): + builder.PrependBoolSlot(5, doubleRound, 0) + +def AddDoubleRound(builder, doubleRound): + RescaleAttributeAddDoubleRound(builder, doubleRound) + +def RescaleAttributeAddPerChannel(builder, perChannel): + builder.PrependBoolSlot(6, perChannel, 0) + +def AddPerChannel(builder, perChannel): + RescaleAttributeAddPerChannel(builder, perChannel) + +def RescaleAttributeEnd(builder): + return builder.EndObject() + +def End(builder): + return RescaleAttributeEnd(builder) diff --git a/ethosu/vela/tosa/ReshapeAttribute.py b/ethosu/vela/tosa/ReshapeAttribute.py index 629b6c2..7df6546 100644 --- a/ethosu/vela/tosa/ReshapeAttribute.py +++ b/ethosu/vela/tosa/ReshapeAttribute.py @@ -3,23 +3,33 @@ # namespace: tosa import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class ReshapeAttribute(object): __slots__ = ['_tab'] @classmethod - def GetRootAsReshapeAttribute(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = ReshapeAttribute() x.Init(buf, n + offset) return x + @classmethod + def GetRootAsReshapeAttribute(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def ReshapeAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) + # ReshapeAttribute def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) # ReshapeAttribute - def Shape(self, j): + def NewShape(self, j): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: a = self._tab.Vector(o) @@ -27,20 +37,44 @@ class ReshapeAttribute(object): return 0 # ReshapeAttribute - def ShapeAsNumpy(self): + def NewShapeAsNumpy(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) return 0 # ReshapeAttribute - def ShapeLength(self): + def NewShapeLength(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: return self._tab.VectorLen(o) return 0 -def ReshapeAttributeStart(builder): builder.StartObject(1) -def ReshapeAttributeAddShape(builder, shape): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(shape), 0) -def ReshapeAttributeStartShapeVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def ReshapeAttributeEnd(builder): return builder.EndObject() + # ReshapeAttribute + def NewShapeIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + +def ReshapeAttributeStart(builder): + builder.StartObject(1) + +def Start(builder): + ReshapeAttributeStart(builder) + +def ReshapeAttributeAddNewShape(builder, newShape): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(newShape), 0) + +def AddNewShape(builder, newShape): + ReshapeAttributeAddNewShape(builder, newShape) + +def ReshapeAttributeStartNewShapeVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StartNewShapeVector(builder, numElems: int) -> int: + return ReshapeAttributeStartNewShapeVector(builder, numElems) + +def ReshapeAttributeEnd(builder): + return builder.EndObject() + +def End(builder): + return ReshapeAttributeEnd(builder) diff --git a/ethosu/vela/tosa/ResizeAttribute.py b/ethosu/vela/tosa/ResizeAttribute.py index 89156d1..96bfa56 100644 --- a/ethosu/vela/tosa/ResizeAttribute.py +++ b/ethosu/vela/tosa/ResizeAttribute.py @@ -3,156 +3,169 @@ # namespace: tosa import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class ResizeAttribute(object): __slots__ = ['_tab'] @classmethod - def GetRootAsResizeAttribute(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = ResizeAttribute() x.Init(buf, n + offset) return x + @classmethod + def GetRootAsResizeAttribute(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def ResizeAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) + # ResizeAttribute def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) # ResizeAttribute - def OutputSize(self, j): + def Scale(self, j): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return self._tab.Get(flatbuffers.number_types.Int16Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 2)) return 0 # ResizeAttribute - def OutputSizeAsNumpy(self): + def ScaleAsNumpy(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int16Flags, o) return 0 # ResizeAttribute - def OutputSizeLength(self): + def ScaleLength(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: return self._tab.VectorLen(o) return 0 # ResizeAttribute - def Stride(self, j): + def ScaleIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + + # ResizeAttribute + def Offset(self, j): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) if o != 0: a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return self._tab.Get(flatbuffers.number_types.Int16Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 2)) return 0 # ResizeAttribute - def StrideAsNumpy(self): + def OffsetAsNumpy(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int16Flags, o) return 0 # ResizeAttribute - def StrideLength(self): + def OffsetLength(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) if o != 0: return self._tab.VectorLen(o) return 0 # ResizeAttribute - def Offset(self, j): + def OffsetIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + return o == 0 + + # ResizeAttribute + def Border(self, j): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) if o != 0: a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return self._tab.Get(flatbuffers.number_types.Int16Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 2)) return 0 # ResizeAttribute - def OffsetAsNumpy(self): + def BorderAsNumpy(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int16Flags, o) return 0 # ResizeAttribute - def OffsetLength(self): + def BorderLength(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) if o != 0: return self._tab.VectorLen(o) return 0 # ResizeAttribute - def Shift(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) - return 0 + def BorderIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + return o == 0 # ResizeAttribute - def StrideFp(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + def Mode(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Float32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) return 0 - # ResizeAttribute - def StrideFpAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float32Flags, o) - return 0 +def ResizeAttributeStart(builder): + builder.StartObject(4) - # ResizeAttribute - def StrideFpLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) - if o != 0: - return self._tab.VectorLen(o) - return 0 +def Start(builder): + ResizeAttributeStart(builder) - # ResizeAttribute - def OffsetFp(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Float32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) - return 0 +def ResizeAttributeAddScale(builder, scale): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(scale), 0) - # ResizeAttribute - def OffsetFpAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float32Flags, o) - return 0 +def AddScale(builder, scale): + ResizeAttributeAddScale(builder, scale) - # ResizeAttribute - def OffsetFpLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) - if o != 0: - return self._tab.VectorLen(o) - return 0 +def ResizeAttributeStartScaleVector(builder, numElems): + return builder.StartVector(2, numElems, 2) - # ResizeAttribute - def Mode(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) - return 0 +def StartScaleVector(builder, numElems: int) -> int: + return ResizeAttributeStartScaleVector(builder, numElems) + +def ResizeAttributeAddOffset(builder, offset): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(offset), 0) + +def AddOffset(builder, offset): + ResizeAttributeAddOffset(builder, offset) + +def ResizeAttributeStartOffsetVector(builder, numElems): + return builder.StartVector(2, numElems, 2) + +def StartOffsetVector(builder, numElems: int) -> int: + return ResizeAttributeStartOffsetVector(builder, numElems) + +def ResizeAttributeAddBorder(builder, border): + builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(border), 0) + +def AddBorder(builder, border): + ResizeAttributeAddBorder(builder, border) + +def ResizeAttributeStartBorderVector(builder, numElems): + return builder.StartVector(2, numElems, 2) + +def StartBorderVector(builder, numElems: int) -> int: + return ResizeAttributeStartBorderVector(builder, numElems) + +def ResizeAttributeAddMode(builder, mode): + builder.PrependUint32Slot(3, mode, 0) + +def AddMode(builder, mode): + ResizeAttributeAddMode(builder, mode) + +def ResizeAttributeEnd(builder): + return builder.EndObject() -def ResizeAttributeStart(builder): builder.StartObject(7) -def ResizeAttributeAddOutputSize(builder, outputSize): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(outputSize), 0) -def ResizeAttributeStartOutputSizeVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def ResizeAttributeAddStride(builder, stride): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(stride), 0) -def ResizeAttributeStartStrideVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def ResizeAttributeAddOffset(builder, offset): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(offset), 0) -def ResizeAttributeStartOffsetVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def ResizeAttributeAddShift(builder, shift): builder.PrependInt32Slot(3, shift, 0) -def ResizeAttributeAddStrideFp(builder, strideFp): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(strideFp), 0) -def ResizeAttributeStartStrideFpVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def ResizeAttributeAddOffsetFp(builder, offsetFp): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(offsetFp), 0) -def ResizeAttributeStartOffsetFpVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def ResizeAttributeAddMode(builder, mode): builder.PrependUint32Slot(6, mode, 0) -def ResizeAttributeEnd(builder): return builder.EndObject() +def End(builder): + return ResizeAttributeEnd(builder) diff --git a/ethosu/vela/tosa/ResizeMode.py b/ethosu/vela/tosa/ResizeMode.py index 65bcd5d..388ecda 100644 --- a/ethosu/vela/tosa/ResizeMode.py +++ b/ethosu/vela/tosa/ResizeMode.py @@ -6,4 +6,3 @@ class ResizeMode(object): UNKNOWN = 0 NEAREST = 1 BILINEAR = 2 - diff --git a/ethosu/vela/tosa/SliceAttribute.py b/ethosu/vela/tosa/SliceAttribute.py index d2f9958..6d8e00b 100644 --- a/ethosu/vela/tosa/SliceAttribute.py +++ b/ethosu/vela/tosa/SliceAttribute.py @@ -3,23 +3,33 @@ # namespace: tosa import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class SliceAttribute(object): __slots__ = ['_tab'] @classmethod - def GetRootAsSliceAttribute(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = SliceAttribute() x.Init(buf, n + offset) return x + @classmethod + def GetRootAsSliceAttribute(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def SliceAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) + # SliceAttribute def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) # SliceAttribute - def Begin(self, j): + def Start(self, j): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: a = self._tab.Vector(o) @@ -27,20 +37,25 @@ class SliceAttribute(object): return 0 # SliceAttribute - def BeginAsNumpy(self): + def StartAsNumpy(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) return 0 # SliceAttribute - def BeginLength(self): + def StartLength(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: return self._tab.VectorLen(o) return 0 # SliceAttribute + def StartIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + + # SliceAttribute def Size(self, j): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) if o != 0: @@ -62,9 +77,43 @@ class SliceAttribute(object): return self._tab.VectorLen(o) return 0 -def SliceAttributeStart(builder): builder.StartObject(2) -def SliceAttributeAddBegin(builder, begin): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(begin), 0) -def SliceAttributeStartBeginVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def SliceAttributeAddSize(builder, size): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(size), 0) -def SliceAttributeStartSizeVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def SliceAttributeEnd(builder): return builder.EndObject() + # SliceAttribute + def SizeIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + return o == 0 + +def SliceAttributeStart(builder): + builder.StartObject(2) + +def Start(builder): + SliceAttributeStart(builder) + +def SliceAttributeAddStart(builder, start): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(start), 0) + +def AddStart(builder, start): + SliceAttributeAddStart(builder, start) + +def SliceAttributeStartStartVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StartStartVector(builder, numElems: int) -> int: + return SliceAttributeStartStartVector(builder, numElems) + +def SliceAttributeAddSize(builder, size): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(size), 0) + +def AddSize(builder, size): + SliceAttributeAddSize(builder, size) + +def SliceAttributeStartSizeVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StartSizeVector(builder, numElems: int) -> int: + return SliceAttributeStartSizeVector(builder, numElems) + +def SliceAttributeEnd(builder): + return builder.EndObject() + +def End(builder): + return SliceAttributeEnd(builder) diff --git a/ethosu/vela/tosa/TableAttribute.py b/ethosu/vela/tosa/TableAttribute.py new file mode 100644 index 0000000..6caa1f2 --- /dev/null +++ b/ethosu/vela/tosa/TableAttribute.py @@ -0,0 +1,80 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tosa + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class TableAttribute(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = TableAttribute() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsTableAttribute(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def TableAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) + + # TableAttribute + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # TableAttribute + def Table(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int16Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 2)) + return 0 + + # TableAttribute + def TableAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int16Flags, o) + return 0 + + # TableAttribute + def TableLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # TableAttribute + def TableIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + +def TableAttributeStart(builder): + builder.StartObject(1) + +def Start(builder): + TableAttributeStart(builder) + +def TableAttributeAddTable(builder, table): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(table), 0) + +def AddTable(builder, table): + TableAttributeAddTable(builder, table) + +def TableAttributeStartTableVector(builder, numElems): + return builder.StartVector(2, numElems, 2) + +def StartTableVector(builder, numElems: int) -> int: + return TableAttributeStartTableVector(builder, numElems) + +def TableAttributeEnd(builder): + return builder.EndObject() + +def End(builder): + return TableAttributeEnd(builder) diff --git a/ethosu/vela/tosa/TileAttribute.py b/ethosu/vela/tosa/TileAttribute.py index f1b721b..89bf23b 100644 --- a/ethosu/vela/tosa/TileAttribute.py +++ b/ethosu/vela/tosa/TileAttribute.py @@ -3,17 +3,27 @@ # namespace: tosa import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class TileAttribute(object): __slots__ = ['_tab'] @classmethod - def GetRootAsTileAttribute(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = TileAttribute() x.Init(buf, n + offset) return x + @classmethod + def GetRootAsTileAttribute(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def TileAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) + # TileAttribute def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) @@ -40,7 +50,31 @@ class TileAttribute(object): return self._tab.VectorLen(o) return 0 -def TileAttributeStart(builder): builder.StartObject(1) -def TileAttributeAddMultiples(builder, multiples): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(multiples), 0) -def TileAttributeStartMultiplesVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def TileAttributeEnd(builder): return builder.EndObject() + # TileAttribute + def MultiplesIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + +def TileAttributeStart(builder): + builder.StartObject(1) + +def Start(builder): + TileAttributeStart(builder) + +def TileAttributeAddMultiples(builder, multiples): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(multiples), 0) + +def AddMultiples(builder, multiples): + TileAttributeAddMultiples(builder, multiples) + +def TileAttributeStartMultiplesVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StartMultiplesVector(builder, numElems: int) -> int: + return TileAttributeStartMultiplesVector(builder, numElems) + +def TileAttributeEnd(builder): + return builder.EndObject() + +def End(builder): + return TileAttributeEnd(builder) diff --git a/ethosu/vela/tosa/TosaBasicBlock.py b/ethosu/vela/tosa/TosaBasicBlock.py index 8f1604a..b31f455 100644 --- a/ethosu/vela/tosa/TosaBasicBlock.py +++ b/ethosu/vela/tosa/TosaBasicBlock.py @@ -3,17 +3,27 @@ # namespace: tosa import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class TosaBasicBlock(object): __slots__ = ['_tab'] @classmethod - def GetRootAsTosaBasicBlock(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = TosaBasicBlock() x.Init(buf, n + offset) return x + @classmethod + def GetRootAsTosaBasicBlock(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def TosaBasicBlockBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) + # TosaBasicBlock def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) @@ -32,7 +42,7 @@ class TosaBasicBlock(object): x = self._tab.Vector(o) x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 x = self._tab.Indirect(x) - from .TosaOperator import TosaOperator + from tosa.TosaOperator import TosaOperator obj = TosaOperator() obj.Init(self._tab.Bytes, x) return obj @@ -46,13 +56,18 @@ class TosaBasicBlock(object): return 0 # TosaBasicBlock + def OperatorsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + return o == 0 + + # TosaBasicBlock def Tensors(self, j): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) if o != 0: x = self._tab.Vector(o) x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 x = self._tab.Indirect(x) - from .TosaTensor import TosaTensor + from tosa.TosaTensor import TosaTensor obj = TosaTensor() obj.Init(self._tab.Bytes, x) return obj @@ -66,6 +81,11 @@ class TosaBasicBlock(object): return 0 # TosaBasicBlock + def TensorsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + return o == 0 + + # TosaBasicBlock def Inputs(self, j): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) if o != 0: @@ -81,6 +101,11 @@ class TosaBasicBlock(object): return 0 # TosaBasicBlock + def InputsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + return o == 0 + + # TosaBasicBlock def Outputs(self, j): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) if o != 0: @@ -95,14 +120,73 @@ class TosaBasicBlock(object): return self._tab.VectorLen(o) return 0 -def TosaBasicBlockStart(builder): builder.StartObject(5) -def TosaBasicBlockAddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) -def TosaBasicBlockAddOperators(builder, operators): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(operators), 0) -def TosaBasicBlockStartOperatorsVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def TosaBasicBlockAddTensors(builder, tensors): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(tensors), 0) -def TosaBasicBlockStartTensorsVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def TosaBasicBlockAddInputs(builder, inputs): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(inputs), 0) -def TosaBasicBlockStartInputsVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def TosaBasicBlockAddOutputs(builder, outputs): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(outputs), 0) -def TosaBasicBlockStartOutputsVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def TosaBasicBlockEnd(builder): return builder.EndObject() + # TosaBasicBlock + def OutputsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + return o == 0 + +def TosaBasicBlockStart(builder): + builder.StartObject(5) + +def Start(builder): + TosaBasicBlockStart(builder) + +def TosaBasicBlockAddName(builder, name): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) + +def AddName(builder, name): + TosaBasicBlockAddName(builder, name) + +def TosaBasicBlockAddOperators(builder, operators): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(operators), 0) + +def AddOperators(builder, operators): + TosaBasicBlockAddOperators(builder, operators) + +def TosaBasicBlockStartOperatorsVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StartOperatorsVector(builder, numElems: int) -> int: + return TosaBasicBlockStartOperatorsVector(builder, numElems) + +def TosaBasicBlockAddTensors(builder, tensors): + builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(tensors), 0) + +def AddTensors(builder, tensors): + TosaBasicBlockAddTensors(builder, tensors) + +def TosaBasicBlockStartTensorsVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StartTensorsVector(builder, numElems: int) -> int: + return TosaBasicBlockStartTensorsVector(builder, numElems) + +def TosaBasicBlockAddInputs(builder, inputs): + builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(inputs), 0) + +def AddInputs(builder, inputs): + TosaBasicBlockAddInputs(builder, inputs) + +def TosaBasicBlockStartInputsVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StartInputsVector(builder, numElems: int) -> int: + return TosaBasicBlockStartInputsVector(builder, numElems) + +def TosaBasicBlockAddOutputs(builder, outputs): + builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(outputs), 0) + +def AddOutputs(builder, outputs): + TosaBasicBlockAddOutputs(builder, outputs) + +def TosaBasicBlockStartOutputsVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StartOutputsVector(builder, numElems: int) -> int: + return TosaBasicBlockStartOutputsVector(builder, numElems) + +def TosaBasicBlockEnd(builder): + return builder.EndObject() + +def End(builder): + return TosaBasicBlockEnd(builder) diff --git a/ethosu/vela/tosa/TosaGraph.py b/ethosu/vela/tosa/TosaGraph.py index f54a44a..84b51a7 100644 --- a/ethosu/vela/tosa/TosaGraph.py +++ b/ethosu/vela/tosa/TosaGraph.py @@ -3,17 +3,27 @@ # namespace: tosa import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class TosaGraph(object): __slots__ = ['_tab'] @classmethod - def GetRootAsTosaGraph(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = TosaGraph() x.Init(buf, n + offset) return x + @classmethod + def GetRootAsTosaGraph(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def TosaGraphBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) + # TosaGraph def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) @@ -23,34 +33,63 @@ class TosaGraph(object): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: x = self._tab.Indirect(o + self._tab.Pos) - from .Version import Version + from tosa.Version import Version obj = Version() obj.Init(self._tab.Bytes, x) return obj return None # TosaGraph - def Blocks(self, j): + def Regions(self, j): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) if o != 0: x = self._tab.Vector(o) x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 x = self._tab.Indirect(x) - from .TosaBasicBlock import TosaBasicBlock - obj = TosaBasicBlock() + from tosa.TosaRegion import TosaRegion + obj = TosaRegion() obj.Init(self._tab.Bytes, x) return obj return None # TosaGraph - def BlocksLength(self): + def RegionsLength(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) if o != 0: return self._tab.VectorLen(o) return 0 -def TosaGraphStart(builder): builder.StartObject(2) -def TosaGraphAddVersion(builder, version): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(version), 0) -def TosaGraphAddBlocks(builder, blocks): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(blocks), 0) -def TosaGraphStartBlocksVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def TosaGraphEnd(builder): return builder.EndObject() + # TosaGraph + def RegionsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + return o == 0 + +def TosaGraphStart(builder): + builder.StartObject(2) + +def Start(builder): + TosaGraphStart(builder) + +def TosaGraphAddVersion(builder, version): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(version), 0) + +def AddVersion(builder, version): + TosaGraphAddVersion(builder, version) + +def TosaGraphAddRegions(builder, regions): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(regions), 0) + +def AddRegions(builder, regions): + TosaGraphAddRegions(builder, regions) + +def TosaGraphStartRegionsVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StartRegionsVector(builder, numElems: int) -> int: + return TosaGraphStartRegionsVector(builder, numElems) + +def TosaGraphEnd(builder): + return builder.EndObject() + +def End(builder): + return TosaGraphEnd(builder) diff --git a/ethosu/vela/tosa/TosaOperator.py b/ethosu/vela/tosa/TosaOperator.py index c45efda..2b889ad 100644 --- a/ethosu/vela/tosa/TosaOperator.py +++ b/ethosu/vela/tosa/TosaOperator.py @@ -3,17 +3,27 @@ # namespace: tosa import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class TosaOperator(object): __slots__ = ['_tab'] @classmethod - def GetRootAsTosaOperator(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = TosaOperator() x.Init(buf, n + offset) return x + @classmethod + def GetRootAsTosaOperator(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def TosaOperatorBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) + # TosaOperator def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) @@ -58,6 +68,11 @@ class TosaOperator(object): return 0 # TosaOperator + def InputsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + return o == 0 + + # TosaOperator def Outputs(self, j): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) if o != 0: @@ -73,30 +88,60 @@ class TosaOperator(object): return 0 # TosaOperator - def QuantInfoType(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos) - return 0 + def OutputsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + return o == 0 - # TosaOperator - def QuantInfo(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) - if o != 0: - from flatbuffers.table import Table - obj = Table(bytearray(), 0) - self._tab.Union(obj, o) - return obj - return None +def TosaOperatorStart(builder): + builder.StartObject(5) + +def Start(builder): + TosaOperatorStart(builder) + +def TosaOperatorAddOp(builder, op): + builder.PrependUint32Slot(0, op, 0) + +def AddOp(builder, op): + TosaOperatorAddOp(builder, op) + +def TosaOperatorAddAttributeType(builder, attributeType): + builder.PrependUint8Slot(1, attributeType, 0) + +def AddAttributeType(builder, attributeType): + TosaOperatorAddAttributeType(builder, attributeType) + +def TosaOperatorAddAttribute(builder, attribute): + builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(attribute), 0) + +def AddAttribute(builder, attribute): + TosaOperatorAddAttribute(builder, attribute) + +def TosaOperatorAddInputs(builder, inputs): + builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(inputs), 0) + +def AddInputs(builder, inputs): + TosaOperatorAddInputs(builder, inputs) + +def TosaOperatorStartInputsVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StartInputsVector(builder, numElems: int) -> int: + return TosaOperatorStartInputsVector(builder, numElems) + +def TosaOperatorAddOutputs(builder, outputs): + builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(outputs), 0) + +def AddOutputs(builder, outputs): + TosaOperatorAddOutputs(builder, outputs) + +def TosaOperatorStartOutputsVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StartOutputsVector(builder, numElems: int) -> int: + return TosaOperatorStartOutputsVector(builder, numElems) + +def TosaOperatorEnd(builder): + return builder.EndObject() -def TosaOperatorStart(builder): builder.StartObject(7) -def TosaOperatorAddOp(builder, op): builder.PrependUint32Slot(0, op, 0) -def TosaOperatorAddAttributeType(builder, attributeType): builder.PrependUint8Slot(1, attributeType, 0) -def TosaOperatorAddAttribute(builder, attribute): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(attribute), 0) -def TosaOperatorAddInputs(builder, inputs): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(inputs), 0) -def TosaOperatorStartInputsVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def TosaOperatorAddOutputs(builder, outputs): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(outputs), 0) -def TosaOperatorStartOutputsVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def TosaOperatorAddQuantInfoType(builder, quantInfoType): builder.PrependUint8Slot(5, quantInfoType, 0) -def TosaOperatorAddQuantInfo(builder, quantInfo): builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(quantInfo), 0) -def TosaOperatorEnd(builder): return builder.EndObject() +def End(builder): + return TosaOperatorEnd(builder) diff --git a/ethosu/vela/tosa/TosaRegion.py b/ethosu/vela/tosa/TosaRegion.py new file mode 100644 index 0000000..7fd6e3c --- /dev/null +++ b/ethosu/vela/tosa/TosaRegion.py @@ -0,0 +1,91 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tosa + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class TosaRegion(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = TosaRegion() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsTosaRegion(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def TosaRegionBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) + + # TosaRegion + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # TosaRegion + def Name(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 + + # TosaRegion + def Blocks(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + x = self._tab.Vector(o) + x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 + x = self._tab.Indirect(x) + from tosa.TosaBasicBlock import TosaBasicBlock + obj = TosaBasicBlock() + obj.Init(self._tab.Bytes, x) + return obj + return None + + # TosaRegion + def BlocksLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # TosaRegion + def BlocksIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + return o == 0 + +def TosaRegionStart(builder): + builder.StartObject(2) + +def Start(builder): + TosaRegionStart(builder) + +def TosaRegionAddName(builder, name): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) + +def AddName(builder, name): + TosaRegionAddName(builder, name) + +def TosaRegionAddBlocks(builder, blocks): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(blocks), 0) + +def AddBlocks(builder, blocks): + TosaRegionAddBlocks(builder, blocks) + +def TosaRegionStartBlocksVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StartBlocksVector(builder, numElems: int) -> int: + return TosaRegionStartBlocksVector(builder, numElems) + +def TosaRegionEnd(builder): + return builder.EndObject() + +def End(builder): + return TosaRegionEnd(builder) diff --git a/ethosu/vela/tosa/TosaTensor.py b/ethosu/vela/tosa/TosaTensor.py index 01ae7ec..850ff8f 100644 --- a/ethosu/vela/tosa/TosaTensor.py +++ b/ethosu/vela/tosa/TosaTensor.py @@ -3,17 +3,27 @@ # namespace: tosa import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class TosaTensor(object): __slots__ = ['_tab'] @classmethod - def GetRootAsTosaTensor(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = TosaTensor() x.Init(buf, n + offset) return x + @classmethod + def GetRootAsTosaTensor(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def TosaTensorBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) + # TosaTensor def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) @@ -48,6 +58,11 @@ class TosaTensor(object): return 0 # TosaTensor + def ShapeIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + return o == 0 + + # TosaTensor def Type(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) if o != 0: @@ -76,11 +91,55 @@ class TosaTensor(object): return self._tab.VectorLen(o) return 0 -def TosaTensorStart(builder): builder.StartObject(4) -def TosaTensorAddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) -def TosaTensorAddShape(builder, shape): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(shape), 0) -def TosaTensorStartShapeVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def TosaTensorAddType(builder, type): builder.PrependUint32Slot(2, type, 0) -def TosaTensorAddData(builder, data): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(data), 0) -def TosaTensorStartDataVector(builder, numElems): return builder.StartVector(1, numElems, 1) -def TosaTensorEnd(builder): return builder.EndObject() + # TosaTensor + def DataIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + return o == 0 + +def TosaTensorStart(builder): + builder.StartObject(4) + +def Start(builder): + TosaTensorStart(builder) + +def TosaTensorAddName(builder, name): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) + +def AddName(builder, name): + TosaTensorAddName(builder, name) + +def TosaTensorAddShape(builder, shape): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(shape), 0) + +def AddShape(builder, shape): + TosaTensorAddShape(builder, shape) + +def TosaTensorStartShapeVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StartShapeVector(builder, numElems: int) -> int: + return TosaTensorStartShapeVector(builder, numElems) + +def TosaTensorAddType(builder, type): + builder.PrependUint32Slot(2, type, 0) + +def AddType(builder, type): + TosaTensorAddType(builder, type) + +def TosaTensorAddData(builder, data): + builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(data), 0) + +def AddData(builder, data): + TosaTensorAddData(builder, data) + +def TosaTensorStartDataVector(builder, numElems): + return builder.StartVector(1, numElems, 1) + +def StartDataVector(builder, numElems: int) -> int: + return TosaTensorStartDataVector(builder, numElems) + +def TosaTensorEnd(builder): + return builder.EndObject() + +def End(builder): + return TosaTensorEnd(builder) diff --git a/ethosu/vela/tosa/TransposeAttribute.py b/ethosu/vela/tosa/TransposeAttribute.py new file mode 100644 index 0000000..71cfdf0 --- /dev/null +++ b/ethosu/vela/tosa/TransposeAttribute.py @@ -0,0 +1,80 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tosa + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class TransposeAttribute(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = TransposeAttribute() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsTransposeAttribute(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def TransposeAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) + + # TransposeAttribute + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # TransposeAttribute + def Perms(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return 0 + + # TransposeAttribute + def PermsAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return 0 + + # TransposeAttribute + def PermsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # TransposeAttribute + def PermsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + +def TransposeAttributeStart(builder): + builder.StartObject(1) + +def Start(builder): + TransposeAttributeStart(builder) + +def TransposeAttributeAddPerms(builder, perms): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(perms), 0) + +def AddPerms(builder, perms): + TransposeAttributeAddPerms(builder, perms) + +def TransposeAttributeStartPermsVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StartPermsVector(builder, numElems: int) -> int: + return TransposeAttributeStartPermsVector(builder, numElems) + +def TransposeAttributeEnd(builder): + return builder.EndObject() + +def End(builder): + return TransposeAttributeEnd(builder) diff --git a/ethosu/vela/tosa/TransposeConvAttribute.py b/ethosu/vela/tosa/TransposeConvAttribute.py index c7aeb41..def507e 100644 --- a/ethosu/vela/tosa/TransposeConvAttribute.py +++ b/ethosu/vela/tosa/TransposeConvAttribute.py @@ -3,23 +3,33 @@ # namespace: tosa import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class TransposeConvAttribute(object): __slots__ = ['_tab'] @classmethod - def GetRootAsTransposeConvAttribute(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = TransposeConvAttribute() x.Init(buf, n + offset) return x + @classmethod + def GetRootAsTransposeConvAttribute(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def TransposeConvAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) + # TransposeConvAttribute def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) # TransposeConvAttribute - def Outpad(self, j): + def OutPad(self, j): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: a = self._tab.Vector(o) @@ -27,20 +37,25 @@ class TransposeConvAttribute(object): return 0 # TransposeConvAttribute - def OutpadAsNumpy(self): + def OutPadAsNumpy(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) return 0 # TransposeConvAttribute - def OutpadLength(self): + def OutPadLength(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: return self._tab.VectorLen(o) return 0 # TransposeConvAttribute + def OutPadIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + + # TransposeConvAttribute def Stride(self, j): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) if o != 0: @@ -63,7 +78,12 @@ class TransposeConvAttribute(object): return 0 # TransposeConvAttribute - def Dilation(self, j): + def StrideIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + return o == 0 + + # TransposeConvAttribute + def OutputShape(self, j): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) if o != 0: a = self._tab.Vector(o) @@ -71,48 +91,94 @@ class TransposeConvAttribute(object): return 0 # TransposeConvAttribute - def DilationAsNumpy(self): + def OutputShapeAsNumpy(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) if o != 0: return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) return 0 # TransposeConvAttribute - def DilationLength(self): + def OutputShapeLength(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) if o != 0: return self._tab.VectorLen(o) return 0 # TransposeConvAttribute - def OutputShape(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) - if o != 0: - a = self._tab.Vector(o) - return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) - return 0 + def OutputShapeIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + return o == 0 # TransposeConvAttribute - def OutputShapeAsNumpy(self): + def InputZp(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) return 0 # TransposeConvAttribute - def OutputShapeLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + def WeightZp(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) if o != 0: - return self._tab.VectorLen(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) return 0 -def TransposeConvAttributeStart(builder): builder.StartObject(4) -def TransposeConvAttributeAddOutpad(builder, outpad): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(outpad), 0) -def TransposeConvAttributeStartOutpadVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def TransposeConvAttributeAddStride(builder, stride): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(stride), 0) -def TransposeConvAttributeStartStrideVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def TransposeConvAttributeAddDilation(builder, dilation): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(dilation), 0) -def TransposeConvAttributeStartDilationVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def TransposeConvAttributeAddOutputShape(builder, outputShape): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(outputShape), 0) -def TransposeConvAttributeStartOutputShapeVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def TransposeConvAttributeEnd(builder): return builder.EndObject() +def TransposeConvAttributeStart(builder): + builder.StartObject(5) + +def Start(builder): + TransposeConvAttributeStart(builder) + +def TransposeConvAttributeAddOutPad(builder, outPad): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(outPad), 0) + +def AddOutPad(builder, outPad): + TransposeConvAttributeAddOutPad(builder, outPad) + +def TransposeConvAttributeStartOutPadVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StartOutPadVector(builder, numElems: int) -> int: + return TransposeConvAttributeStartOutPadVector(builder, numElems) + +def TransposeConvAttributeAddStride(builder, stride): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(stride), 0) + +def AddStride(builder, stride): + TransposeConvAttributeAddStride(builder, stride) + +def TransposeConvAttributeStartStrideVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StartStrideVector(builder, numElems: int) -> int: + return TransposeConvAttributeStartStrideVector(builder, numElems) + +def TransposeConvAttributeAddOutputShape(builder, outputShape): + builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(outputShape), 0) + +def AddOutputShape(builder, outputShape): + TransposeConvAttributeAddOutputShape(builder, outputShape) + +def TransposeConvAttributeStartOutputShapeVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StartOutputShapeVector(builder, numElems: int) -> int: + return TransposeConvAttributeStartOutputShapeVector(builder, numElems) + +def TransposeConvAttributeAddInputZp(builder, inputZp): + builder.PrependInt32Slot(3, inputZp, 0) + +def AddInputZp(builder, inputZp): + TransposeConvAttributeAddInputZp(builder, inputZp) + +def TransposeConvAttributeAddWeightZp(builder, weightZp): + builder.PrependInt32Slot(4, weightZp, 0) + +def AddWeightZp(builder, weightZp): + TransposeConvAttributeAddWeightZp(builder, weightZp) + +def TransposeConvAttributeEnd(builder): + return builder.EndObject() + +def End(builder): + return TransposeConvAttributeEnd(builder) diff --git a/ethosu/vela/tosa/UnaryQuantInfo.py b/ethosu/vela/tosa/UnaryQuantInfo.py deleted file mode 100644 index 7111c6c..0000000 --- a/ethosu/vela/tosa/UnaryQuantInfo.py +++ /dev/null @@ -1,38 +0,0 @@ -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tosa - -import flatbuffers - -class UnaryQuantInfo(object): - __slots__ = ['_tab'] - - @classmethod - def GetRootAsUnaryQuantInfo(cls, buf, offset): - n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = UnaryQuantInfo() - x.Init(buf, n + offset) - return x - - # UnaryQuantInfo - def Init(self, buf, pos): - self._tab = flatbuffers.table.Table(buf, pos) - - # UnaryQuantInfo - def InputZp(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 - - # UnaryQuantInfo - def OutputZp(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 UnaryQuantInfoStart(builder): builder.StartObject(2) -def UnaryQuantInfoAddInputZp(builder, inputZp): builder.PrependInt32Slot(0, inputZp, 0) -def UnaryQuantInfoAddOutputZp(builder, outputZp): builder.PrependInt32Slot(1, outputZp, 0) -def UnaryQuantInfoEnd(builder): return builder.EndObject() diff --git a/ethosu/vela/tosa/Version.py b/ethosu/vela/tosa/Version.py index 403add3..369f356 100644 --- a/ethosu/vela/tosa/Version.py +++ b/ethosu/vela/tosa/Version.py @@ -3,52 +3,91 @@ # namespace: tosa import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class Version(object): __slots__ = ['_tab'] @classmethod - def GetRootAsVersion(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = Version() x.Init(buf, n + offset) return x + @classmethod + def GetRootAsVersion(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def VersionBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) + # Version def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) # Version - def _major(self): + def _Major(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 + return -1 # Version - def _minor(self): + def _Minor(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 22 + return -1 # Version - def _patch(self): + def _Patch(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) if o != 0: return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) - return 0 + return -1 # Version - def _experimental(self): + def _Draft(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) if o != 0: return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) - return False - -def VersionStart(builder): builder.StartObject(4) -def VersionAdd_major(builder, Major): builder.PrependInt32Slot(0, Major, 0) -def VersionAdd_minor(builder, Minor): builder.PrependInt32Slot(1, Minor, 22) -def VersionAdd_patch(builder, Patch): builder.PrependInt32Slot(2, Patch, 0) -def VersionAdd_experimental(builder, Experimental): builder.PrependBoolSlot(3, Experimental, 0) -def VersionEnd(builder): return builder.EndObject() + return True + +def VersionStart(builder): + builder.StartObject(4) + +def Start(builder): + VersionStart(builder) + +def VersionAdd_Major(builder, _Major): + builder.PrependInt32Slot(0, _Major, -1) + +def Add_Major(builder, _Major): + VersionAdd_Major(builder, _Major) + +def VersionAdd_Minor(builder, _Minor): + builder.PrependInt32Slot(1, _Minor, -1) + +def Add_Minor(builder, _Minor): + VersionAdd_Minor(builder, _Minor) + +def VersionAdd_Patch(builder, _Patch): + builder.PrependInt32Slot(2, _Patch, -1) + +def Add_Patch(builder, _Patch): + VersionAdd_Patch(builder, _Patch) + +def VersionAdd_Draft(builder, _Draft): + builder.PrependBoolSlot(3, _Draft, 1) + +def Add_Draft(builder, _Draft): + VersionAdd_Draft(builder, _Draft) + +def VersionEnd(builder): + return builder.EndObject() + +def End(builder): + return VersionEnd(builder) diff --git a/ethosu/vela/tosa/WhileLoopAttribute.py b/ethosu/vela/tosa/WhileLoopAttribute.py index 68655c9..20bc728 100644 --- a/ethosu/vela/tosa/WhileLoopAttribute.py +++ b/ethosu/vela/tosa/WhileLoopAttribute.py @@ -3,17 +3,27 @@ # namespace: tosa import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() class WhileLoopAttribute(object): __slots__ = ['_tab'] @classmethod - def GetRootAsWhileLoopAttribute(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = WhileLoopAttribute() x.Init(buf, n + offset) return x + @classmethod + def GetRootAsWhileLoopAttribute(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def WhileLoopAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) + # WhileLoopAttribute def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) @@ -32,7 +42,26 @@ class WhileLoopAttribute(object): return self._tab.String(o + self._tab.Pos) return None -def WhileLoopAttributeStart(builder): builder.StartObject(2) -def WhileLoopAttributeAddCondBranch(builder, condBranch): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(condBranch), 0) -def WhileLoopAttributeAddBodyBranch(builder, bodyBranch): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(bodyBranch), 0) -def WhileLoopAttributeEnd(builder): return builder.EndObject() +def WhileLoopAttributeStart(builder): + builder.StartObject(2) + +def Start(builder): + WhileLoopAttributeStart(builder) + +def WhileLoopAttributeAddCondBranch(builder, condBranch): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(condBranch), 0) + +def AddCondBranch(builder, condBranch): + WhileLoopAttributeAddCondBranch(builder, condBranch) + +def WhileLoopAttributeAddBodyBranch(builder, bodyBranch): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(bodyBranch), 0) + +def AddBodyBranch(builder, bodyBranch): + WhileLoopAttributeAddBodyBranch(builder, bodyBranch) + +def WhileLoopAttributeEnd(builder): + return builder.EndObject() + +def End(builder): + return WhileLoopAttributeEnd(builder) diff --git a/ethosu/vela/tosa_mapping.py b/ethosu/vela/tosa_mapping.py index 97fdd20..2dafd81 100644 --- a/ethosu/vela/tosa_mapping.py +++ b/ethosu/vela/tosa_mapping.py @@ -1,4 +1,4 @@ -# SPDX-FileCopyrightText: Copyright 2021-2022 Arm Limited and/or its affiliates <open-source-office@arm.com> +# SPDX-FileCopyrightText: Copyright 2021-2023 Arm Limited and/or its affiliates <open-source-office@arm.com> # # SPDX-License-Identifier: Apache-2.0 # @@ -28,19 +28,16 @@ from .tosa import AxisAttribute # noqa: F401 from .tosa import ClampAttribute # noqa: F401 from .tosa import CondIfAttribute # noqa: F401 from .tosa import ConvAttribute # noqa: F401 -from .tosa import ConvQuantInfo # noqa: F401 -from .tosa import MatMulQuantInfo # noqa: F401 +from .tosa import FullyConnectedAttribute # noqa: F401 from .tosa import MulAttribute # noqa: F401 -from .tosa import PadQuantInfo # noqa: F401 from .tosa import PoolAttribute # noqa: F401 -from .tosa import ReluNAttribute # noqa: F401 from .tosa import RescaleAttribute # noqa: F401 from .tosa import ReshapeAttribute # noqa: F401 from .tosa import ResizeAttribute # noqa: F401 from .tosa import SliceAttribute # noqa: F401 from .tosa import TileAttribute # noqa: F401 +from .tosa import TransposeAttribute # noqa: F401 from .tosa import TransposeConvAttribute # noqa: F401 -from .tosa import UnaryQuantInfo # noqa: F401 from .tosa import WhileLoopAttribute # noqa: F401 from .tosa.DType import DType from .tosa.Op import Op as TosaOp @@ -54,7 +51,7 @@ datatype_map = { DType.INT16: DataType.int16, DType.INT32: DataType.int32, DType.INT48: DataType.int48, - DType.FLOAT: DataType.float32, + DType.FP32: DataType.float32, } datatype_map_numpy = { @@ -63,7 +60,7 @@ datatype_map_numpy = { DType.INT8: np.int8, DType.INT16: np.int16, DType.INT32: np.int32, - DType.FLOAT: np.float32, + DType.FP32: np.float32, } @@ -118,65 +115,64 @@ class AttrSerializer: return attrs -class QuantSerializer: - def __init__(self, name, members=None): - self.name = name - self.module = globals()[self.name] - self.cls = getattr(self.module, self.name) - self.members = [] - if members is not None: - for mem in members: - deserialize = identity - underscore_mem = mem - camelcase_mem = underscore_to_camel_case(mem) - self.members.append((underscore_mem, camelcase_mem, deserialize)) - - def deserialize(self, op_data): - quant_info_type = op_data.QuantInfoType() - quant_info = op_data.QuantInfo() - quant = {} - if quant_info_type: - tosa_quant = self.cls() - tosa_quant.Init(quant_info.Bytes, quant_info.Pos) - for underscore_mem, camelcase_mem, deserialize in self.members: - attr = getattr(tosa_quant, camelcase_mem)() - try: - quant[underscore_mem] = deserialize(attr) - except TypeError: - print("Warning: {0} could not read quant info '{1}'.".format(self.name, underscore_mem)) - - return quant - - is_vec = True -pool_attrs = AttrSerializer("PoolAttribute", (("padding", is_vec), ("kernel", is_vec), ("stride", is_vec))) -conv_attrs = AttrSerializer("ConvAttribute", (("padding", is_vec), ("stride", is_vec), ("dilation", is_vec))) +pool_attrs = AttrSerializer( + "PoolAttribute", + ( + ("pad", is_vec), + ("kernel", is_vec), + ("stride", is_vec), + ("input_zp"), + ("output_zp"), + ), +) +conv_attrs = AttrSerializer( + "ConvAttribute", + ( + ("pad", is_vec), + ("stride", is_vec), + ("dilation", is_vec), + ("input_zp"), + ("weight_zp"), + ), +) +fc_attrs = AttrSerializer("FullyConnectedAttribute", (("input_zp"), ("weight_zp"))) transpose_conv_attrs = AttrSerializer( - "TransposeConvAttribute", (("outpad", is_vec), ("stride", is_vec), ("dilation", is_vec), ("out_shape", is_vec)) + "TransposeConvAttribute", + ( + ("outpad", is_vec), + ("stride", is_vec), + ("dilation", is_vec), + ("out_shape", is_vec), + ), ) -relun_attrs = AttrSerializer("ReluNAttribute", ("max_int")) +transpose_attrs = AttrSerializer("TransposeAttribute", (("perms", is_vec),)) axis_attrs = AttrSerializer("AxisAttribute", ("axis",)) reshape_attrs = AttrSerializer("ReshapeAttribute", (("shape", is_vec),)) -slice_attrs = AttrSerializer("SliceAttribute", (("begin", is_vec), ("size", is_vec))) +slice_attrs = AttrSerializer("SliceAttribute", (("start", is_vec), ("size", is_vec))) tile_attrs = AttrSerializer("TileAttribute", (("multiplies", is_vec),)) resize_attrs = AttrSerializer( - "ResizeAttribute", (("output_size", is_vec), ("stride", is_vec), ("offset", is_vec), ("shift")) + "ResizeAttribute", + (("output_size", is_vec), ("stride", is_vec), ("offset", is_vec), ("shift")), ) clamp_attrs = AttrSerializer("ClampAttribute", (("min_int"), ("max_int"))) rescale_attrs = AttrSerializer( "RescaleAttribute", - ("input_zp", "output_zp", ("multiplier", is_vec), ("shift", is_vec), "scale32", "double_round", "per_channel"), + ( + "input_zp", + "output_zp", + ("multiplier", is_vec), + ("shift", is_vec), + "scale32", + "double_round", + "per_channel", + ), ) mul_attrs = AttrSerializer("MulAttribute", ("shift",)) ars_attrs = AttrSerializer("ArithmeticRightShiftAttribute", ("round",)) condif_attrs = AttrSerializer("CondIfAttribute", (("then_branch"), ("else_branch"))) # TODO these are references while_attrs = AttrSerializer("WhileLoopAttribute", (("cond_branch"), ("body_branch"))) # TODO these are references -unary_quant_info = QuantSerializer("UnaryQuantInfo", ("input_zp", "output_zp")) -conv_quant_info = QuantSerializer("ConvQuantInfo", ("input_zp", "weight_zp")) -matmul_quant_info = QuantSerializer("MatMulQuantInfo", ("a_zp", "b_zp")) -pad_quant_info = QuantSerializer("PadQuantInfo", ("input_zp",)) - unsupported_tosa_operators = { TosaOp.UNKNOWN, TosaOp.ARGMAX, @@ -245,16 +241,26 @@ TOSA_CONCAT_INDICES = TensorIndices([1, 2], [], []) tosa_operator_map = { # TosaOp.UNKNOWN: (), # TODO TosaOp.ARGMAX: (Op.ArgMax, axis_attrs, None), - TosaOp.AVG_POOL2D: (Op.AvgPool, pool_attrs, unary_quant_info, TOSA_IFM_INDICES), - TosaOp.CONV2D: (Op.Conv2DBias, conv_attrs, conv_quant_info, TOSA_IFM_WEIGHTS_BIAS_INDICES), + TosaOp.AVG_POOL2D: (Op.AvgPool, pool_attrs, None, TOSA_IFM_INDICES), + TosaOp.CONV2D: (Op.Conv2DBias, conv_attrs, None, TOSA_IFM_WEIGHTS_BIAS_INDICES), # TODO TosaOp.CONV3D: - TosaOp.DEPTHWISE_CONV2D: (Op.DepthwiseConv2DBias, conv_attrs, conv_quant_info, TOSA_IFM_WEIGHTS_BIAS_INDICES), - TosaOp.FULLY_CONNECTED: (Op.FullyConnected, None, conv_quant_info, TOSA_IFM_WEIGHTS_BIAS_INDICES), + TosaOp.DEPTHWISE_CONV2D: ( + Op.DepthwiseConv2DBias, + conv_attrs, + None, + TOSA_IFM_WEIGHTS_BIAS_INDICES, + ), + TosaOp.FULLY_CONNECTED: ( + Op.FullyConnected, + fc_attrs, + None, + TOSA_IFM_WEIGHTS_BIAS_INDICES, + ), # TODO TosaOp.MATMUL: TosaOp.MAX_POOL2D: (Op.MaxPool, pool_attrs, None, TOSA_IFM_INDICES), - # TODO TosaOp.TRANSPOSE_CONV2D: (Op.Conv2DBackpropInput, transpose_conv_attrs, conv_quant_info) + # TODO TosaOp.TRANSPOSE_CONV2D: (Op.Conv2DBackpropInput, transpose_conv_attrs, None) TosaOp.CLAMP: (Op.Clamp, clamp_attrs, None, TOSA_IFM_INDICES), - TosaOp.RELUN: (Op.ReluN, relun_attrs, None, TOSA_IFM_INDICES), + # TODO: BUG: No longer a relu - presumably a clamp - TosaOp.RELUN: (Op.ReluN, relun_attrs, None, TOSA_IFM_INDICES), # TODO TosaOp.SIGMOID # TODO TosaOp.TANH TosaOp.ADD: (Op.Add, None, None, TOSA_IFM_IFM2_INDICES), @@ -299,15 +305,17 @@ tosa_operator_map = { TosaOp.CONCAT: (Op.Concat, axis_attrs, None, TOSA_CONCAT_INDICES), # TODO Is the padding intended to be dynamic input, TOSA spec state it as attribute # Handled as for TFLite for now - TosaOp.PAD: (Op.Pad, None, pad_quant_info, TOSA_IFM_INDICES), + TosaOp.PAD: (Op.Pad, None, None, TOSA_IFM_INDICES), TosaOp.RESHAPE: (Op.Reshape, reshape_attrs, None, TOSA_IFM_INDICES), # TODO TosaOp.REVERSE TosaOp.SLICE: (Op.SplitSliceRead, slice_attrs, None, TOSA_IFM_INDICES), # TODO TosaOp.TILE TosaOp.TRANSPOSE: ( Op.Transpose, + transpose_attrs, None, - None, + # TODO: why is this IFM2 indices but then overridden to TOSA_IFM_INDICES in _reader? + # TOSA_IFM_IFM2_INDICES, TOSA_IFM_IFM2_INDICES, ), # TODO Is the perms intended to be dynamic input, TOSA spec state it as attribute # TODO TosaOp.GATHER diff --git a/ethosu/vela/tosa_reader.py b/ethosu/vela/tosa_reader.py index 56e0b1c..56af59d 100644 --- a/ethosu/vela/tosa_reader.py +++ b/ethosu/vela/tosa_reader.py @@ -1,4 +1,4 @@ -# SPDX-FileCopyrightText: Copyright 2021-2022 Arm Limited and/or its affiliates <open-source-office@arm.com> +# SPDX-FileCopyrightText: Copyright 2021-2023 Arm Limited and/or its affiliates <open-source-office@arm.com> # # SPDX-License-Identifier: Apache-2.0 # @@ -40,7 +40,6 @@ from .tosa.Op import Op as TosaOp from .tosa.TosaGraph import TosaGraph as TG from .tosa_mapping import datatype_map from .tosa_mapping import datatype_map_numpy -from .tosa_mapping import TOSA_IFM_INDICES from .tosa_mapping import tosa_operator_map from .tosa_mapping import unsupported_tosa_operators @@ -94,30 +93,30 @@ class TosaSubgraph: op_code = op_data.Op() if op_code in unsupported_tosa_operators: print("Unsupported Operator", op_code) + for opname in dir(TosaOp): + if op_code == getattr(TosaOp, opname): + print(f" {opname}") return op_type, attr_serializer, quant_serializer, indices = tosa_operator_map[op_code] inputs = [] outputs = [] for idx in range(op_data.InputsLength()): - input_tens = self.get_tensor_by_name(decode_str(op_data.Inputs(idx))) + input = decode_str(op_data.Inputs(idx)) + input_tens = self.get_tensor_by_name(input) inputs.append(input_tens) + if input_tens is None: + print(f"could not find named input tensor {input}::{input_tens}") assert input_tens is not None for idx in range(op_data.OutputsLength()): - output_tens = self.get_tensor_by_name(decode_str(op_data.Outputs(idx))) + output = decode_str(op_data.Outputs(idx)) + output_tens = self.get_tensor_by_name(output) outputs.append(output_tens) + if output_tens is None: + print(f"could not find named output tensor {output}::{output_tens}") assert output_tens is not None - # Permutation attribute for TRANSPOSE is an input tensor in TOSA - # TODO In order to optimise Depthwise spawning from TFLite Support for removing - # Transpose of constant data. - # Moving permutation to an attribute, to match internal graph representation for now - perms = None - if op_code == TosaOp.TRANSPOSE: - perms = inputs.pop(1) - indices = TOSA_IFM_INDICES - name = "unknown_op_name" if len(outputs): name = outputs[0].name @@ -189,27 +188,21 @@ class TosaSubgraph: if op.type.is_depthwise_conv2d_op(): op.attrs["depth_multiplier"] = op.weights.shape[3] if op.type == Op.SplitSliceRead: - op.read_offsets[0] = Shape4D.from_list(list(op.attrs["begin"]), 0) + op.read_offsets[0] = Shape4D.from_list(list(op.attrs["start"]), 0) op.read_shapes[0] = op.attrs["size"] - elif op.type == Op.Transpose: - op.attrs["perms"] = perms.values - - if quant_serializer is not None: - quant_info = quant_serializer.deserialize(op_data) - # TODO tensor zero points currently set here # zero points part of Rescale operation, handled in tosa_graph_optimizer - if "input_zp" in quant_info: - self.set_tensor_zp(op.ifm, quant_info["input_zp"]) - if "weight_zp" in quant_info: - self.set_tensor_zp(op.weights, quant_info["weight_zp"]) - if "output_zp" in quant_info: - self.set_tensor_zp(op.ofm, quant_info["output_zp"]) - if "a_zp" in quant_info: - self.set_tensor_zp(op.ifm, quant_info["a_zp"]) - if "b_zp" in quant_info: - self.set_tensor_zp(op.ifm2, quant_info["b_zp"]) + if "input_zp" in op.attrs: + self.set_tensor_zp(op.ifm, op.attrs["input_zp"]) + if "weight_zp" in op.attrs: + self.set_tensor_zp(op.weights, op.attrs["weight_zp"]) + if "output_zp" in op.attrs: + self.set_tensor_zp(op.ofm, op.attrs["output_zp"]) + if "a_zp" in op.attrs: + self.set_tensor_zp(op.ifm, op.attrs["a_zp"]) + if "b_zp" in op.attrs: + self.set_tensor_zp(op.ifm2, op.attrs["b_zp"]) def parse_tensor(self, tens_data): name = decode_str(tens_data.Name()) @@ -260,7 +253,6 @@ class TosaSubgraph: class TosaGraph: def __init__(self, filename, batch_size, feed_dict, output_node_names, initialisation_nodes): - self.op_times = {} if batch_size is None: batch_size = 1 @@ -278,11 +270,15 @@ class TosaGraph: parsing_step = "parsing version" self.check_version(tosa_graph) + parsing_step = "parsing single main region" + assert 1 == tosa_graph.RegionsLength() + assert b"main" == tosa_graph.Regions(0).Name() + parsing_step = "parsing blocks length" self.subgraphs = [] - for b_idx in range(tosa_graph.BlocksLength()): + for b_idx in range(tosa_graph.Regions(0).BlocksLength()): parsing_step = f"parsing block {b_idx}" - self.subgraphs.append(TosaSubgraph(self, tosa_graph.Blocks(b_idx))) + self.subgraphs.append(TosaSubgraph(self, tosa_graph.Regions(0).Blocks(b_idx))) self.nng = Graph(self.name, self.batch_size) for tosa_sg in self.subgraphs: @@ -297,8 +293,8 @@ class TosaGraph: def check_version(self, tosa_graph): version = tosa_graph.Version() - version_str = f"{version._major()}.{version._minor()}.{version._patch()}" - if version_str != "0.22.0": + version_str = f"{version._Major()}.{version._Minor()}.{version._Patch()}" + if version_str != "0.80.0": print(f"Unsupported TOSA version: {version_str}") assert False |