From 0b6d7c271af1e6593e6a2cf14b32acea765f4b64 Mon Sep 17 00:00:00 2001 From: Tai Ly Date: Fri, 8 Mar 2024 17:03:25 +0000 Subject: [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 Change-Id: I5b075d29677cffca9ff2292708141d48410e7e72 --- include/attribute.def | 20 ++-- include/tosa_generated.h | 186 +++++++++-------------------------- python/serializer/tosa_serializer.py | 38 +++---- python/tosa/ClampAttribute.py | 86 ++++++---------- python/tosa/PadAttribute.py | 80 +++------------ python/tosa/RescaleAttribute.py | 100 +++---------------- schema/tosa.fbs | 12 +-- 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 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 *padding() const { - return GetPointer *>(VT_PADDING); - } - int32_t pad_const_int() const { - return GetField(VT_PAD_CONST_INT, 0); - } - const ::flatbuffers::Vector *pad_const_fp() const { - return GetPointer *>(VT_PAD_CONST_FP); + const ::flatbuffers::Vector *pad_const() const { + return GetPointer *>(VT_PAD_CONST); } bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyOffset(verifier, VT_PADDING) && - verifier.VerifyVector(padding()) && - VerifyField(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> padding) { - fbb_.AddOffset(PadAttribute::VT_PADDING, padding); - } - void add_pad_const_int(int32_t pad_const_int) { - fbb_.AddElement(PadAttribute::VT_PAD_CONST_INT, pad_const_int, 0); - } - void add_pad_const_fp(::flatbuffers::Offset<::flatbuffers::Vector> pad_const_fp) { - fbb_.AddOffset(PadAttribute::VT_PAD_CONST_FP, pad_const_fp); + void add_pad_const(::flatbuffers::Offset<::flatbuffers::Vector> 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 CreatePadAttribute( ::flatbuffers::FlatBufferBuilder &_fbb, - ::flatbuffers::Offset<::flatbuffers::Vector> padding = 0, - int32_t pad_const_int = 0, - ::flatbuffers::Offset<::flatbuffers::Vector> pad_const_fp = 0) { + ::flatbuffers::Offset<::flatbuffers::Vector> 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 CreatePadAttributeDirect( ::flatbuffers::FlatBufferBuilder &_fbb, - const std::vector *padding = nullptr, - int32_t pad_const_int = 0, - const std::vector *pad_const_fp = nullptr) { - auto padding__ = padding ? _fbb.CreateVector(*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(*pad_const_fp) : 0; + const std::vector *pad_const = nullptr) { + if (pad_const) { _fbb.ForceVectorAlignment(pad_const->size(), sizeof(uint8_t), 8); } + auto pad_const__ = pad_const ? _fbb.CreateVector(*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 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(VT_MIN_INT, 0); + const ::flatbuffers::Vector *min_val() const { + return GetPointer *>(VT_MIN_VAL); } - int32_t max_int() const { - return GetField(VT_MAX_INT, 0); - } - const ::flatbuffers::Vector *min_fp() const { - return GetPointer *>(VT_MIN_FP); - } - const ::flatbuffers::Vector *max_fp() const { - return GetPointer *>(VT_MAX_FP); + const ::flatbuffers::Vector *max_val() const { + return GetPointer *>(VT_MAX_VAL); } bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && - VerifyField(verifier, VT_MIN_INT, 4) && - VerifyField(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(ClampAttribute::VT_MIN_INT, min_int, 0); - } - void add_max_int(int32_t max_int) { - fbb_.AddElement(ClampAttribute::VT_MAX_INT, max_int, 0); + void add_min_val(::flatbuffers::Offset<::flatbuffers::Vector> min_val) { + fbb_.AddOffset(ClampAttribute::VT_MIN_VAL, min_val); } - void add_min_fp(::flatbuffers::Offset<::flatbuffers::Vector> min_fp) { - fbb_.AddOffset(ClampAttribute::VT_MIN_FP, min_fp); - } - void add_max_fp(::flatbuffers::Offset<::flatbuffers::Vector> max_fp) { - fbb_.AddOffset(ClampAttribute::VT_MAX_FP, max_fp); + void add_max_val(::flatbuffers::Offset<::flatbuffers::Vector> 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 CreateClampAttribute( ::flatbuffers::FlatBufferBuilder &_fbb, - int32_t min_int = 0, - int32_t max_int = 0, - ::flatbuffers::Offset<::flatbuffers::Vector> min_fp = 0, - ::flatbuffers::Offset<::flatbuffers::Vector> max_fp = 0) { + ::flatbuffers::Offset<::flatbuffers::Vector> min_val = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> 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 CreateClampAttributeDirect( ::flatbuffers::FlatBufferBuilder &_fbb, - int32_t min_int = 0, - int32_t max_int = 0, - const std::vector *min_fp = nullptr, - const std::vector *max_fp = nullptr) { - if (min_fp) { _fbb.ForceVectorAlignment(min_fp->size(), sizeof(uint8_t), 8); } - auto min_fp__ = min_fp ? _fbb.CreateVector(*min_fp) : 0; - if (max_fp) { _fbb.ForceVectorAlignment(max_fp->size(), sizeof(uint8_t), 8); } - auto max_fp__ = max_fp ? _fbb.CreateVector(*max_fp) : 0; + const std::vector *min_val = nullptr, + const std::vector *max_val = nullptr) { + if (min_val) { _fbb.ForceVectorAlignment(min_val->size(), sizeof(uint8_t), 8); } + auto min_val__ = min_val ? _fbb.CreateVector(*min_val) : 0; + if (max_val) { _fbb.ForceVectorAlignment(max_val->size(), sizeof(uint8_t), 8); } + auto max_val__ = max_val ? _fbb.CreateVector(*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(VT_INPUT_ZP, 0); @@ -1301,12 +1249,6 @@ struct RescaleAttribute FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { int32_t output_zp() const { return GetField(VT_OUTPUT_ZP, 0); } - const ::flatbuffers::Vector *multiplier() const { - return GetPointer *>(VT_MULTIPLIER); - } - const ::flatbuffers::Vector *shift() const { - return GetPointer *>(VT_SHIFT); - } bool scale32() const { return GetField(VT_SCALE32, 0) != 0; } @@ -1326,10 +1268,6 @@ struct RescaleAttribute FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { return VerifyTableStart(verifier) && VerifyField(verifier, VT_INPUT_ZP, 4) && VerifyField(verifier, VT_OUTPUT_ZP, 4) && - VerifyOffset(verifier, VT_MULTIPLIER) && - verifier.VerifyVector(multiplier()) && - VerifyOffset(verifier, VT_SHIFT) && - verifier.VerifyVector(shift()) && VerifyField(verifier, VT_SCALE32, 1) && VerifyField(verifier, VT_DOUBLE_ROUND, 1) && VerifyField(verifier, VT_PER_CHANNEL, 1) && @@ -1349,12 +1287,6 @@ struct RescaleAttributeBuilder { void add_output_zp(int32_t output_zp) { fbb_.AddElement(RescaleAttribute::VT_OUTPUT_ZP, output_zp, 0); } - void add_multiplier(::flatbuffers::Offset<::flatbuffers::Vector> multiplier) { - fbb_.AddOffset(RescaleAttribute::VT_MULTIPLIER, multiplier); - } - void add_shift(::flatbuffers::Offset<::flatbuffers::Vector> shift) { - fbb_.AddOffset(RescaleAttribute::VT_SHIFT, shift); - } void add_scale32(bool scale32) { fbb_.AddElement(RescaleAttribute::VT_SCALE32, static_cast(scale32), 0); } @@ -1385,16 +1317,12 @@ inline ::flatbuffers::Offset CreateRescaleAttribute( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input_zp = 0, int32_t output_zp = 0, - ::flatbuffers::Offset<::flatbuffers::Vector> multiplier = 0, - ::flatbuffers::Offset<::flatbuffers::Vector> 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 CreateRescaleAttribute( return builder_.Finish(); } -inline ::flatbuffers::Offset CreateRescaleAttributeDirect( - ::flatbuffers::FlatBufferBuilder &_fbb, - int32_t input_zp = 0, - int32_t output_zp = 0, - const std::vector *multiplier = nullptr, - const std::vector *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(*multiplier) : 0; - auto shift__ = shift ? _fbb.CreateVector(*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(" 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 @@ -42,97 +42,43 @@ class RescaleAttribute(object): return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) 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; -- cgit v1.2.1