[serialization_lib] Fix Clamp and Pad Attributes

This patch implements following changes to attribute fields:
- PadAttribute: delete padding field, replace pad_const_int
	and pad_const_fp fields by pad_const, a field of
	ubyte array
- ClampAttribute: replace min_int, max_int, min_fp and max_fp
	fields by min_val and max_val, fields of ubyte arrays
- RescaleAttribute: delete multiplier and shift fields

Signed-off-by: Tai Ly <tai.ly@arm.com>
Change-Id: I5b075d29677cffca9ff2292708141d48410e7e72

7 files changed, 121 insertions, 401 deletions

diff --git a/include/attribute.def b/include/attribute.def
index b6ff3c2..2176f47 100644
--- a/include/attribute.def
+++ b/include/attribute.def
@@ -1,5 +1,5 @@
 
-// Copyright (c) 2020-2023, ARM Limited.
+// Copyright (c) 2020-2024, ARM Limited.
 //
 //    Licensed under the Apache License, Version 2.0 (the "License");
 //    you may not use this file except in compliance with the License.
@@ -50,10 +50,8 @@ DEF_ATTRIBUTE(TransposeConv, 6,
               int32_t, S, weight_zp,
               bool,    S, local_bound)
 
-DEF_ATTRIBUTE(Pad, 3,
-              int32_t, V, padding,
-              int32_t, S, pad_const_int,
-              float, S, pad_const_fp)
+DEF_ATTRIBUTE(Pad, 1,
+              uint8_t, V, pad_const)
 
 DEF_ATTRIBUTE(Axis, 1,
               int32_t, S, axis)
@@ -64,17 +62,13 @@ DEF_ATTRIBUTE(Resize, 4,
               int16_t, V, border,
               ResizeMode, S, mode)
 
-DEF_ATTRIBUTE(Clamp, 4,
-              int32_t, S, min_int,
-              int32_t, S, max_int,
-              float, S, min_fp,
-              float, S, max_fp)
+DEF_ATTRIBUTE(Clamp, 2,
+              uint8_t, V, min_val,
+              uint8_t, V, max_val)
 
-DEF_ATTRIBUTE(Rescale, 9,
+DEF_ATTRIBUTE(Rescale, 7,
               int32_t, S, input_zp,
               int32_t, S, output_zp,
-              int32_t, V, multiplier,
-              int32_t, V, shift,
               bool, S, scale32,
               bool, S, double_round,
               bool, S, per_channel,
diff --git a/include/tosa_generated.h b/include/tosa_generated.h
index c7a280a..64d54bc 100644
--- a/include/tosa_generated.h
+++ b/include/tosa_generated.h
@@ -984,26 +984,15 @@ inline ::flatbuffers::Offset<TransposeConvAttribute> CreateTransposeConvAttribut
 struct PadAttribute FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef PadAttributeBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
-    VT_PADDING = 4,
-    VT_PAD_CONST_INT = 6,
-    VT_PAD_CONST_FP = 8
+    VT_PAD_CONST = 4
   };
-  const ::flatbuffers::Vector<int32_t> *padding() const {
-    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_PADDING);
-  }
-  int32_t pad_const_int() const {
-    return GetField<int32_t>(VT_PAD_CONST_INT, 0);
-  }
-  const ::flatbuffers::Vector<uint8_t> *pad_const_fp() const {
-    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_PAD_CONST_FP);
+  const ::flatbuffers::Vector<uint8_t> *pad_const() const {
+    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_PAD_CONST);
   }
   bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
-           VerifyOffset(verifier, VT_PADDING) &&
-           verifier.VerifyVector(padding()) &&
-           VerifyField<int32_t>(verifier, VT_PAD_CONST_INT, 4) &&
-           VerifyOffset(verifier, VT_PAD_CONST_FP) &&
-           verifier.VerifyVector(pad_const_fp()) &&
+           VerifyOffset(verifier, VT_PAD_CONST) &&
+           verifier.VerifyVector(pad_const()) &&
            verifier.EndTable();
   }
 };
@@ -1012,14 +1001,8 @@ struct PadAttributeBuilder {
   typedef PadAttribute Table;
   ::flatbuffers::FlatBufferBuilder &fbb_;
   ::flatbuffers::uoffset_t start_;
-  void add_padding(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> padding) {
-    fbb_.AddOffset(PadAttribute::VT_PADDING, padding);
-  }
-  void add_pad_const_int(int32_t pad_const_int) {
-    fbb_.AddElement<int32_t>(PadAttribute::VT_PAD_CONST_INT, pad_const_int, 0);
-  }
-  void add_pad_const_fp(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> pad_const_fp) {
-    fbb_.AddOffset(PadAttribute::VT_PAD_CONST_FP, pad_const_fp);
+  void add_pad_const(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> pad_const) {
+    fbb_.AddOffset(PadAttribute::VT_PAD_CONST, pad_const);
   }
   explicit PadAttributeBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
@@ -1034,29 +1017,20 @@ struct PadAttributeBuilder {
 
 inline ::flatbuffers::Offset<PadAttribute> CreatePadAttribute(
     ::flatbuffers::FlatBufferBuilder &_fbb,
-    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> padding = 0,
-    int32_t pad_const_int = 0,
-    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> pad_const_fp = 0) {
+    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> pad_const = 0) {
   PadAttributeBuilder builder_(_fbb);
-  builder_.add_pad_const_fp(pad_const_fp);
-  builder_.add_pad_const_int(pad_const_int);
-  builder_.add_padding(padding);
+  builder_.add_pad_const(pad_const);
   return builder_.Finish();
 }
 
 inline ::flatbuffers::Offset<PadAttribute> CreatePadAttributeDirect(
     ::flatbuffers::FlatBufferBuilder &_fbb,
-    const std::vector<int32_t> *padding = nullptr,
-    int32_t pad_const_int = 0,
-    const std::vector<uint8_t> *pad_const_fp = nullptr) {
-  auto padding__ = padding ? _fbb.CreateVector<int32_t>(*padding) : 0;
-  if (pad_const_fp) { _fbb.ForceVectorAlignment(pad_const_fp->size(), sizeof(uint8_t), 8); }
-  auto pad_const_fp__ = pad_const_fp ? _fbb.CreateVector<uint8_t>(*pad_const_fp) : 0;
+    const std::vector<uint8_t> *pad_const = nullptr) {
+  if (pad_const) { _fbb.ForceVectorAlignment(pad_const->size(), sizeof(uint8_t), 8); }
+  auto pad_const__ = pad_const ? _fbb.CreateVector<uint8_t>(*pad_const) : 0;
   return tosa::CreatePadAttribute(
       _fbb,
-      padding__,
-      pad_const_int,
-      pad_const_fp__);
+      pad_const__);
 }
 
 struct AxisAttribute FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
@@ -1194,31 +1168,21 @@ inline ::flatbuffers::Offset<ResizeAttribute> CreateResizeAttributeDirect(
 struct ClampAttribute FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef ClampAttributeBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
-    VT_MIN_INT = 4,
-    VT_MAX_INT = 6,
-    VT_MIN_FP = 8,
-    VT_MAX_FP = 10
+    VT_MIN_VAL = 4,
+    VT_MAX_VAL = 6
   };
-  int32_t min_int() const {
-    return GetField<int32_t>(VT_MIN_INT, 0);
+  const ::flatbuffers::Vector<uint8_t> *min_val() const {
+    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_MIN_VAL);
   }
-  int32_t max_int() const {
-    return GetField<int32_t>(VT_MAX_INT, 0);
-  }
-  const ::flatbuffers::Vector<uint8_t> *min_fp() const {
-    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_MIN_FP);
-  }
-  const ::flatbuffers::Vector<uint8_t> *max_fp() const {
-    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_MAX_FP);
+  const ::flatbuffers::Vector<uint8_t> *max_val() const {
+    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_MAX_VAL);
   }
   bool Verify(::flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
-           VerifyField<int32_t>(verifier, VT_MIN_INT, 4) &&
-           VerifyField<int32_t>(verifier, VT_MAX_INT, 4) &&
-           VerifyOffset(verifier, VT_MIN_FP) &&
-           verifier.VerifyVector(min_fp()) &&
-           VerifyOffset(verifier, VT_MAX_FP) &&
-           verifier.VerifyVector(max_fp()) &&
+           VerifyOffset(verifier, VT_MIN_VAL) &&
+           verifier.VerifyVector(min_val()) &&
+           VerifyOffset(verifier, VT_MAX_VAL) &&
+           verifier.VerifyVector(max_val()) &&
            verifier.EndTable();
   }
 };
@@ -1227,17 +1191,11 @@ struct ClampAttributeBuilder {
   typedef ClampAttribute Table;
   ::flatbuffers::FlatBufferBuilder &fbb_;
   ::flatbuffers::uoffset_t start_;
-  void add_min_int(int32_t min_int) {
-    fbb_.AddElement<int32_t>(ClampAttribute::VT_MIN_INT, min_int, 0);
-  }
-  void add_max_int(int32_t max_int) {
-    fbb_.AddElement<int32_t>(ClampAttribute::VT_MAX_INT, max_int, 0);
+  void add_min_val(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> min_val) {
+    fbb_.AddOffset(ClampAttribute::VT_MIN_VAL, min_val);
   }
-  void add_min_fp(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> min_fp) {
-    fbb_.AddOffset(ClampAttribute::VT_MIN_FP, min_fp);
-  }
-  void add_max_fp(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> max_fp) {
-    fbb_.AddOffset(ClampAttribute::VT_MAX_FP, max_fp);
+  void add_max_val(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> max_val) {
+    fbb_.AddOffset(ClampAttribute::VT_MAX_VAL, max_val);
   }
   explicit ClampAttributeBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
@@ -1252,34 +1210,26 @@ struct ClampAttributeBuilder {
 
 inline ::flatbuffers::Offset<ClampAttribute> CreateClampAttribute(
     ::flatbuffers::FlatBufferBuilder &_fbb,
-    int32_t min_int = 0,
-    int32_t max_int = 0,
-    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> min_fp = 0,
-    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> max_fp = 0) {
+    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> min_val = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> max_val = 0) {
   ClampAttributeBuilder builder_(_fbb);
-  builder_.add_max_fp(max_fp);
-  builder_.add_min_fp(min_fp);
-  builder_.add_max_int(max_int);
-  builder_.add_min_int(min_int);
+  builder_.add_max_val(max_val);
+  builder_.add_min_val(min_val);
   return builder_.Finish();
 }
 
 inline ::flatbuffers::Offset<ClampAttribute> CreateClampAttributeDirect(
     ::flatbuffers::FlatBufferBuilder &_fbb,
-    int32_t min_int = 0,
-    int32_t max_int = 0,
-    const std::vector<uint8_t> *min_fp = nullptr,
-    const std::vector<uint8_t> *max_fp = nullptr) {
-  if (min_fp) { _fbb.ForceVectorAlignment(min_fp->size(), sizeof(uint8_t), 8); }
-  auto min_fp__ = min_fp ? _fbb.CreateVector<uint8_t>(*min_fp) : 0;
-  if (max_fp) { _fbb.ForceVectorAlignment(max_fp->size(), sizeof(uint8_t), 8); }
-  auto max_fp__ = max_fp ? _fbb.CreateVector<uint8_t>(*max_fp) : 0;
+    const std::vector<uint8_t> *min_val = nullptr,
+    const std::vector<uint8_t> *max_val = nullptr) {
+  if (min_val) { _fbb.ForceVectorAlignment(min_val->size(), sizeof(uint8_t), 8); }
+  auto min_val__ = min_val ? _fbb.CreateVector<uint8_t>(*min_val) : 0;
+  if (max_val) { _fbb.ForceVectorAlignment(max_val->size(), sizeof(uint8_t), 8); }
+  auto max_val__ = max_val ? _fbb.CreateVector<uint8_t>(*max_val) : 0;
   return tosa::CreateClampAttribute(
       _fbb,
-      min_int,
-      max_int,
-      min_fp__,
-      max_fp__);
+      min_val__,
+      max_val__);
 }
 
 struct RescaleAttribute FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
@@ -1287,13 +1237,11 @@ struct RescaleAttribute FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_INPUT_ZP = 4,
     VT_OUTPUT_ZP = 6,
-    VT_MULTIPLIER = 8,
-    VT_SHIFT = 10,
-    VT_SCALE32 = 12,
-    VT_DOUBLE_ROUND = 14,
-    VT_PER_CHANNEL = 16,
-    VT_INPUT_UNSIGNED = 18,
-    VT_OUTPUT_UNSIGNED = 20
+    VT_SCALE32 = 8,
+    VT_DOUBLE_ROUND = 10,
+    VT_PER_CHANNEL = 12,
+    VT_INPUT_UNSIGNED = 14,
+    VT_OUTPUT_UNSIGNED = 16
   };
   int32_t input_zp() const {
     return GetField<int32_t>(VT_INPUT_ZP, 0);
@@ -1301,12 +1249,6 @@ struct RescaleAttribute FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   int32_t output_zp() const {
     return GetField<int32_t>(VT_OUTPUT_ZP, 0);
   }
-  const ::flatbuffers::Vector<int32_t> *multiplier() const {
-    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_MULTIPLIER);
-  }
-  const ::flatbuffers::Vector<int32_t> *shift() const {
-    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_SHIFT);
-  }
   bool scale32() const {
     return GetField<uint8_t>(VT_SCALE32, 0) != 0;
   }
@@ -1326,10 +1268,6 @@ struct RescaleAttribute FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
     return VerifyTableStart(verifier) &&
            VerifyField<int32_t>(verifier, VT_INPUT_ZP, 4) &&
            VerifyField<int32_t>(verifier, VT_OUTPUT_ZP, 4) &&
-           VerifyOffset(verifier, VT_MULTIPLIER) &&
-           verifier.VerifyVector(multiplier()) &&
-           VerifyOffset(verifier, VT_SHIFT) &&
-           verifier.VerifyVector(shift()) &&
            VerifyField<uint8_t>(verifier, VT_SCALE32, 1) &&
            VerifyField<uint8_t>(verifier, VT_DOUBLE_ROUND, 1) &&
            VerifyField<uint8_t>(verifier, VT_PER_CHANNEL, 1) &&
@@ -1349,12 +1287,6 @@ struct RescaleAttributeBuilder {
   void add_output_zp(int32_t output_zp) {
     fbb_.AddElement<int32_t>(RescaleAttribute::VT_OUTPUT_ZP, output_zp, 0);
   }
-  void add_multiplier(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> multiplier) {
-    fbb_.AddOffset(RescaleAttribute::VT_MULTIPLIER, multiplier);
-  }
-  void add_shift(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> shift) {
-    fbb_.AddOffset(RescaleAttribute::VT_SHIFT, shift);
-  }
   void add_scale32(bool scale32) {
     fbb_.AddElement<uint8_t>(RescaleAttribute::VT_SCALE32, static_cast<uint8_t>(scale32), 0);
   }
@@ -1385,16 +1317,12 @@ inline ::flatbuffers::Offset<RescaleAttribute> CreateRescaleAttribute(
     ::flatbuffers::FlatBufferBuilder &_fbb,
     int32_t input_zp = 0,
     int32_t output_zp = 0,
-    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> multiplier = 0,
-    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> shift = 0,
     bool scale32 = false,
     bool double_round = false,
     bool per_channel = false,
     bool input_unsigned = false,
     bool output_unsigned = false) {
   RescaleAttributeBuilder builder_(_fbb);
-  builder_.add_shift(shift);
-  builder_.add_multiplier(multiplier);
   builder_.add_output_zp(output_zp);
   builder_.add_input_zp(input_zp);
   builder_.add_output_unsigned(output_unsigned);
@@ -1405,32 +1333,6 @@ inline ::flatbuffers::Offset<RescaleAttribute> CreateRescaleAttribute(
   return builder_.Finish();
 }
 
-inline ::flatbuffers::Offset<RescaleAttribute> CreateRescaleAttributeDirect(
-    ::flatbuffers::FlatBufferBuilder &_fbb,
-    int32_t input_zp = 0,
-    int32_t output_zp = 0,
-    const std::vector<int32_t> *multiplier = nullptr,
-    const std::vector<int32_t> *shift = nullptr,
-    bool scale32 = false,
-    bool double_round = false,
-    bool per_channel = false,
-    bool input_unsigned = false,
-    bool output_unsigned = false) {
-  auto multiplier__ = multiplier ? _fbb.CreateVector<int32_t>(*multiplier) : 0;
-  auto shift__ = shift ? _fbb.CreateVector<int32_t>(*shift) : 0;
-  return tosa::CreateRescaleAttribute(
-      _fbb,
-      input_zp,
-      output_zp,
-      multiplier__,
-      shift__,
-      scale32,
-      double_round,
-      per_channel,
-      input_unsigned,
-      output_unsigned);
-}
-
 struct MulAttribute FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   typedef MulAttributeBuilder Builder;
   enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
diff --git a/python/serializer/tosa_serializer.py b/python/serializer/tosa_serializer.py
index 546de7d..2c7996a 100644
--- a/python/serializer/tosa_serializer.py
+++ b/python/serializer/tosa_serializer.py
@@ -13,7 +13,6 @@
 #    limitations under the License.
 
 import os
-import struct
 import serializer.tosa_serializer as ts
 import json
 import flatbuffers
@@ -201,22 +200,18 @@ class TosaSerializerAttribute(TosaSerializerUnion):
         self.ints.append((a.AddWeightZp, weight_zp))
         self.bools.append((a.AddLocalBound, local_bound))
 
-    def PadAttribute(self, serializer_builder, padding, pad_const_int, pad_const_fp):
+    def PadAttribute(self, serializer_builder, pad_const_val_as_bytes):
         from tosa import PadAttribute as a, Attribute
 
         self.utype = Attribute.Attribute().PadAttribute
         self.optFcns = (a.Start, a.End)
 
-        self.intvecs.append((a.AddPadding, padding))
-        self.ints.append((a.AddPadConstInt, pad_const_int))
-
-        # pad_const_fp attribute serialized as uint8 vector
-        pad_const_float_as_bytes = struct.pack("<f", pad_const_fp)
-        serialized_pad_const_fp = ts.TosaSerializer.serializeUint8Vec(
-            serializer_builder, pad_const_float_as_bytes
+        # serialize pad_const_val_as_bytes as uint8 vector
+        serialized_pad_const_val = ts.TosaSerializer.serializeUint8Vec(
+            serializer_builder, pad_const_val_as_bytes
         )
 
-        self.floats.append((a.AddPadConstFp, serialized_pad_const_fp))
+        self.floats.append((a.AddPadConst, serialized_pad_const_val))
 
     def AxisAttribute(self, axis):
         from tosa import AxisAttribute as a, Attribute
@@ -237,34 +232,27 @@ class TosaSerializerAttribute(TosaSerializerUnion):
         self.int16vecs.append((a.AddBorder, border))
         self.ints.append((a.AddMode, mode))
 
-    def ClampAttribute(self, serializer_builder, minint, maxint, minfp, maxfp):
+    def ClampAttribute(self, serializer_builder, min_val_as_bytes, max_val_as_bytes):
         from tosa import ClampAttribute as a, Attribute
 
         self.utype = Attribute.Attribute().ClampAttribute
         self.optFcns = (a.Start, a.End)
 
-        self.ints.append((a.AddMinInt, minint))
-        self.ints.append((a.AddMaxInt, maxint))
-
         # min/max float attributes serialized as uint8 vectors
-        minfp_bytes = struct.pack("<f", minfp)
-        maxfp_bytes = struct.pack("<f", maxfp)
-        serialized_minfp_bytes = ts.TosaSerializer.serializeUint8Vec(
-            serializer_builder, minfp_bytes
+        serialized_min_val = ts.TosaSerializer.serializeUint8Vec(
+            serializer_builder, min_val_as_bytes
         )
-        serialized_maxfp_bytes = ts.TosaSerializer.serializeUint8Vec(
-            serializer_builder, maxfp_bytes
+        serialized_max_val = ts.TosaSerializer.serializeUint8Vec(
+            serializer_builder, max_val_as_bytes
         )
 
-        self.floats.append((a.AddMinFp, serialized_minfp_bytes))
-        self.floats.append((a.AddMaxFp, serialized_maxfp_bytes))
+        self.floats.append((a.AddMinVal, serialized_min_val))
+        self.floats.append((a.AddMaxVal, serialized_max_val))
 
     def RescaleAttribute(
         self,
         input_zp,
         output_zp,
-        multiplier,
-        shift,
         scale32,
         double_round,
         per_channel,
@@ -278,8 +266,6 @@ class TosaSerializerAttribute(TosaSerializerUnion):
 
         self.ints.append((a.AddInputZp, input_zp))
         self.ints.append((a.AddOutputZp, output_zp))
-        self.intvecs.append((a.AddMultiplier, multiplier))
-        self.intvecs.append((a.AddShift, shift))
         self.bools.append((a.AddScale32, scale32))
         self.bools.append((a.AddDoubleRound, double_round))
         self.bools.append((a.AddPerChannel, per_channel))
diff --git a/python/tosa/ClampAttribute.py b/python/tosa/ClampAttribute.py
index 40e7d2e..6a41498 100644
--- a/python/tosa/ClampAttribute.py
+++ b/python/tosa/ClampAttribute.py
@@ -29,114 +29,88 @@ class ClampAttribute(object):
         self._tab = flatbuffers.table.Table(buf, pos)
 
     # ClampAttribute
-    def MinInt(self):
+    def MinVal(self, j):
         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
-
-    # ClampAttribute
-    def MaxInt(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
-
-    # ClampAttribute
-    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))
+    def MinValAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
         if o != 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))
+    def MinValLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
         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))
+    def MinValIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
         return o == 0
 
     # ClampAttribute
-    def MaxFp(self, j):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+    def MaxVal(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.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))
+    def MaxValAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
         if o != 0:
             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
         return 0
 
     # ClampAttribute
-    def MaxFpLength(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+    def MaxValLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
         if o != 0:
             return self._tab.VectorLen(o)
         return 0
 
     # ClampAttribute
-    def MaxFpIsNone(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+    def MaxValIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
         return o == 0
 
 def ClampAttributeStart(builder):
-    builder.StartObject(4)
+    builder.StartObject(2)
 
 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 ClampAttributeAddMinVal(builder, minVal):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(minVal), 0)
 
-def AddMinFp(builder, minFp):
-    ClampAttributeAddMinFp(builder, minFp)
+def AddMinVal(builder, minVal):
+    ClampAttributeAddMinVal(builder, minVal)
 
-def ClampAttributeStartMinFpVector(builder, numElems):
+def ClampAttributeStartMinValVector(builder, numElems):
     return builder.StartVector(1, numElems, 1)
 
-def StartMinFpVector(builder, numElems: int) -> int:
-    return ClampAttributeStartMinFpVector(builder, numElems)
+def StartMinValVector(builder, numElems: int) -> int:
+    return ClampAttributeStartMinValVector(builder, numElems)
 
-def ClampAttributeAddMaxFp(builder, maxFp):
-    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(maxFp), 0)
+def ClampAttributeAddMaxVal(builder, maxVal):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(maxVal), 0)
 
-def AddMaxFp(builder, maxFp):
-    ClampAttributeAddMaxFp(builder, maxFp)
+def AddMaxVal(builder, maxVal):
+    ClampAttributeAddMaxVal(builder, maxVal)
 
-def ClampAttributeStartMaxFpVector(builder, numElems):
+def ClampAttributeStartMaxValVector(builder, numElems):
     return builder.StartVector(1, numElems, 1)
 
-def StartMaxFpVector(builder, numElems: int) -> int:
-    return ClampAttributeStartMaxFpVector(builder, numElems)
+def StartMaxValVector(builder, numElems: int) -> int:
+    return ClampAttributeStartMaxValVector(builder, numElems)
 
 def ClampAttributeEnd(builder):
     return builder.EndObject()
diff --git a/python/tosa/PadAttribute.py b/python/tosa/PadAttribute.py
index fc843bb..301bf17 100644
--- a/python/tosa/PadAttribute.py
+++ b/python/tosa/PadAttribute.py
@@ -29,101 +29,49 @@ class PadAttribute(object):
         self._tab = flatbuffers.table.Table(buf, pos)
 
     # PadAttribute
-    def Padding(self, j):
+    def PadConst(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.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
         return 0
 
     # PadAttribute
-    def PaddingAsNumpy(self):
+    def PadConstAsNumpy(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.Uint8Flags, o)
         return 0
 
     # PadAttribute
-    def PaddingLength(self):
+    def PadConstLength(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):
+    def PadConstIsNone(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)
+    builder.StartObject(1)
 
 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 PadAttributeAddPadConst(builder, padConst):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(padConst), 0)
 
-def AddPadConstFp(builder, padConstFp):
-    PadAttributeAddPadConstFp(builder, padConstFp)
+def AddPadConst(builder, padConst):
+    PadAttributeAddPadConst(builder, padConst)
 
-def PadAttributeStartPadConstFpVector(builder, numElems):
+def PadAttributeStartPadConstVector(builder, numElems):
     return builder.StartVector(1, numElems, 1)
 
-def StartPadConstFpVector(builder, numElems: int) -> int:
-    return PadAttributeStartPadConstFpVector(builder, numElems)
+def StartPadConstVector(builder, numElems: int) -> int:
+    return PadAttributeStartPadConstVector(builder, numElems)
 
 def PadAttributeEnd(builder):
     return builder.EndObject()
diff --git a/python/tosa/RescaleAttribute.py b/python/tosa/RescaleAttribute.py
index 320c119..12e7ced 100644
--- a/python/tosa/RescaleAttribute.py
+++ b/python/tosa/RescaleAttribute.py
@@ -43,96 +43,42 @@ class RescaleAttribute(object):
         return 0
 
     # RescaleAttribute
-    def Multiplier(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 0
-
-    # RescaleAttribute
-    def MultiplierAsNumpy(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
-
-    # RescaleAttribute
-    def MultiplierLength(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
-        if o != 0:
-            return self._tab.VectorLen(o)
-        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:
-            a = self._tab.Vector(o)
-            return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
-        return 0
-
-    # RescaleAttribute
-    def ShiftAsNumpy(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 0
-
-    # RescaleAttribute
-    def ShiftLength(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
-        if o != 0:
-            return self._tab.VectorLen(o)
-        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))
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
         if o != 0:
             return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
         return False
 
     # RescaleAttribute
     def DoubleRound(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        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
 
     # RescaleAttribute
     def PerChannel(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
         if o != 0:
             return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
         return False
 
     # RescaleAttribute
     def InputUnsigned(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
         if o != 0:
             return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
         return False
 
     # RescaleAttribute
     def OutputUnsigned(self):
-        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
         if o != 0:
             return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
         return False
 
 def RescaleAttributeStart(builder):
-    builder.StartObject(9)
+    builder.StartObject(7)
 
 def Start(builder):
     RescaleAttributeStart(builder)
@@ -149,56 +95,32 @@ def RescaleAttributeAddOutputZp(builder, outputZp):
 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)
+    builder.PrependBoolSlot(2, scale32, 0)
 
 def AddScale32(builder, scale32):
     RescaleAttributeAddScale32(builder, scale32)
 
 def RescaleAttributeAddDoubleRound(builder, doubleRound):
-    builder.PrependBoolSlot(5, doubleRound, 0)
+    builder.PrependBoolSlot(3, doubleRound, 0)
 
 def AddDoubleRound(builder, doubleRound):
     RescaleAttributeAddDoubleRound(builder, doubleRound)
 
 def RescaleAttributeAddPerChannel(builder, perChannel):
-    builder.PrependBoolSlot(6, perChannel, 0)
+    builder.PrependBoolSlot(4, perChannel, 0)
 
 def AddPerChannel(builder, perChannel):
     RescaleAttributeAddPerChannel(builder, perChannel)
 
 def RescaleAttributeAddInputUnsigned(builder, inputUnsigned):
-    builder.PrependBoolSlot(7, inputUnsigned, 0)
+    builder.PrependBoolSlot(5, inputUnsigned, 0)
 
 def AddInputUnsigned(builder, inputUnsigned):
     RescaleAttributeAddInputUnsigned(builder, inputUnsigned)
 
 def RescaleAttributeAddOutputUnsigned(builder, outputUnsigned):
-    builder.PrependBoolSlot(8, outputUnsigned, 0)
+    builder.PrependBoolSlot(6, outputUnsigned, 0)
 
 def AddOutputUnsigned(builder, outputUnsigned):
     RescaleAttributeAddOutputUnsigned(builder, outputUnsigned)
diff --git a/schema/tosa.fbs b/schema/tosa.fbs
index 2bb3470..028765d 100644
--- a/schema/tosa.fbs
+++ b/schema/tosa.fbs
@@ -182,9 +182,7 @@ table TransposeConvAttribute {
 }
 
 table PadAttribute {
-  padding: [int32];
-  pad_const_int: int32;
-  pad_const_fp: [ubyte] (force_align: 8);
+  pad_const: [ubyte] (force_align: 8);
 }
 
 table AxisAttribute {
@@ -199,17 +197,13 @@ table ResizeAttribute {
 }
 
 table ClampAttribute {
-  min_int: int32;
-  max_int: int32;
-  min_fp: [ubyte] (force_align: 8);
-  max_fp: [ubyte] (force_align: 8);
+  min_val: [ubyte] (force_align: 8);
+  max_val: [ubyte] (force_align: 8);
 }
 
 table RescaleAttribute {
   input_zp: int32;
   output_zp: int32;
-  multiplier: [int32];
-  shift: [int32];
   scale32: bool;
   double_round: bool;
   per_channel: bool;