Moving Vela to use TOSA v0.80.0 specification

 * Using serialization_lib main branch to update statically copied
   files sha 5f920211ac23393a7b98a0d358bfbfc3232d5c8f (v0.80.0)
 * All files within the ethosu/vela/tosa are copied from that revision
 * Note: hope to move to serialization_lib as a pip module in future

 * Modified the ethosu/vela/{tosa_mapping,tosa_reader}.py to use
   v0.80.0 TOSA FlatBuffers implementation
 * These are the additional changes made to support this new version,
   with changes in the format of the FlatBuffers file and where various
   values are stored. Either changing from input to attribute, or
   moving to different attributes.

Signed-off-by: Rob Elliott <robert.elliott@arm.com>
Change-Id: I5e1fcc2a9964148619be3477adf1e88e84cbae2d

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