Remove quantinfo types

Any needed information has been moved into the attributes for each operator.

This aligns with the structure of the attributes in the TOSA
specification, and generally simplifies the code.

Change-Id: I8243e91b09de1a9115f8af09c5e7def7e8f2866b
Signed-off-by: Eric Kunze <eric.kunze@arm.com>

12 files changed, 206 insertions, 183 deletions

diff --git a/python/serializer/tosa_serializer.py b/python/serializer/tosa_serializer.py
index 4d7d7bf..10372e4 100644
--- a/python/serializer/tosa_serializer.py
+++ b/python/serializer/tosa_serializer.py
@@ -30,7 +30,7 @@ import tosa.Op as TosaOp
 
 # Keep version number in sync with the version default value with schema/tosa.fbs
 TOSA_VERSION_MAJOR = 0
-TOSA_VERSION_MINOR = 25
+TOSA_VERSION_MINOR = 30
 TOSA_VERSION_PATCH = 0
 TOSA_VERSION_DRAFT = True
 TOSA_VERSION = [
@@ -141,7 +141,7 @@ class TosaSerializerAttribute(TosaSerializerUnion):
     def __init__(self):
         super().__init__()
 
-    def PoolAttribute(self, kernel, stride, pad):
+    def PoolAttribute(self, kernel, stride, pad, input_zp, output_zp):
         from tosa import PoolAttribute as a, Attribute
 
         self.utype = Attribute.Attribute().PoolAttribute
@@ -150,8 +150,10 @@ class TosaSerializerAttribute(TosaSerializerUnion):
         self.intvecs.append((a.AddPad, pad))
         self.intvecs.append((a.AddKernel, kernel))
         self.intvecs.append((a.AddStride, stride))
+        self.ints.append((a.AddInputZp, input_zp))
+        self.ints.append((a.AddOutputZp, output_zp))
 
-    def ConvAttribute(self, pad, stride, dilation):
+    def ConvAttribute(self, pad, stride, dilation, input_zp, weight_zp):
         from tosa import ConvAttribute as a, Attribute
 
         self.utype = Attribute.Attribute().ConvAttribute
@@ -160,8 +162,10 @@ class TosaSerializerAttribute(TosaSerializerUnion):
         self.intvecs.append((a.AddPad, pad))
         self.intvecs.append((a.AddStride, stride))
         self.intvecs.append((a.AddDilation, dilation))
+        self.ints.append((a.AddInputZp, input_zp))
+        self.ints.append((a.AddWeightZp, weight_zp))
 
-    def TransposeConvAttribute(self, outpad, stride, output_shape):
+    def TransposeConvAttribute(self, outpad, stride, output_shape, input_zp, weight_zp):
         from tosa import TransposeConvAttribute as a, Attribute
 
         self.utype = Attribute.Attribute().TransposeConvAttribute
@@ -170,6 +174,8 @@ class TosaSerializerAttribute(TosaSerializerUnion):
         self.intvecs.append((a.AddOutPad, outpad))
         self.intvecs.append((a.AddStride, stride))
         self.intvecs.append((a.AddOutputShape, output_shape))
+        self.ints.append((a.AddInputZp, input_zp))
+        self.ints.append((a.AddWeightZp, weight_zp))
 
     def PadAttribute(self, padding, pad_const_int, pad_const_fp):
         from tosa import PadAttribute as a, Attribute
@@ -311,43 +317,32 @@ class TosaSerializerAttribute(TosaSerializerUnion):
 
         self.intvecs.append((a.AddTable, table))
 
+    def MatMulAttribute(self, A_zp, B_zp):
+        from tosa import MatMulAttribute as a, Attribute
 
-class TosaSerializerQuantInfo(TosaSerializerUnion):
-    """This class handles encapsulating all of the enumerated types for quantinfo"""
-
-    def __init__(self):
-        super().__init__()
-
-    def ConvQuantInfo(self, input_zp, weight_zp):
-        from tosa import ConvQuantInfo as q, QuantInfo
+        self.utype = Attribute.Attribute().MatMulAttribute
+        self.optFcns = (a.Start, a.End)
 
-        self.utype = QuantInfo.QuantInfo().ConvQuantInfo
-        self.optFcns = (q.Start, q.End)
-        self.ints.append((q.AddInputZp, input_zp))
-        self.ints.append((q.AddWeightZp, weight_zp))
+        self.ints.append((a.AddAZp, A_zp))
+        self.ints.append((a.AddBZp, B_zp))
 
-    def UnaryQuantInfo(self, input_zp, output_zp):
-        from tosa import UnaryQuantInfo as q, QuantInfo
+    def FullyConnectedAttribute(self, input_zp, weight_zp):
+        from tosa import FullyConnectedAttribute as a, Attribute
 
-        self.utype = QuantInfo.QuantInfo().UnaryQuantInfo
-        self.optFcns = (q.Start, q.End)
-        self.ints.append((q.AddInputZp, input_zp))
-        self.ints.append((q.AddOutputZp, output_zp))
+        self.utype = Attribute.Attribute().FullyConnectedAttribute
+        self.optFcns = (a.Start, a.End)
 
-    def MatMulQuantInfo(self, a_zp, b_zp):
-        from tosa import MatMulQuantInfo as q, QuantInfo
+        self.ints.append((a.AddInputZp, input_zp))
+        self.ints.append((a.AddWeightZp, weight_zp))
 
-        self.utype = QuantInfo.QuantInfo().MatMulQuantInfo
-        self.optFcns = (q.Start, q.End)
-        self.ints.append((q.AddAZp, a_zp))
-        self.ints.append((q.AddBZp, b_zp))
+    def NegateAttribute(self, input1_zp, output_zp):
+        from tosa import NegateAttribute as a, Attribute
 
-    def PadQuantInfo(self, input_zp):
-        from tosa import PadQuantInfo as q, QuantInfo
+        self.utype = Attribute.Attribute().NegateAttribute
+        self.optFcns = (a.Start, a.End)
 
-        self.utype = QuantInfo.QuantInfo().PadQuantInfo
-        self.optFcns = (q.Start, q.End)
-        self.ints.append((q.AddInputZp, input_zp))
+        self.ints.append((a.AddInput1Zp, input1_zp))
+        self.ints.append((a.AddOutputZp, output_zp))
 
 
 class TosaSerializerTensor:
@@ -467,12 +462,11 @@ class TosaSerializerTensor:
 
 
 class TosaSerializerOperator:
-    def __init__(self, op, inputs, outputs, attributes=None, quantInfo=None):
+    def __init__(self, op, inputs, outputs, attributes=None):
         self.op = op
         self.attributes = attributes
         self.inputs = TosaSerializer.toList(inputs)
         self.outputs = TosaSerializer.toList(outputs)
-        self.quantInfo = quantInfo
 
     def __str__(self):
         str = "Op {}\n----\n".format(self.op)
@@ -491,13 +485,10 @@ class TosaSerializerOperator:
         fb_outputs = TosaSerializer.serializeStrVec(
             builder, self.outputs, TosaOperator.StartOutputsVector
         )
-        # Need to serialize quant_info and attributes enums still
+        # Need to serialize attributes enums still
         if self.attributes is not None:
             fb_attributes = self.attributes.serialize(builder)
 
-        if self.quantInfo is not None:
-            fb_qinfo = self.quantInfo.serialize(builder)
-
         TosaOperator.Start(builder)
         TosaOperator.AddOp(builder, self.op)
         TosaOperator.AddInputs(builder, fb_inputs)
@@ -505,9 +496,6 @@ class TosaSerializerOperator:
         if self.attributes is not None:
             TosaOperator.AddAttributeType(builder, self.attributes.utype)
             TosaOperator.AddAttribute(builder, fb_attributes)
-        if self.quantInfo is not None:
-            TosaOperator.AddQuantInfoType(builder, self.quantInfo.utype)
-            TosaOperator.AddQuantInfo(builder, fb_qinfo)
 
         return TosaOperator.End(builder)
 
@@ -544,10 +532,8 @@ class TosaSerializerBasicBlock:
     def addOutput(self, name):
         self.outputs.append(name)
 
-    def addOperator(self, op, inputs, outputs, attributes=None, quant_info=None):
-        self.operators.append(
-            TosaSerializerOperator(op, inputs, outputs, attributes, quant_info)
-        )
+    def addOperator(self, op, inputs, outputs, attributes=None):
+        self.operators.append(TosaSerializerOperator(op, inputs, outputs, attributes))
 
     def serialize(self, builder):
         fb_name = builder.CreateString(self.name)
@@ -671,13 +657,16 @@ class TosaSerializer:
         self.currBasicBlock.addOutput(name)
         return tens
 
-    def addOperator(self, op, inputs, outputs, attributes=None, quant_info=None):
+    def addOperator(self, op, inputs, outputs, attributes=None):
 
         if op == TosaOp.Op().CONST:
             raise Exception("Use addConstTensor() to add CONST ops")
 
         return self.currBasicBlock.addOperator(
-            op, inputs, outputs, attributes, quant_info
+            op,
+            inputs,
+            outputs,
+            attributes,
         )
 
     def setExpectedReturnCode(self, val, fail, desc=""):
@@ -861,21 +850,48 @@ class TosaSerializer:
             ConvAttribute.StartDilationVector = (
                 ConvAttribute.ConvAttributeStartDilationVector
             )
+            ConvAttribute.AddInputZp = ConvAttribute.ConvAttributeAddInputZp
+            ConvAttribute.AddWeightZp = ConvAttribute.ConvAttributeAddWeightZp
             ConvAttribute.End = ConvAttribute.ConvAttributeEnd
-        from tosa import ConvQuantInfo
-
-        if not hasattr(ConvQuantInfo, "Start"):
-            ConvQuantInfo.Start = ConvQuantInfo.ConvQuantInfoStart
-            ConvQuantInfo.AddInputZp = ConvQuantInfo.ConvQuantInfoAddInputZp
-            ConvQuantInfo.AddWeightZp = ConvQuantInfo.ConvQuantInfoAddWeightZp
-            ConvQuantInfo.End = ConvQuantInfo.ConvQuantInfoEnd
-        from tosa import MatMulQuantInfo
-
-        if not hasattr(MatMulQuantInfo, "Start"):
-            MatMulQuantInfo.Start = MatMulQuantInfo.MatMulQuantInfoStart
-            MatMulQuantInfo.AddAZp = MatMulQuantInfo.MatMulQuantInfoAddAZp
-            MatMulQuantInfo.AddBZp = MatMulQuantInfo.MatMulQuantInfoAddBZp
-            MatMulQuantInfo.End = MatMulQuantInfo.MatMulQuantInfoEnd
+        from tosa import FullyConnectedAttribute
+
+        if not hasattr(FullyConnectedAttribute, "Start"):
+            FullyConnectedAttribute.Start = (
+                FullyConnectedAttribute.FullyConnectedAttributeStart
+            )
+            FullyConnectedAttribute.AddInputZp = (
+                FullyConnectedAttribute.FullyConnectedAttributeAddInputZp
+            )
+            FullyConnectedAttribute.AddWeightZp = (
+                FullyConnectedAttribute.FullyConnectedAttributeAddWeightZp
+            )
+            FullyConnectedAttribute.End = (
+                FullyConnectedAttribute.FullyConnectedAttributeEnd
+            )
+        from tosa import MatMulAttribute
+
+        if not hasattr(MatMulAttribute, "Start"):
+            MatMulAttribute.Start = MatMulAttribute.MatMulAttributeStart
+            MatMulAttribute.AddAZp = MatMulAttribute.MatMulAttributeAddAZp
+            MatMulAttribute.AddBZp = MatMulAttribute.MatMulAttributeAddBZp
+            MatMulAttribute.End = MatMulAttribute.MatMulAttributeEnd
+        from tosa import PoolAttribute
+
+        if not hasattr(PoolAttribute, "Start"):
+            PoolAttribute.Start = PoolAttribute.PoolAttributeStart
+            PoolAttribute.AddPad = PoolAttribute.PoolAttributeAddPad
+            PoolAttribute.StartPadVector = PoolAttribute.PoolAttributeStartPadVector
+            PoolAttribute.AddKernel = PoolAttribute.PoolAttributeAddKernel
+            PoolAttribute.StartKernelVector = (
+                PoolAttribute.PoolAttributeStartKernelVector
+            )
+            PoolAttribute.AddStride = PoolAttribute.PoolAttributeAddStride
+            PoolAttribute.StartStrideVector = (
+                PoolAttribute.PoolAttributeStartStrideVector
+            )
+            PoolAttribute.AddInputZp = PoolAttribute.PoolAttributeAddInputZp
+            PoolAttribute.AddOutputZp = PoolAttribute.PoolAttributeAddOutputZp
+            PoolAttribute.End = PoolAttribute.PoolAttributeEnd
         from tosa import MulAttribute
 
         if not hasattr(MulAttribute, "Start"):
@@ -893,12 +909,6 @@ class TosaSerializer:
             PadAttribute.AddPadConstInt = PadAttribute.PadAttributeAddPadConstInt
             PadAttribute.AddPadConstFp = PadAttribute.PadAttributeAddPadConstFp
             PadAttribute.End = PadAttribute.PadAttributeEnd
-        from tosa import PadQuantInfo
-
-        if not hasattr(PadQuantInfo, "Start"):
-            PadQuantInfo.Start = PadQuantInfo.PadQuantInfoStart
-            PadQuantInfo.AddInputZp = PadQuantInfo.PadQuantInfoAddInputZp
-            PadQuantInfo.End = PadQuantInfo.PadQuantInfoEnd
         from tosa import PoolAttribute
 
         if not hasattr(PoolAttribute, "Start"):
@@ -913,6 +923,8 @@ class TosaSerializer:
             PoolAttribute.StartStrideVector = (
                 PoolAttribute.PoolAttributeStartStrideVector
             )
+            PoolAttribute.AddInputZp = PoolAttribute.PoolAttributeAddInputZp
+            PoolAttribute.AddOutputZp = PoolAttribute.PoolAttributeAddOutputZp
             PoolAttribute.End = PoolAttribute.PoolAttributeEnd
         from tosa import RescaleAttribute
 
@@ -1048,8 +1060,6 @@ class TosaSerializer:
             TosaOperator.StartOutputsVector = (
                 TosaOperator.TosaOperatorStartOutputsVector
             )
-            TosaOperator.AddQuantInfoType = TosaOperator.TosaOperatorAddQuantInfoType
-            TosaOperator.AddQuantInfo = TosaOperator.TosaOperatorAddQuantInfo
             TosaOperator.End = TosaOperator.TosaOperatorEnd
         from tosa import TosaTensor
 
@@ -1095,16 +1105,15 @@ class TosaSerializer:
             TransposeConvAttribute.StartOutputShapeVector = (
                 TransposeConvAttribute.TransposeConvAttributeStartOutputShapeVector
             )
+            TransposeConvAttribute.AddInputZp = (
+                TransposeConvAttribute.TransposeConvAttributeAddInputZp
+            )
+            TransposeConvAttribute.AddWeightZp = (
+                TransposeConvAttribute.TransposeConvAttributeAddWeightZp
+            )
             TransposeConvAttribute.End = (
                 TransposeConvAttribute.TransposeConvAttributeEnd
             )
-        from tosa import UnaryQuantInfo
-
-        if not hasattr(UnaryQuantInfo, "Start"):
-            UnaryQuantInfo.Start = UnaryQuantInfo.UnaryQuantInfoStart
-            UnaryQuantInfo.AddInputZp = UnaryQuantInfo.UnaryQuantInfoAddInputZp
-            UnaryQuantInfo.AddOutputZp = UnaryQuantInfo.UnaryQuantInfoAddOutputZp
-            UnaryQuantInfo.End = UnaryQuantInfo.UnaryQuantInfoEnd
         from tosa import Version
 
         if not hasattr(Version, "Start"):
@@ -1114,6 +1123,35 @@ class TosaSerializer:
             Version.Add_patch = Version.VersionAdd_patch
             Version.Add_draft = Version.VersionAdd_draft
             Version.End = Version.VersionEnd
+        from tosa import MatMulAttribute
+
+        if not hasattr(MatMulAttribute, "Start"):
+            MatMulAttribute.Start = MatMulAttribute.MatMulAttributeStart
+            MatMulAttribute.AddAZp = MatMulAttribute.MatMulAttributeAddAZp
+            MatMulAttribute.AddBZp = MatMulAttribute.MatMulAttributeAddBZp
+            MatMulAttribute.End = MatMulAttribute.MatMulAttributeEnd
+        from tosa import FullyConnectedAttribute
+
+        if not hasattr(FullyConnectedAttribute, "Start"):
+            FullyConnectedAttribute.Start = (
+                FullyConnectedAttribute.FullyConnectedAttributeStart
+            )
+            FullyConnectedAttribute.AddInputZp = (
+                FullyConnectedAttribute.FullyConnectedAttributeAddInputZp
+            )
+            FullyConnectedAttribute.AddWeightZp = (
+                FullyConnectedAttribute.FullyConnectedAttributeAddWeightZp
+            )
+            FullyConnectedAttribute.End = (
+                FullyConnectedAttribute.FullyConnectedAttributeEnd
+            )
+        from tosa import NegateAttribute
+
+        if not hasattr(NegateAttribute, "Start"):
+            NegateAttribute.Start = NegateAttribute.NegateAttributeStart
+            NegateAttribute.AddInput1Zp = NegateAttribute.NegateAttributeAddInput1Zp
+            NegateAttribute.AddOutputZp = NegateAttribute.NegateAttributeAddOutputZp
+            NegateAttribute.End = NegateAttribute.NegateAttributeEnd
         from tosa import WhileLoopAttribute
 
         if not hasattr(WhileLoopAttribute, "Start"):
diff --git a/python/tosa/Attribute.py b/python/tosa/Attribute.py
index f0307af..166de8e 100644
--- a/python/tosa/Attribute.py
+++ b/python/tosa/Attribute.py
@@ -21,4 +21,7 @@ class Attribute(object):
     WhileLoopAttribute = 15
     TransposeAttribute = 16
     TableAttribute = 17
+    MatMulAttribute = 18
+    FullyConnectedAttribute = 19
+    NegateAttribute = 20
 
diff --git a/python/tosa/ConvAttribute.py b/python/tosa/ConvAttribute.py
index 72a24ce..8244ea5 100644
--- a/python/tosa/ConvAttribute.py
+++ b/python/tosa/ConvAttribute.py
@@ -105,11 +105,27 @@ class ConvAttribute(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
         return o == 0
 
-def ConvAttributeStart(builder): builder.StartObject(3)
+    # 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 ConvAttributeAddPad(builder, pad): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pad), 0)
 def ConvAttributeStartPadVector(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 ConvAttributeAddInputZp(builder, inputZp): builder.PrependInt32Slot(3, inputZp, 0)
+def ConvAttributeAddWeightZp(builder, weightZp): builder.PrependInt32Slot(4, weightZp, 0)
 def ConvAttributeEnd(builder): return builder.EndObject()
diff --git a/python/tosa/ConvQuantInfo.py b/python/tosa/FullyConnectedAttribute.py
index 7902c67..62b480d 100644
--- a/python/tosa/ConvQuantInfo.py
+++ b/python/tosa/FullyConnectedAttribute.py
@@ -6,39 +6,39 @@ import flatbuffers
 from flatbuffers.compat import import_numpy
 np = import_numpy()
 
-class ConvQuantInfo(object):
+class FullyConnectedAttribute(object):
     __slots__ = ['_tab']
 
     @classmethod
-    def GetRootAsConvQuantInfo(cls, buf, offset):
+    def GetRootAsFullyConnectedAttribute(cls, buf, offset):
         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
-        x = ConvQuantInfo()
+        x = FullyConnectedAttribute()
         x.Init(buf, n + offset)
         return x
 
     @classmethod
-    def ConvQuantInfoBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+    def FullyConnectedAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
         return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed)
 
-    # ConvQuantInfo
+    # FullyConnectedAttribute
     def Init(self, buf, pos):
         self._tab = flatbuffers.table.Table(buf, pos)
 
-    # ConvQuantInfo
+    # 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
 
-    # ConvQuantInfo
+    # 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 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()
+def FullyConnectedAttributeStart(builder): builder.StartObject(2)
+def FullyConnectedAttributeAddInputZp(builder, inputZp): builder.PrependInt32Slot(0, inputZp, 0)
+def FullyConnectedAttributeAddWeightZp(builder, weightZp): builder.PrependInt32Slot(1, weightZp, 0)
+def FullyConnectedAttributeEnd(builder): return builder.EndObject()
diff --git a/python/tosa/MatMulQuantInfo.py b/python/tosa/MatMulAttribute.py
index 457da66..601f13f 100644
--- a/python/tosa/MatMulQuantInfo.py
+++ b/python/tosa/MatMulAttribute.py
@@ -6,39 +6,39 @@ import flatbuffers
 from flatbuffers.compat import import_numpy
 np = import_numpy()
 
-class MatMulQuantInfo(object):
+class MatMulAttribute(object):
     __slots__ = ['_tab']
 
     @classmethod
-    def GetRootAsMatMulQuantInfo(cls, buf, offset):
+    def GetRootAsMatMulAttribute(cls, buf, offset):
         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
-        x = MatMulQuantInfo()
+        x = MatMulAttribute()
         x.Init(buf, n + offset)
         return x
 
     @classmethod
-    def MatMulQuantInfoBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+    def MatMulAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
         return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed)
 
-    # MatMulQuantInfo
+    # MatMulAttribute
     def Init(self, buf, pos):
         self._tab = flatbuffers.table.Table(buf, pos)
 
-    # MatMulQuantInfo
+    # 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
 
-    # MatMulQuantInfo
+    # 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 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()
+def MatMulAttributeStart(builder): builder.StartObject(2)
+def MatMulAttributeAddAZp(builder, aZp): builder.PrependInt32Slot(0, aZp, 0)
+def MatMulAttributeAddBZp(builder, bZp): builder.PrependInt32Slot(1, bZp, 0)
+def MatMulAttributeEnd(builder): return builder.EndObject()
diff --git a/python/tosa/UnaryQuantInfo.py b/python/tosa/NegateAttribute.py
index 648fc34..24a57dc 100644
--- a/python/tosa/UnaryQuantInfo.py
+++ b/python/tosa/NegateAttribute.py
@@ -6,39 +6,39 @@ import flatbuffers
 from flatbuffers.compat import import_numpy
 np = import_numpy()
 
-class UnaryQuantInfo(object):
+class NegateAttribute(object):
     __slots__ = ['_tab']
 
     @classmethod
-    def GetRootAsUnaryQuantInfo(cls, buf, offset):
+    def GetRootAsNegateAttribute(cls, buf, offset):
         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
-        x = UnaryQuantInfo()
+        x = NegateAttribute()
         x.Init(buf, n + offset)
         return x
 
     @classmethod
-    def UnaryQuantInfoBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+    def NegateAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
         return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed)
 
-    # UnaryQuantInfo
+    # NegateAttribute
     def Init(self, buf, pos):
         self._tab = flatbuffers.table.Table(buf, pos)
 
-    # UnaryQuantInfo
-    def InputZp(self):
+    # 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
 
-    # UnaryQuantInfo
+    # 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 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()
+def NegateAttributeStart(builder): builder.StartObject(2)
+def NegateAttributeAddInput1Zp(builder, input1Zp): builder.PrependInt32Slot(0, input1Zp, 0)
+def NegateAttributeAddOutputZp(builder, outputZp): builder.PrependInt32Slot(1, outputZp, 0)
+def NegateAttributeEnd(builder): return builder.EndObject()
diff --git a/python/tosa/PadQuantInfo.py b/python/tosa/PadQuantInfo.py
deleted file mode 100644
index c07db07..0000000
--- a/python/tosa/PadQuantInfo.py
+++ /dev/null
@@ -1,36 +0,0 @@
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: tosa
-
-import flatbuffers
-from flatbuffers.compat import import_numpy
-np = import_numpy()
-
-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
-
-    @classmethod
-    def PadQuantInfoBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
-        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed)
-
-    # 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/python/tosa/PoolAttribute.py b/python/tosa/PoolAttribute.py
index f2c12cf..8b6903e 100644
--- a/python/tosa/PoolAttribute.py
+++ b/python/tosa/PoolAttribute.py
@@ -105,11 +105,27 @@ class PoolAttribute(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
         return o == 0
 
-def PoolAttributeStart(builder): builder.StartObject(3)
+    # 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
+
+def PoolAttributeStart(builder): builder.StartObject(5)
 def PoolAttributeAddPad(builder, pad): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pad), 0)
 def PoolAttributeStartPadVector(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 PoolAttributeAddInputZp(builder, inputZp): builder.PrependInt32Slot(3, inputZp, 0)
+def PoolAttributeAddOutputZp(builder, outputZp): builder.PrependInt32Slot(4, outputZp, 0)
 def PoolAttributeEnd(builder): return builder.EndObject()
diff --git a/python/tosa/QuantInfo.py b/python/tosa/QuantInfo.py
deleted file mode 100644
index ffdfd32..0000000
--- a/python/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/python/tosa/TosaOperator.py b/python/tosa/TosaOperator.py
index 040c2dc..fd11f76 100644
--- a/python/tosa/TosaOperator.py
+++ b/python/tosa/TosaOperator.py
@@ -88,24 +88,7 @@ class TosaOperator(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
         return o == 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
-
-    # 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(7)
+def TosaOperatorStart(builder): builder.StartObject(5)
 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)
@@ -113,6 +96,4 @@ def TosaOperatorAddInputs(builder, inputs): builder.PrependUOffsetTRelativeSlot(
 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()
diff --git a/python/tosa/TransposeConvAttribute.py b/python/tosa/TransposeConvAttribute.py
index 2a675a0..8ca5ba7 100644
--- a/python/tosa/TransposeConvAttribute.py
+++ b/python/tosa/TransposeConvAttribute.py
@@ -105,11 +105,27 @@ class TransposeConvAttribute(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
         return o == 0
 
-def TransposeConvAttributeStart(builder): builder.StartObject(3)
+    # TransposeConvAttribute
+    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
+
+    # TransposeConvAttribute
+    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 TransposeConvAttributeStart(builder): builder.StartObject(5)
 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 TransposeConvAttributeAddOutputShape(builder, outputShape): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(outputShape), 0)
 def TransposeConvAttributeStartOutputShapeVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def TransposeConvAttributeAddInputZp(builder, inputZp): builder.PrependInt32Slot(3, inputZp, 0)
+def TransposeConvAttributeAddWeightZp(builder, weightZp): builder.PrependInt32Slot(4, weightZp, 0)
 def TransposeConvAttributeEnd(builder): return builder.EndObject()
diff --git a/python/tosa/Version.py b/python/tosa/Version.py
index 27dea53..bdac948 100644
--- a/python/tosa/Version.py
+++ b/python/tosa/Version.py
@@ -36,7 +36,7 @@ class Version(object):
         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 25
+        return 30
 
     # Version
     def _patch(self):
@@ -54,7 +54,7 @@ class Version(object):
 
 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, 25)
+def VersionAdd_minor(builder, Minor): builder.PrependInt32Slot(1, Minor, 30)
 def VersionAdd_patch(builder, Patch): builder.PrependInt32Slot(2, Patch, 0)
 def VersionAdd_draft(builder, Draft): builder.PrependBoolSlot(3, Draft, 1)
 def VersionEnd(builder): return builder.EndObject()