wehub-resource-sync
7254f7b4d1
Build / Build (macos-latest) (push) Has been cancelled
Build / Build (ubuntu-latest) (push) Has been cancelled
Build / Build (windows-latest) (push) Has been cancelled
Build / Analyze (javascript) (push) Has been cancelled
Build / Analyze (python) (push) Has been cancelled
3086 lines
123 KiB
JavaScript
3086 lines
123 KiB
JavaScript
|
|
export const armnnSerializer = {};
|
|
|
|
armnnSerializer.ActivationFunction = {
|
|
Sigmoid: 0, '0': 'Sigmoid',
|
|
TanH: 1, '1': 'TanH',
|
|
Linear: 2, '2': 'Linear',
|
|
ReLu: 3, '3': 'ReLu',
|
|
BoundedReLu: 4, '4': 'BoundedReLu',
|
|
SoftReLu: 5, '5': 'SoftReLu',
|
|
LeakyReLu: 6, '6': 'LeakyReLu',
|
|
Abs: 7, '7': 'Abs',
|
|
Sqrt: 8, '8': 'Sqrt',
|
|
Square: 9, '9': 'Square',
|
|
Elu: 10, '10': 'Elu',
|
|
HardSwish: 11, '11': 'HardSwish',
|
|
Gelu: 12, '12': 'Gelu'
|
|
};
|
|
|
|
armnnSerializer.ArgMinMaxFunction = {
|
|
Min: 0, '0': 'Min',
|
|
Max: 1, '1': 'Max'
|
|
};
|
|
|
|
armnnSerializer.DataType = {
|
|
Float16: 0, '0': 'Float16',
|
|
Float32: 1, '1': 'Float32',
|
|
QuantisedAsymm8: 2, '2': 'QuantisedAsymm8',
|
|
Signed32: 3, '3': 'Signed32',
|
|
Boolean: 4, '4': 'Boolean',
|
|
QuantisedSymm16: 5, '5': 'QuantisedSymm16',
|
|
QAsymmU8: 6, '6': 'QAsymmU8',
|
|
QSymmS16: 7, '7': 'QSymmS16',
|
|
QAsymmS8: 8, '8': 'QAsymmS8',
|
|
QSymmS8: 9, '9': 'QSymmS8',
|
|
Signed64: 10, '10': 'Signed64'
|
|
};
|
|
|
|
armnnSerializer.DataLayout = {
|
|
NHWC: 0, '0': 'NHWC',
|
|
NCHW: 1, '1': 'NCHW',
|
|
NDHWC: 2, '2': 'NDHWC',
|
|
NCDHW: 3, '3': 'NCDHW'
|
|
};
|
|
|
|
armnnSerializer.ReduceOperation = {
|
|
Sum: 0, '0': 'Sum',
|
|
Max: 1, '1': 'Max',
|
|
Mean: 2, '2': 'Mean',
|
|
Min: 3, '3': 'Min',
|
|
Prod: 4, '4': 'Prod'
|
|
};
|
|
|
|
armnnSerializer.ResizeMethod = {
|
|
NearestNeighbor: 0, '0': 'NearestNeighbor',
|
|
Bilinear: 1, '1': 'Bilinear'
|
|
};
|
|
|
|
armnnSerializer.ScatterNdFunction = {
|
|
Update: 0, '0': 'Update',
|
|
Add: 1, '1': 'Add',
|
|
Sub: 2, '2': 'Sub',
|
|
Max: 3, '3': 'Max',
|
|
Min: 4, '4': 'Min'
|
|
};
|
|
|
|
armnnSerializer.TensorInfo = class TensorInfo {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.TensorInfo();
|
|
$.dimensions = reader.array(position, 4, Uint32Array);
|
|
$.dataType = reader.int8_(position, 6, 0);
|
|
$.quantizationScale = reader.float32_(position, 8, 1);
|
|
$.quantizationOffset = reader.int32_(position, 10, 0);
|
|
$.quantizationScales = reader.array(position, 12, Float32Array);
|
|
$.quantizationDim = reader.uint32_(position, 14, 0);
|
|
$.dimensionality = reader.uint32_(position, 16, 1);
|
|
$.dimensionSpecificity = reader.bools_(position, 18);
|
|
$.isConstant = reader.bool_(position, 20, false);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.TensorInfo();
|
|
$.dimensions = reader.array(json.dimensions, Uint32Array);
|
|
$.dataType = armnnSerializer.DataType[json.dataType];
|
|
$.quantizationScale = reader.value(json.quantizationScale, 1);
|
|
$.quantizationOffset = reader.value(json.quantizationOffset, 0);
|
|
$.quantizationScales = reader.array(json.quantizationScales, Float32Array);
|
|
$.quantizationDim = reader.value(json.quantizationDim, 0);
|
|
$.dimensionality = reader.value(json.dimensionality, 1);
|
|
$.dimensionSpecificity = reader.array(json.dimensionSpecificity);
|
|
$.isConstant = reader.value(json.isConstant, false);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.Connection = class Connection {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.Connection();
|
|
$.sourceLayerIndex = reader.uint32(position + 0);
|
|
$.outputSlotIndex = reader.uint32(position + 4);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.Connection();
|
|
$.sourceLayerIndex = json.sourceLayerIndex;
|
|
$.outputSlotIndex = json.outputSlotIndex;
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.ByteData = class ByteData {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.ByteData();
|
|
$.data = reader.array(position, 4, Int8Array);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.ByteData();
|
|
$.data = reader.array(json.data, Int8Array);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.ShortData = class ShortData {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.ShortData();
|
|
$.data = reader.array(position, 4, Int16Array);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.ShortData();
|
|
$.data = reader.array(json.data, Int16Array);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.IntData = class IntData {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.IntData();
|
|
$.data = reader.array(position, 4, Int32Array);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.IntData();
|
|
$.data = reader.array(json.data, Int32Array);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.LongData = class LongData {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.LongData();
|
|
$.data = reader.int64s_(position, 4);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.LongData();
|
|
$.data = reader.array(json.data);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.ConstTensorData = class {
|
|
|
|
static decode(reader, position, type) {
|
|
switch (type) {
|
|
case 1: return armnnSerializer.ByteData.decode(reader, position);
|
|
case 2: return armnnSerializer.ShortData.decode(reader, position);
|
|
case 3: return armnnSerializer.IntData.decode(reader, position);
|
|
case 4: return armnnSerializer.LongData.decode(reader, position);
|
|
default: return undefined;
|
|
}
|
|
}
|
|
|
|
static decodeText(reader, json, type) {
|
|
switch (type) {
|
|
case 'ByteData': return armnnSerializer.ByteData.decodeText(reader, json);
|
|
case 'ShortData': return armnnSerializer.ShortData.decodeText(reader, json);
|
|
case 'IntData': return armnnSerializer.IntData.decodeText(reader, json);
|
|
case 'LongData': return armnnSerializer.LongData.decodeText(reader, json);
|
|
default: return undefined;
|
|
}
|
|
}
|
|
};
|
|
|
|
armnnSerializer.ConstTensor = class ConstTensor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.ConstTensor();
|
|
$.info = reader.table(position, 4, armnnSerializer.TensorInfo);
|
|
$.data = reader.union(position, 6, armnnSerializer.ConstTensorData);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.ConstTensor();
|
|
$.info = reader.object(json.info, armnnSerializer.TensorInfo);
|
|
$.data = armnnSerializer.ConstTensorData.decodeText(reader, json.data, json.data_type);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.InputSlot = class InputSlot {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.InputSlot();
|
|
$.index = reader.uint32_(position, 4, 0);
|
|
$.connection = reader.struct(position, 6, armnnSerializer.Connection);
|
|
$.isOverridden = reader.bool_(position, 8, false);
|
|
$.overriddenTensorInfo = reader.table(position, 10, armnnSerializer.TensorInfo);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.InputSlot();
|
|
$.index = reader.value(json.index, 0);
|
|
$.connection = reader.object(json.connection, armnnSerializer.Connection);
|
|
$.isOverridden = reader.value(json.isOverridden, false);
|
|
$.overriddenTensorInfo = reader.object(json.overriddenTensorInfo, armnnSerializer.TensorInfo);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.OutputSlot = class OutputSlot {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.OutputSlot();
|
|
$.index = reader.uint32_(position, 4, 0);
|
|
$.tensorInfo = reader.table(position, 6, armnnSerializer.TensorInfo);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.OutputSlot();
|
|
$.index = reader.value(json.index, 0);
|
|
$.tensorInfo = reader.object(json.tensorInfo, armnnSerializer.TensorInfo);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.LayerType = {
|
|
Addition: 0, '0': 'Addition',
|
|
Input: 1, '1': 'Input',
|
|
Multiplication: 2, '2': 'Multiplication',
|
|
Output: 3, '3': 'Output',
|
|
Pooling2d: 4, '4': 'Pooling2d',
|
|
Reshape: 5, '5': 'Reshape',
|
|
Softmax: 6, '6': 'Softmax',
|
|
Convolution2d: 7, '7': 'Convolution2d',
|
|
DepthwiseConvolution2d: 8, '8': 'DepthwiseConvolution2d',
|
|
Activation: 9, '9': 'Activation',
|
|
Permute: 10, '10': 'Permute',
|
|
FullyConnected: 11, '11': 'FullyConnected',
|
|
Constant: 12, '12': 'Constant',
|
|
SpaceToBatchNd: 13, '13': 'SpaceToBatchNd',
|
|
BatchToSpaceNd: 14, '14': 'BatchToSpaceNd',
|
|
Division: 15, '15': 'Division',
|
|
Minimum: 16, '16': 'Minimum',
|
|
Equal: 17, '17': 'Equal',
|
|
Maximum: 18, '18': 'Maximum',
|
|
Normalization: 19, '19': 'Normalization',
|
|
Pad: 20, '20': 'Pad',
|
|
Rsqrt: 21, '21': 'Rsqrt',
|
|
Floor: 22, '22': 'Floor',
|
|
BatchNormalization: 23, '23': 'BatchNormalization',
|
|
Greater: 24, '24': 'Greater',
|
|
ResizeBilinear: 25, '25': 'ResizeBilinear',
|
|
Subtraction: 26, '26': 'Subtraction',
|
|
StridedSlice: 27, '27': 'StridedSlice',
|
|
Gather: 28, '28': 'Gather',
|
|
Mean: 29, '29': 'Mean',
|
|
Merger: 30, '30': 'Merger',
|
|
L2Normalization: 31, '31': 'L2Normalization',
|
|
Splitter: 32, '32': 'Splitter',
|
|
DetectionPostProcess: 33, '33': 'DetectionPostProcess',
|
|
Lstm: 34, '34': 'Lstm',
|
|
Quantize: 35, '35': 'Quantize',
|
|
Dequantize: 36, '36': 'Dequantize',
|
|
Merge: 37, '37': 'Merge',
|
|
Switch: 38, '38': 'Switch',
|
|
Concat: 39, '39': 'Concat',
|
|
SpaceToDepth: 40, '40': 'SpaceToDepth',
|
|
Prelu: 41, '41': 'Prelu',
|
|
TransposeConvolution2d: 42, '42': 'TransposeConvolution2d',
|
|
Resize: 43, '43': 'Resize',
|
|
Stack: 44, '44': 'Stack',
|
|
QuantizedLstm: 45, '45': 'QuantizedLstm',
|
|
Abs: 46, '46': 'Abs',
|
|
ArgMinMax: 47, '47': 'ArgMinMax',
|
|
Slice: 48, '48': 'Slice',
|
|
DepthToSpace: 49, '49': 'DepthToSpace',
|
|
InstanceNormalization: 50, '50': 'InstanceNormalization',
|
|
LogSoftmax: 51, '51': 'LogSoftmax',
|
|
Comparison: 52, '52': 'Comparison',
|
|
StandIn: 53, '53': 'StandIn',
|
|
ElementwiseUnary: 54, '54': 'ElementwiseUnary',
|
|
Transpose: 55, '55': 'Transpose',
|
|
QLstm: 56, '56': 'QLstm',
|
|
Fill: 57, '57': 'Fill',
|
|
Rank: 58, '58': 'Rank',
|
|
LogicalBinary: 59, '59': 'LogicalBinary',
|
|
Reduce: 60, '60': 'Reduce',
|
|
Cast: 61, '61': 'Cast',
|
|
Shape: 62, '62': 'Shape',
|
|
UnidirectionalSequenceLstm: 63, '63': 'UnidirectionalSequenceLstm',
|
|
ChannelShuffle: 64, '64': 'ChannelShuffle',
|
|
Convolution3d: 65, '65': 'Convolution3d',
|
|
Pooling3d: 66, '66': 'Pooling3d',
|
|
GatherNd: 67, '67': 'GatherNd',
|
|
BatchMatMul: 68, '68': 'BatchMatMul',
|
|
ElementwiseBinary: 69, '69': 'ElementwiseBinary',
|
|
ReverseV2: 70, '70': 'ReverseV2',
|
|
Tile: 71, '71': 'Tile',
|
|
ScatterNd: 72, '72': 'ScatterNd'
|
|
};
|
|
|
|
armnnSerializer.LayerBase = class LayerBase {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.LayerBase();
|
|
$.index = reader.uint32_(position, 4, 0);
|
|
$.layerName = reader.string_(position, 6, null);
|
|
$.layerType = reader.uint32_(position, 8, 0);
|
|
$.inputSlots = reader.tables(position, 10, armnnSerializer.InputSlot);
|
|
$.outputSlots = reader.tables(position, 12, armnnSerializer.OutputSlot);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.LayerBase();
|
|
$.index = reader.value(json.index, 0);
|
|
$.layerName = reader.value(json.layerName, null);
|
|
$.layerType = armnnSerializer.LayerType[json.layerType];
|
|
$.inputSlots = reader.objects(json.inputSlots, armnnSerializer.InputSlot);
|
|
$.outputSlots = reader.objects(json.outputSlots, armnnSerializer.OutputSlot);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.BindableLayerBase = class BindableLayerBase {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.BindableLayerBase();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.layerBindingId = reader.int32_(position, 6, 0);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.BindableLayerBase();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.layerBindingId = reader.value(json.layerBindingId, 0);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.AbsLayer = class AbsLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.AbsLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.AbsLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.ActivationLayer = class ActivationLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.ActivationLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.ActivationDescriptor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.ActivationLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.ActivationDescriptor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.ActivationDescriptor = class ActivationDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.ActivationDescriptor();
|
|
$.activationFunction = reader.int8_(position, 4, 0);
|
|
$.a = reader.float32_(position, 6, 0);
|
|
$.b = reader.float32_(position, 8, 0);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.ActivationDescriptor();
|
|
$.activationFunction = armnnSerializer.ActivationFunction[json.activationFunction];
|
|
$.a = reader.value(json.a, 0);
|
|
$.b = reader.value(json.b, 0);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.AdditionLayer = class AdditionLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.AdditionLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.AdditionLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.ArgMinMaxLayer = class ArgMinMaxLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.ArgMinMaxLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.ArgMinMaxDescriptor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.ArgMinMaxLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.ArgMinMaxDescriptor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.ArgMinMaxDescriptor = class ArgMinMaxDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.ArgMinMaxDescriptor();
|
|
$.argMinMaxFunction = reader.int8_(position, 4, 0);
|
|
$.axis = reader.int32_(position, 6, 0);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.ArgMinMaxDescriptor();
|
|
$.argMinMaxFunction = armnnSerializer.ArgMinMaxFunction[json.argMinMaxFunction];
|
|
$.axis = reader.value(json.axis, 0);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.CastLayer = class CastLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.CastLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.CastLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.ChannelShuffleLayer = class ChannelShuffleLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.ChannelShuffleLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.ChannelShuffleDescriptor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.ChannelShuffleLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.ChannelShuffleDescriptor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.ChannelShuffleDescriptor = class ChannelShuffleDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.ChannelShuffleDescriptor();
|
|
$.axis = reader.uint32_(position, 4, 0);
|
|
$.numGroups = reader.uint32_(position, 6, 0);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.ChannelShuffleDescriptor();
|
|
$.axis = reader.value(json.axis, 0);
|
|
$.numGroups = reader.value(json.numGroups, 0);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.ComparisonOperation = {
|
|
Equal: 0, '0': 'Equal',
|
|
Greater: 1, '1': 'Greater',
|
|
GreaterOrEqual: 2, '2': 'GreaterOrEqual',
|
|
Less: 3, '3': 'Less',
|
|
LessOrEqual: 4, '4': 'LessOrEqual',
|
|
NotEqual: 5, '5': 'NotEqual'
|
|
};
|
|
|
|
armnnSerializer.ComparisonDescriptor = class ComparisonDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.ComparisonDescriptor();
|
|
$.operation = reader.int8_(position, 4, 0);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.ComparisonDescriptor();
|
|
$.operation = armnnSerializer.ComparisonOperation[json.operation];
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.ComparisonLayer = class ComparisonLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.ComparisonLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.ComparisonDescriptor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.ComparisonLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.ComparisonDescriptor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.ConstantLayer = class ConstantLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.ConstantLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.input = reader.table(position, 6, armnnSerializer.ConstTensor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.ConstantLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.input = reader.object(json.input, armnnSerializer.ConstTensor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.Convolution2dLayer = class Convolution2dLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.Convolution2dLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.Convolution2dDescriptor);
|
|
$.weights = reader.table(position, 8, armnnSerializer.ConstTensor);
|
|
$.biases = reader.table(position, 10, armnnSerializer.ConstTensor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.Convolution2dLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.Convolution2dDescriptor);
|
|
$.weights = reader.object(json.weights, armnnSerializer.ConstTensor);
|
|
$.biases = reader.object(json.biases, armnnSerializer.ConstTensor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.Convolution2dDescriptor = class Convolution2dDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.Convolution2dDescriptor();
|
|
$.padLeft = reader.uint32_(position, 4, 0);
|
|
$.padRight = reader.uint32_(position, 6, 0);
|
|
$.padTop = reader.uint32_(position, 8, 0);
|
|
$.padBottom = reader.uint32_(position, 10, 0);
|
|
$.strideX = reader.uint32_(position, 12, 0);
|
|
$.strideY = reader.uint32_(position, 14, 0);
|
|
$.dilationX = reader.uint32_(position, 16, 1);
|
|
$.dilationY = reader.uint32_(position, 18, 1);
|
|
$.biasEnabled = reader.bool_(position, 20, false);
|
|
$.dataLayout = reader.int8_(position, 22, 1);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.Convolution2dDescriptor();
|
|
$.padLeft = reader.value(json.padLeft, 0);
|
|
$.padRight = reader.value(json.padRight, 0);
|
|
$.padTop = reader.value(json.padTop, 0);
|
|
$.padBottom = reader.value(json.padBottom, 0);
|
|
$.strideX = reader.value(json.strideX, 0);
|
|
$.strideY = reader.value(json.strideY, 0);
|
|
$.dilationX = reader.value(json.dilationX, 1);
|
|
$.dilationY = reader.value(json.dilationY, 1);
|
|
$.biasEnabled = reader.value(json.biasEnabled, false);
|
|
$.dataLayout = armnnSerializer.DataLayout[json.dataLayout];
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.Convolution3dLayer = class Convolution3dLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.Convolution3dLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.Convolution3dDescriptor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.Convolution3dLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.Convolution3dDescriptor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.Convolution3dDescriptor = class Convolution3dDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.Convolution3dDescriptor();
|
|
$.padLeft = reader.uint32_(position, 4, 0);
|
|
$.padRight = reader.uint32_(position, 6, 0);
|
|
$.padTop = reader.uint32_(position, 8, 0);
|
|
$.padBottom = reader.uint32_(position, 10, 0);
|
|
$.padFront = reader.uint32_(position, 12, 0);
|
|
$.padBack = reader.uint32_(position, 14, 0);
|
|
$.strideX = reader.uint32_(position, 16, 0);
|
|
$.strideY = reader.uint32_(position, 18, 0);
|
|
$.strideZ = reader.uint32_(position, 20, 0);
|
|
$.dilationX = reader.uint32_(position, 22, 1);
|
|
$.dilationY = reader.uint32_(position, 24, 1);
|
|
$.dilationZ = reader.uint32_(position, 26, 1);
|
|
$.biasEnabled = reader.bool_(position, 28, false);
|
|
$.dataLayout = reader.int8_(position, 30, 2);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.Convolution3dDescriptor();
|
|
$.padLeft = reader.value(json.padLeft, 0);
|
|
$.padRight = reader.value(json.padRight, 0);
|
|
$.padTop = reader.value(json.padTop, 0);
|
|
$.padBottom = reader.value(json.padBottom, 0);
|
|
$.padFront = reader.value(json.padFront, 0);
|
|
$.padBack = reader.value(json.padBack, 0);
|
|
$.strideX = reader.value(json.strideX, 0);
|
|
$.strideY = reader.value(json.strideY, 0);
|
|
$.strideZ = reader.value(json.strideZ, 0);
|
|
$.dilationX = reader.value(json.dilationX, 1);
|
|
$.dilationY = reader.value(json.dilationY, 1);
|
|
$.dilationZ = reader.value(json.dilationZ, 1);
|
|
$.biasEnabled = reader.value(json.biasEnabled, false);
|
|
$.dataLayout = armnnSerializer.DataLayout[json.dataLayout];
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.DepthToSpaceLayer = class DepthToSpaceLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.DepthToSpaceLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.DepthToSpaceDescriptor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.DepthToSpaceLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.DepthToSpaceDescriptor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.DepthToSpaceDescriptor = class DepthToSpaceDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.DepthToSpaceDescriptor();
|
|
$.blockSize = reader.uint32_(position, 4, 0);
|
|
$.dataLayout = reader.int8_(position, 6, 0);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.DepthToSpaceDescriptor();
|
|
$.blockSize = reader.value(json.blockSize, 0);
|
|
$.dataLayout = armnnSerializer.DataLayout[json.dataLayout];
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.DivisionLayer = class DivisionLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.DivisionLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.DivisionLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.BinaryOperation = {
|
|
Add: 0, '0': 'Add',
|
|
Div: 1, '1': 'Div',
|
|
Maximum: 2, '2': 'Maximum',
|
|
Minimum: 3, '3': 'Minimum',
|
|
Mul: 4, '4': 'Mul',
|
|
Sub: 5, '5': 'Sub',
|
|
SqDiff: 6, '6': 'SqDiff',
|
|
Power: 7, '7': 'Power',
|
|
FloorDiv: 8, '8': 'FloorDiv'
|
|
};
|
|
|
|
armnnSerializer.ElementwiseBinaryDescriptor = class ElementwiseBinaryDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.ElementwiseBinaryDescriptor();
|
|
$.operation = reader.int8_(position, 4, 0);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.ElementwiseBinaryDescriptor();
|
|
$.operation = armnnSerializer.BinaryOperation[json.operation];
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.ElementwiseBinaryLayer = class ElementwiseBinaryLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.ElementwiseBinaryLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.ElementwiseBinaryDescriptor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.ElementwiseBinaryLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.ElementwiseBinaryDescriptor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.UnaryOperation = {
|
|
Abs: 0, '0': 'Abs',
|
|
Rsqrt: 1, '1': 'Rsqrt',
|
|
Sqrt: 2, '2': 'Sqrt',
|
|
Exp: 3, '3': 'Exp',
|
|
Neg: 4, '4': 'Neg',
|
|
LogicalNot: 5, '5': 'LogicalNot',
|
|
Log: 6, '6': 'Log',
|
|
Sin: 7, '7': 'Sin',
|
|
Ceil: 8, '8': 'Ceil'
|
|
};
|
|
|
|
armnnSerializer.ElementwiseUnaryDescriptor = class ElementwiseUnaryDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.ElementwiseUnaryDescriptor();
|
|
$.operation = reader.int8_(position, 4, 0);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.ElementwiseUnaryDescriptor();
|
|
$.operation = armnnSerializer.UnaryOperation[json.operation];
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.ElementwiseUnaryLayer = class ElementwiseUnaryLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.ElementwiseUnaryLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.ElementwiseUnaryDescriptor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.ElementwiseUnaryLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.ElementwiseUnaryDescriptor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.EqualLayer = class EqualLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.EqualLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.EqualLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.FillLayer = class FillLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.FillLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.FillDescriptor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.FillLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.FillDescriptor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.FillDescriptor = class FillDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.FillDescriptor();
|
|
$.value = reader.float32_(position, 4, 0);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.FillDescriptor();
|
|
$.value = reader.value(json.value, 0);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.FloorLayer = class FloorLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.FloorLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.FloorLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.FullyConnectedLayer = class FullyConnectedLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.FullyConnectedLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.FullyConnectedDescriptor);
|
|
$.weights = reader.table(position, 8, armnnSerializer.ConstTensor);
|
|
$.biases = reader.table(position, 10, armnnSerializer.ConstTensor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.FullyConnectedLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.FullyConnectedDescriptor);
|
|
$.weights = reader.object(json.weights, armnnSerializer.ConstTensor);
|
|
$.biases = reader.object(json.biases, armnnSerializer.ConstTensor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.FullyConnectedDescriptor = class FullyConnectedDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.FullyConnectedDescriptor();
|
|
$.biasEnabled = reader.bool_(position, 4, false);
|
|
$.transposeWeightsMatrix = reader.bool_(position, 6, false);
|
|
$.constantWeights = reader.bool_(position, 8, true);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.FullyConnectedDescriptor();
|
|
$.biasEnabled = reader.value(json.biasEnabled, false);
|
|
$.transposeWeightsMatrix = reader.value(json.transposeWeightsMatrix, false);
|
|
$.constantWeights = reader.value(json.constantWeights, true);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.GatherLayer = class GatherLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.GatherLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.GatherDescriptor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.GatherLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.GatherDescriptor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.GatherDescriptor = class GatherDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.GatherDescriptor();
|
|
$.axis = reader.int32_(position, 4, 0);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.GatherDescriptor();
|
|
$.axis = reader.value(json.axis, 0);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.GatherNdLayer = class GatherNdLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.GatherNdLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.GatherNdLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.GreaterLayer = class GreaterLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.GreaterLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.GreaterLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.InputLayer = class InputLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.InputLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.BindableLayerBase);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.InputLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.BindableLayerBase);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.InstanceNormalizationLayer = class InstanceNormalizationLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.InstanceNormalizationLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.InstanceNormalizationDescriptor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.InstanceNormalizationLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.InstanceNormalizationDescriptor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.InstanceNormalizationDescriptor = class InstanceNormalizationDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.InstanceNormalizationDescriptor();
|
|
$.gamma = reader.float32_(position, 4, 0);
|
|
$.beta = reader.float32_(position, 6, 0);
|
|
$.eps = reader.float32_(position, 8, 0);
|
|
$.dataLayout = reader.int8_(position, 10, 0);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.InstanceNormalizationDescriptor();
|
|
$.gamma = reader.value(json.gamma, 0);
|
|
$.beta = reader.value(json.beta, 0);
|
|
$.eps = reader.value(json.eps, 0);
|
|
$.dataLayout = armnnSerializer.DataLayout[json.dataLayout];
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.LogSoftmaxLayer = class LogSoftmaxLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.LogSoftmaxLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.LogSoftmaxDescriptor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.LogSoftmaxLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.LogSoftmaxDescriptor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.LogSoftmaxDescriptor = class LogSoftmaxDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.LogSoftmaxDescriptor();
|
|
$.beta = reader.float32_(position, 4, 1);
|
|
$.axis = reader.int32_(position, 6, -1);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.LogSoftmaxDescriptor();
|
|
$.beta = reader.value(json.beta, 1);
|
|
$.axis = reader.value(json.axis, -1);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.L2NormalizationLayer = class L2NormalizationLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.L2NormalizationLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.L2NormalizationDescriptor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.L2NormalizationLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.L2NormalizationDescriptor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.L2NormalizationDescriptor = class L2NormalizationDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.L2NormalizationDescriptor();
|
|
$.dataLayout = reader.int8_(position, 4, 1);
|
|
$.eps = reader.float32_(position, 6, 1e-12);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.L2NormalizationDescriptor();
|
|
$.dataLayout = armnnSerializer.DataLayout[json.dataLayout];
|
|
$.eps = reader.value(json.eps, 1e-12);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.LogicalBinaryOperation = {
|
|
LogicalAnd: 0, '0': 'LogicalAnd',
|
|
LogicalOr: 1, '1': 'LogicalOr'
|
|
};
|
|
|
|
armnnSerializer.LogicalBinaryDescriptor = class LogicalBinaryDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.LogicalBinaryDescriptor();
|
|
$.operation = reader.int8_(position, 4, 0);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.LogicalBinaryDescriptor();
|
|
$.operation = armnnSerializer.LogicalBinaryOperation[json.operation];
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.LogicalBinaryLayer = class LogicalBinaryLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.LogicalBinaryLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.LogicalBinaryDescriptor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.LogicalBinaryLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.LogicalBinaryDescriptor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.MinimumLayer = class MinimumLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.MinimumLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.MinimumLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.MaximumLayer = class MaximumLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.MaximumLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.MaximumLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.MultiplicationLayer = class MultiplicationLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.MultiplicationLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.MultiplicationLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.Pooling2dLayer = class Pooling2dLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.Pooling2dLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.Pooling2dDescriptor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.Pooling2dLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.Pooling2dDescriptor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.Pooling3dLayer = class Pooling3dLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.Pooling3dLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.Pooling3dDescriptor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.Pooling3dLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.Pooling3dDescriptor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.PoolingAlgorithm = {
|
|
Max: 0, '0': 'Max',
|
|
Average: 1, '1': 'Average',
|
|
L2: 2, '2': 'L2'
|
|
};
|
|
|
|
armnnSerializer.OutputShapeRounding = {
|
|
Floor: 0, '0': 'Floor',
|
|
Ceiling: 1, '1': 'Ceiling'
|
|
};
|
|
|
|
armnnSerializer.PaddingMethod = {
|
|
IgnoreValue: 0, '0': 'IgnoreValue',
|
|
Exclude: 1, '1': 'Exclude'
|
|
};
|
|
|
|
armnnSerializer.Pooling2dDescriptor = class Pooling2dDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.Pooling2dDescriptor();
|
|
$.poolType = reader.int8_(position, 4, 0);
|
|
$.padLeft = reader.uint32_(position, 6, 0);
|
|
$.padRight = reader.uint32_(position, 8, 0);
|
|
$.padTop = reader.uint32_(position, 10, 0);
|
|
$.padBottom = reader.uint32_(position, 12, 0);
|
|
$.poolWidth = reader.uint32_(position, 14, 0);
|
|
$.poolHeight = reader.uint32_(position, 16, 0);
|
|
$.strideX = reader.uint32_(position, 18, 0);
|
|
$.strideY = reader.uint32_(position, 20, 0);
|
|
$.outputShapeRounding = reader.int8_(position, 22, 0);
|
|
$.paddingMethod = reader.int8_(position, 24, 0);
|
|
$.dataLayout = reader.int8_(position, 26, 0);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.Pooling2dDescriptor();
|
|
$.poolType = armnnSerializer.PoolingAlgorithm[json.poolType];
|
|
$.padLeft = reader.value(json.padLeft, 0);
|
|
$.padRight = reader.value(json.padRight, 0);
|
|
$.padTop = reader.value(json.padTop, 0);
|
|
$.padBottom = reader.value(json.padBottom, 0);
|
|
$.poolWidth = reader.value(json.poolWidth, 0);
|
|
$.poolHeight = reader.value(json.poolHeight, 0);
|
|
$.strideX = reader.value(json.strideX, 0);
|
|
$.strideY = reader.value(json.strideY, 0);
|
|
$.outputShapeRounding = armnnSerializer.OutputShapeRounding[json.outputShapeRounding];
|
|
$.paddingMethod = armnnSerializer.PaddingMethod[json.paddingMethod];
|
|
$.dataLayout = armnnSerializer.DataLayout[json.dataLayout];
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.Pooling3dDescriptor = class Pooling3dDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.Pooling3dDescriptor();
|
|
$.poolType = reader.int8_(position, 4, 0);
|
|
$.padLeft = reader.uint32_(position, 6, 0);
|
|
$.padRight = reader.uint32_(position, 8, 0);
|
|
$.padTop = reader.uint32_(position, 10, 0);
|
|
$.padBottom = reader.uint32_(position, 12, 0);
|
|
$.padFront = reader.uint32_(position, 14, 0);
|
|
$.padBack = reader.uint32_(position, 16, 0);
|
|
$.poolWidth = reader.uint32_(position, 18, 0);
|
|
$.poolHeight = reader.uint32_(position, 20, 0);
|
|
$.poolDepth = reader.uint32_(position, 22, 0);
|
|
$.strideX = reader.uint32_(position, 24, 0);
|
|
$.strideY = reader.uint32_(position, 26, 0);
|
|
$.strideZ = reader.uint32_(position, 28, 0);
|
|
$.outputShapeRounding = reader.int8_(position, 30, 0);
|
|
$.paddingMethod = reader.int8_(position, 32, 0);
|
|
$.dataLayout = reader.int8_(position, 34, 0);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.Pooling3dDescriptor();
|
|
$.poolType = armnnSerializer.PoolingAlgorithm[json.poolType];
|
|
$.padLeft = reader.value(json.padLeft, 0);
|
|
$.padRight = reader.value(json.padRight, 0);
|
|
$.padTop = reader.value(json.padTop, 0);
|
|
$.padBottom = reader.value(json.padBottom, 0);
|
|
$.padFront = reader.value(json.padFront, 0);
|
|
$.padBack = reader.value(json.padBack, 0);
|
|
$.poolWidth = reader.value(json.poolWidth, 0);
|
|
$.poolHeight = reader.value(json.poolHeight, 0);
|
|
$.poolDepth = reader.value(json.poolDepth, 0);
|
|
$.strideX = reader.value(json.strideX, 0);
|
|
$.strideY = reader.value(json.strideY, 0);
|
|
$.strideZ = reader.value(json.strideZ, 0);
|
|
$.outputShapeRounding = armnnSerializer.OutputShapeRounding[json.outputShapeRounding];
|
|
$.paddingMethod = armnnSerializer.PaddingMethod[json.paddingMethod];
|
|
$.dataLayout = armnnSerializer.DataLayout[json.dataLayout];
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.QuantizeLayer = class QuantizeLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.QuantizeLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.QuantizeLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.SoftmaxLayer = class SoftmaxLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.SoftmaxLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.SoftmaxDescriptor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.SoftmaxLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.SoftmaxDescriptor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.SoftmaxDescriptor = class SoftmaxDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.SoftmaxDescriptor();
|
|
$.beta = reader.float32_(position, 4, 0);
|
|
$.axis = reader.int32_(position, 6, -1);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.SoftmaxDescriptor();
|
|
$.beta = reader.value(json.beta, 0);
|
|
$.axis = reader.value(json.axis, -1);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.DepthwiseConvolution2dLayer = class DepthwiseConvolution2dLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.DepthwiseConvolution2dLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.DepthwiseConvolution2dDescriptor);
|
|
$.weights = reader.table(position, 8, armnnSerializer.ConstTensor);
|
|
$.biases = reader.table(position, 10, armnnSerializer.ConstTensor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.DepthwiseConvolution2dLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.DepthwiseConvolution2dDescriptor);
|
|
$.weights = reader.object(json.weights, armnnSerializer.ConstTensor);
|
|
$.biases = reader.object(json.biases, armnnSerializer.ConstTensor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.DepthwiseConvolution2dDescriptor = class DepthwiseConvolution2dDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.DepthwiseConvolution2dDescriptor();
|
|
$.padLeft = reader.uint32_(position, 4, 0);
|
|
$.padRight = reader.uint32_(position, 6, 0);
|
|
$.padTop = reader.uint32_(position, 8, 0);
|
|
$.padBottom = reader.uint32_(position, 10, 0);
|
|
$.strideX = reader.uint32_(position, 12, 0);
|
|
$.strideY = reader.uint32_(position, 14, 0);
|
|
$.dilationX = reader.uint32_(position, 16, 1);
|
|
$.dilationY = reader.uint32_(position, 18, 1);
|
|
$.biasEnabled = reader.bool_(position, 20, false);
|
|
$.dataLayout = reader.int8_(position, 22, 1);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.DepthwiseConvolution2dDescriptor();
|
|
$.padLeft = reader.value(json.padLeft, 0);
|
|
$.padRight = reader.value(json.padRight, 0);
|
|
$.padTop = reader.value(json.padTop, 0);
|
|
$.padBottom = reader.value(json.padBottom, 0);
|
|
$.strideX = reader.value(json.strideX, 0);
|
|
$.strideY = reader.value(json.strideY, 0);
|
|
$.dilationX = reader.value(json.dilationX, 1);
|
|
$.dilationY = reader.value(json.dilationY, 1);
|
|
$.biasEnabled = reader.value(json.biasEnabled, false);
|
|
$.dataLayout = armnnSerializer.DataLayout[json.dataLayout];
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.OutputLayer = class OutputLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.OutputLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.BindableLayerBase);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.OutputLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.BindableLayerBase);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.ReshapeLayer = class ReshapeLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.ReshapeLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.ReshapeDescriptor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.ReshapeLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.ReshapeDescriptor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.ReshapeDescriptor = class ReshapeDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.ReshapeDescriptor();
|
|
$.targetShape = reader.array(position, 4, Uint32Array);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.ReshapeDescriptor();
|
|
$.targetShape = reader.array(json.targetShape, Uint32Array);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.PermuteLayer = class PermuteLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.PermuteLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.PermuteDescriptor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.PermuteLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.PermuteDescriptor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.PermuteDescriptor = class PermuteDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.PermuteDescriptor();
|
|
$.dimMappings = reader.array(position, 4, Uint32Array);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.PermuteDescriptor();
|
|
$.dimMappings = reader.array(json.dimMappings, Uint32Array);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.ShapeLayer = class ShapeLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.ShapeLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.ShapeLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.SpaceToBatchNdLayer = class SpaceToBatchNdLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.SpaceToBatchNdLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.SpaceToBatchNdDescriptor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.SpaceToBatchNdLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.SpaceToBatchNdDescriptor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.SpaceToBatchNdDescriptor = class SpaceToBatchNdDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.SpaceToBatchNdDescriptor();
|
|
$.blockShape = reader.array(position, 4, Uint32Array);
|
|
$.padList = reader.array(position, 6, Uint32Array);
|
|
$.dataLayout = reader.int8_(position, 8, 0);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.SpaceToBatchNdDescriptor();
|
|
$.blockShape = reader.array(json.blockShape, Uint32Array);
|
|
$.padList = reader.array(json.padList, Uint32Array);
|
|
$.dataLayout = armnnSerializer.DataLayout[json.dataLayout];
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.SpaceToDepthLayer = class SpaceToDepthLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.SpaceToDepthLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.SpaceToDepthDescriptor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.SpaceToDepthLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.SpaceToDepthDescriptor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.SpaceToDepthDescriptor = class SpaceToDepthDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.SpaceToDepthDescriptor();
|
|
$.blockSize = reader.uint32_(position, 4, 0);
|
|
$.dataLayout = reader.int8_(position, 6, 0);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.SpaceToDepthDescriptor();
|
|
$.blockSize = reader.value(json.blockSize, 0);
|
|
$.dataLayout = armnnSerializer.DataLayout[json.dataLayout];
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.SubtractionLayer = class SubtractionLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.SubtractionLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.SubtractionLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.BatchToSpaceNdLayer = class BatchToSpaceNdLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.BatchToSpaceNdLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.BatchToSpaceNdDescriptor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.BatchToSpaceNdLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.BatchToSpaceNdDescriptor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.BatchToSpaceNdDescriptor = class BatchToSpaceNdDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.BatchToSpaceNdDescriptor();
|
|
$.blockShape = reader.array(position, 4, Uint32Array);
|
|
$.crops = reader.array(position, 6, Uint32Array);
|
|
$.dataLayout = reader.int8_(position, 8, 0);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.BatchToSpaceNdDescriptor();
|
|
$.blockShape = reader.array(json.blockShape, Uint32Array);
|
|
$.crops = reader.array(json.crops, Uint32Array);
|
|
$.dataLayout = armnnSerializer.DataLayout[json.dataLayout];
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.NormalizationAlgorithmChannel = {
|
|
Across: 0, '0': 'Across',
|
|
Within: 1, '1': 'Within'
|
|
};
|
|
|
|
armnnSerializer.NormalizationAlgorithmMethod = {
|
|
LocalBrightness: 0, '0': 'LocalBrightness',
|
|
LocalContrast: 1, '1': 'LocalContrast'
|
|
};
|
|
|
|
armnnSerializer.NormalizationLayer = class NormalizationLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.NormalizationLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.NormalizationDescriptor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.NormalizationLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.NormalizationDescriptor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.NormalizationDescriptor = class NormalizationDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.NormalizationDescriptor();
|
|
$.normChannelType = reader.int8_(position, 4, 0);
|
|
$.normMethodType = reader.int8_(position, 6, 0);
|
|
$.normSize = reader.uint32_(position, 8, 0);
|
|
$.alpha = reader.float32_(position, 10, 0);
|
|
$.beta = reader.float32_(position, 12, 0);
|
|
$.k = reader.float32_(position, 14, 0);
|
|
$.dataLayout = reader.int8_(position, 16, 1);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.NormalizationDescriptor();
|
|
$.normChannelType = armnnSerializer.NormalizationAlgorithmChannel[json.normChannelType];
|
|
$.normMethodType = armnnSerializer.NormalizationAlgorithmMethod[json.normMethodType];
|
|
$.normSize = reader.value(json.normSize, 0);
|
|
$.alpha = reader.value(json.alpha, 0);
|
|
$.beta = reader.value(json.beta, 0);
|
|
$.k = reader.value(json.k, 0);
|
|
$.dataLayout = armnnSerializer.DataLayout[json.dataLayout];
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.MeanLayer = class MeanLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.MeanLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.MeanDescriptor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.MeanLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.MeanDescriptor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.MeanDescriptor = class MeanDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.MeanDescriptor();
|
|
$.axis = reader.array(position, 4, Uint32Array);
|
|
$.keepDims = reader.bool_(position, 6, false);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.MeanDescriptor();
|
|
$.axis = reader.array(json.axis, Uint32Array);
|
|
$.keepDims = reader.value(json.keepDims, false);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.PadLayer = class PadLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.PadLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.PadDescriptor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.PadLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.PadDescriptor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.PaddingMode = {
|
|
Constant: 0, '0': 'Constant',
|
|
Reflect: 1, '1': 'Reflect',
|
|
Symmetric: 2, '2': 'Symmetric'
|
|
};
|
|
|
|
armnnSerializer.PadDescriptor = class PadDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.PadDescriptor();
|
|
$.padList = reader.array(position, 4, Uint32Array);
|
|
$.padValue = reader.float32_(position, 6, 0);
|
|
$.paddingMode = reader.int8_(position, 8, 0);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.PadDescriptor();
|
|
$.padList = reader.array(json.padList, Uint32Array);
|
|
$.padValue = reader.value(json.padValue, 0);
|
|
$.paddingMode = armnnSerializer.PaddingMode[json.paddingMode];
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.RsqrtLayer = class RsqrtLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.RsqrtLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.RsqrtLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.BatchNormalizationLayer = class BatchNormalizationLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.BatchNormalizationLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.BatchNormalizationDescriptor);
|
|
$.mean = reader.table(position, 8, armnnSerializer.ConstTensor);
|
|
$.variance = reader.table(position, 10, armnnSerializer.ConstTensor);
|
|
$.beta = reader.table(position, 12, armnnSerializer.ConstTensor);
|
|
$.gamma = reader.table(position, 14, armnnSerializer.ConstTensor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.BatchNormalizationLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.BatchNormalizationDescriptor);
|
|
$.mean = reader.object(json.mean, armnnSerializer.ConstTensor);
|
|
$.variance = reader.object(json.variance, armnnSerializer.ConstTensor);
|
|
$.beta = reader.object(json.beta, armnnSerializer.ConstTensor);
|
|
$.gamma = reader.object(json.gamma, armnnSerializer.ConstTensor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.BatchNormalizationDescriptor = class BatchNormalizationDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.BatchNormalizationDescriptor();
|
|
$.eps = reader.float32_(position, 4, 0);
|
|
$.dataLayout = reader.int8_(position, 6, 0);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.BatchNormalizationDescriptor();
|
|
$.eps = reader.value(json.eps, 0);
|
|
$.dataLayout = armnnSerializer.DataLayout[json.dataLayout];
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.ResizeBilinearLayer = class ResizeBilinearLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.ResizeBilinearLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.ResizeBilinearDescriptor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.ResizeBilinearLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.ResizeBilinearDescriptor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.ResizeBilinearDescriptor = class ResizeBilinearDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.ResizeBilinearDescriptor();
|
|
$.targetWidth = reader.uint32_(position, 4, 0);
|
|
$.targetHeight = reader.uint32_(position, 6, 0);
|
|
$.dataLayout = reader.int8_(position, 8, 0);
|
|
$.alignCorners = reader.bool_(position, 10, false);
|
|
$.halfPixelCenters = reader.bool_(position, 12, false);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.ResizeBilinearDescriptor();
|
|
$.targetWidth = reader.value(json.targetWidth, 0);
|
|
$.targetHeight = reader.value(json.targetHeight, 0);
|
|
$.dataLayout = armnnSerializer.DataLayout[json.dataLayout];
|
|
$.alignCorners = reader.value(json.alignCorners, false);
|
|
$.halfPixelCenters = reader.value(json.halfPixelCenters, false);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.SliceLayer = class SliceLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.SliceLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.SliceDescriptor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.SliceLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.SliceDescriptor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.SliceDescriptor = class SliceDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.SliceDescriptor();
|
|
$.begin = reader.array(position, 4, Uint32Array);
|
|
$.size = reader.array(position, 6, Uint32Array);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.SliceDescriptor();
|
|
$.begin = reader.array(json.begin, Uint32Array);
|
|
$.size = reader.array(json.size, Uint32Array);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.StridedSliceLayer = class StridedSliceLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.StridedSliceLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.StridedSliceDescriptor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.StridedSliceLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.StridedSliceDescriptor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.StridedSliceDescriptor = class StridedSliceDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.StridedSliceDescriptor();
|
|
$.begin = reader.array(position, 4, Int32Array);
|
|
$.end = reader.array(position, 6, Int32Array);
|
|
$.stride = reader.array(position, 8, Int32Array);
|
|
$.beginMask = reader.int32_(position, 10, 0);
|
|
$.endMask = reader.int32_(position, 12, 0);
|
|
$.shrinkAxisMask = reader.int32_(position, 14, 0);
|
|
$.ellipsisMask = reader.int32_(position, 16, 0);
|
|
$.newAxisMask = reader.int32_(position, 18, 0);
|
|
$.dataLayout = reader.int8_(position, 20, 0);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.StridedSliceDescriptor();
|
|
$.begin = reader.array(json.begin, Int32Array);
|
|
$.end = reader.array(json.end, Int32Array);
|
|
$.stride = reader.array(json.stride, Int32Array);
|
|
$.beginMask = reader.value(json.beginMask, 0);
|
|
$.endMask = reader.value(json.endMask, 0);
|
|
$.shrinkAxisMask = reader.value(json.shrinkAxisMask, 0);
|
|
$.ellipsisMask = reader.value(json.ellipsisMask, 0);
|
|
$.newAxisMask = reader.value(json.newAxisMask, 0);
|
|
$.dataLayout = armnnSerializer.DataLayout[json.dataLayout];
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.ConcatLayer = class ConcatLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.ConcatLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.OriginsDescriptor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.ConcatLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.OriginsDescriptor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.MergerLayer = class MergerLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.MergerLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.OriginsDescriptor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.MergerLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.OriginsDescriptor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.UintVector = class UintVector {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.UintVector();
|
|
$.data = reader.array(position, 4, Uint32Array);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.UintVector();
|
|
$.data = reader.array(json.data, Uint32Array);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.OriginsDescriptor = class OriginsDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.OriginsDescriptor();
|
|
$.concatAxis = reader.uint32_(position, 4, 0);
|
|
$.numViews = reader.uint32_(position, 6, 0);
|
|
$.numDimensions = reader.uint32_(position, 8, 0);
|
|
$.viewOrigins = reader.tables(position, 10, armnnSerializer.UintVector);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.OriginsDescriptor();
|
|
$.concatAxis = reader.value(json.concatAxis, 0);
|
|
$.numViews = reader.value(json.numViews, 0);
|
|
$.numDimensions = reader.value(json.numDimensions, 0);
|
|
$.viewOrigins = reader.objects(json.viewOrigins, armnnSerializer.UintVector);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.ViewsDescriptor = class ViewsDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.ViewsDescriptor();
|
|
$.origins = reader.table(position, 4, armnnSerializer.OriginsDescriptor);
|
|
$.viewSizes = reader.tables(position, 6, armnnSerializer.UintVector);
|
|
$.hasAxis = reader.bool_(position, 8, false);
|
|
$.axis = reader.int32_(position, 10, 0);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.ViewsDescriptor();
|
|
$.origins = reader.object(json.origins, armnnSerializer.OriginsDescriptor);
|
|
$.viewSizes = reader.objects(json.viewSizes, armnnSerializer.UintVector);
|
|
$.hasAxis = reader.value(json.hasAxis, false);
|
|
$.axis = reader.value(json.axis, 0);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.SplitterLayer = class SplitterLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.SplitterLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.ViewsDescriptor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.SplitterLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.ViewsDescriptor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.DetectionPostProcessLayer = class DetectionPostProcessLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.DetectionPostProcessLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.DetectionPostProcessDescriptor);
|
|
$.anchors = reader.table(position, 8, armnnSerializer.ConstTensor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.DetectionPostProcessLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.DetectionPostProcessDescriptor);
|
|
$.anchors = reader.object(json.anchors, armnnSerializer.ConstTensor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.DetectionPostProcessDescriptor = class DetectionPostProcessDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.DetectionPostProcessDescriptor();
|
|
$.maxDetections = reader.uint32_(position, 4, 0);
|
|
$.maxClassesPerDetection = reader.uint32_(position, 6, 0);
|
|
$.detectionsPerClass = reader.uint32_(position, 8, 0);
|
|
$.nmsScoreThreshold = reader.float32_(position, 10, 0);
|
|
$.nmsIouThreshold = reader.float32_(position, 12, 0);
|
|
$.numClasses = reader.uint32_(position, 14, 0);
|
|
$.useRegularNms = reader.bool_(position, 16, false);
|
|
$.scaleX = reader.float32_(position, 18, 0);
|
|
$.scaleY = reader.float32_(position, 20, 0);
|
|
$.scaleW = reader.float32_(position, 22, 0);
|
|
$.scaleH = reader.float32_(position, 24, 0);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.DetectionPostProcessDescriptor();
|
|
$.maxDetections = reader.value(json.maxDetections, 0);
|
|
$.maxClassesPerDetection = reader.value(json.maxClassesPerDetection, 0);
|
|
$.detectionsPerClass = reader.value(json.detectionsPerClass, 0);
|
|
$.nmsScoreThreshold = reader.value(json.nmsScoreThreshold, 0);
|
|
$.nmsIouThreshold = reader.value(json.nmsIouThreshold, 0);
|
|
$.numClasses = reader.value(json.numClasses, 0);
|
|
$.useRegularNms = reader.value(json.useRegularNms, false);
|
|
$.scaleX = reader.value(json.scaleX, 0);
|
|
$.scaleY = reader.value(json.scaleY, 0);
|
|
$.scaleW = reader.value(json.scaleW, 0);
|
|
$.scaleH = reader.value(json.scaleH, 0);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.LstmInputParams = class LstmInputParams {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.LstmInputParams();
|
|
$.inputToForgetWeights = reader.table(position, 4, armnnSerializer.ConstTensor);
|
|
$.inputToCellWeights = reader.table(position, 6, armnnSerializer.ConstTensor);
|
|
$.inputToOutputWeights = reader.table(position, 8, armnnSerializer.ConstTensor);
|
|
$.recurrentToForgetWeights = reader.table(position, 10, armnnSerializer.ConstTensor);
|
|
$.recurrentToCellWeights = reader.table(position, 12, armnnSerializer.ConstTensor);
|
|
$.recurrentToOutputWeights = reader.table(position, 14, armnnSerializer.ConstTensor);
|
|
$.forgetGateBias = reader.table(position, 16, armnnSerializer.ConstTensor);
|
|
$.cellBias = reader.table(position, 18, armnnSerializer.ConstTensor);
|
|
$.outputGateBias = reader.table(position, 20, armnnSerializer.ConstTensor);
|
|
$.inputToInputWeights = reader.table(position, 22, armnnSerializer.ConstTensor);
|
|
$.recurrentToInputWeights = reader.table(position, 24, armnnSerializer.ConstTensor);
|
|
$.cellToInputWeights = reader.table(position, 26, armnnSerializer.ConstTensor);
|
|
$.inputGateBias = reader.table(position, 28, armnnSerializer.ConstTensor);
|
|
$.projectionWeights = reader.table(position, 30, armnnSerializer.ConstTensor);
|
|
$.projectionBias = reader.table(position, 32, armnnSerializer.ConstTensor);
|
|
$.cellToForgetWeights = reader.table(position, 34, armnnSerializer.ConstTensor);
|
|
$.cellToOutputWeights = reader.table(position, 36, armnnSerializer.ConstTensor);
|
|
$.inputLayerNormWeights = reader.table(position, 38, armnnSerializer.ConstTensor);
|
|
$.forgetLayerNormWeights = reader.table(position, 40, armnnSerializer.ConstTensor);
|
|
$.cellLayerNormWeights = reader.table(position, 42, armnnSerializer.ConstTensor);
|
|
$.outputLayerNormWeights = reader.table(position, 44, armnnSerializer.ConstTensor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.LstmInputParams();
|
|
$.inputToForgetWeights = reader.object(json.inputToForgetWeights, armnnSerializer.ConstTensor);
|
|
$.inputToCellWeights = reader.object(json.inputToCellWeights, armnnSerializer.ConstTensor);
|
|
$.inputToOutputWeights = reader.object(json.inputToOutputWeights, armnnSerializer.ConstTensor);
|
|
$.recurrentToForgetWeights = reader.object(json.recurrentToForgetWeights, armnnSerializer.ConstTensor);
|
|
$.recurrentToCellWeights = reader.object(json.recurrentToCellWeights, armnnSerializer.ConstTensor);
|
|
$.recurrentToOutputWeights = reader.object(json.recurrentToOutputWeights, armnnSerializer.ConstTensor);
|
|
$.forgetGateBias = reader.object(json.forgetGateBias, armnnSerializer.ConstTensor);
|
|
$.cellBias = reader.object(json.cellBias, armnnSerializer.ConstTensor);
|
|
$.outputGateBias = reader.object(json.outputGateBias, armnnSerializer.ConstTensor);
|
|
$.inputToInputWeights = reader.object(json.inputToInputWeights, armnnSerializer.ConstTensor);
|
|
$.recurrentToInputWeights = reader.object(json.recurrentToInputWeights, armnnSerializer.ConstTensor);
|
|
$.cellToInputWeights = reader.object(json.cellToInputWeights, armnnSerializer.ConstTensor);
|
|
$.inputGateBias = reader.object(json.inputGateBias, armnnSerializer.ConstTensor);
|
|
$.projectionWeights = reader.object(json.projectionWeights, armnnSerializer.ConstTensor);
|
|
$.projectionBias = reader.object(json.projectionBias, armnnSerializer.ConstTensor);
|
|
$.cellToForgetWeights = reader.object(json.cellToForgetWeights, armnnSerializer.ConstTensor);
|
|
$.cellToOutputWeights = reader.object(json.cellToOutputWeights, armnnSerializer.ConstTensor);
|
|
$.inputLayerNormWeights = reader.object(json.inputLayerNormWeights, armnnSerializer.ConstTensor);
|
|
$.forgetLayerNormWeights = reader.object(json.forgetLayerNormWeights, armnnSerializer.ConstTensor);
|
|
$.cellLayerNormWeights = reader.object(json.cellLayerNormWeights, armnnSerializer.ConstTensor);
|
|
$.outputLayerNormWeights = reader.object(json.outputLayerNormWeights, armnnSerializer.ConstTensor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.LstmDescriptor = class LstmDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.LstmDescriptor();
|
|
$.activationFunc = reader.uint32_(position, 4, 0);
|
|
$.clippingThresCell = reader.float32_(position, 6, 0);
|
|
$.clippingThresProj = reader.float32_(position, 8, 0);
|
|
$.cifgEnabled = reader.bool_(position, 10, true);
|
|
$.peepholeEnabled = reader.bool_(position, 12, false);
|
|
$.projectionEnabled = reader.bool_(position, 14, false);
|
|
$.layerNormEnabled = reader.bool_(position, 16, false);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.LstmDescriptor();
|
|
$.activationFunc = reader.value(json.activationFunc, 0);
|
|
$.clippingThresCell = reader.value(json.clippingThresCell, 0);
|
|
$.clippingThresProj = reader.value(json.clippingThresProj, 0);
|
|
$.cifgEnabled = reader.value(json.cifgEnabled, true);
|
|
$.peepholeEnabled = reader.value(json.peepholeEnabled, false);
|
|
$.projectionEnabled = reader.value(json.projectionEnabled, false);
|
|
$.layerNormEnabled = reader.value(json.layerNormEnabled, false);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.LstmLayer = class LstmLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.LstmLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.LstmDescriptor);
|
|
$.inputParams = reader.table(position, 8, armnnSerializer.LstmInputParams);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.LstmLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.LstmDescriptor);
|
|
$.inputParams = reader.object(json.inputParams, armnnSerializer.LstmInputParams);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.QLstmInputParams = class QLstmInputParams {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.QLstmInputParams();
|
|
$.inputToForgetWeights = reader.table(position, 4, armnnSerializer.ConstTensor);
|
|
$.inputToCellWeights = reader.table(position, 6, armnnSerializer.ConstTensor);
|
|
$.inputToOutputWeights = reader.table(position, 8, armnnSerializer.ConstTensor);
|
|
$.recurrentToForgetWeights = reader.table(position, 10, armnnSerializer.ConstTensor);
|
|
$.recurrentToCellWeights = reader.table(position, 12, armnnSerializer.ConstTensor);
|
|
$.recurrentToOutputWeights = reader.table(position, 14, armnnSerializer.ConstTensor);
|
|
$.forgetGateBias = reader.table(position, 16, armnnSerializer.ConstTensor);
|
|
$.cellBias = reader.table(position, 18, armnnSerializer.ConstTensor);
|
|
$.outputGateBias = reader.table(position, 20, armnnSerializer.ConstTensor);
|
|
$.inputToInputWeights = reader.table(position, 22, armnnSerializer.ConstTensor);
|
|
$.recurrentToInputWeights = reader.table(position, 24, armnnSerializer.ConstTensor);
|
|
$.inputGateBias = reader.table(position, 26, armnnSerializer.ConstTensor);
|
|
$.projectionWeights = reader.table(position, 28, armnnSerializer.ConstTensor);
|
|
$.projectionBias = reader.table(position, 30, armnnSerializer.ConstTensor);
|
|
$.cellToInputWeights = reader.table(position, 32, armnnSerializer.ConstTensor);
|
|
$.cellToForgetWeights = reader.table(position, 34, armnnSerializer.ConstTensor);
|
|
$.cellToOutputWeights = reader.table(position, 36, armnnSerializer.ConstTensor);
|
|
$.inputLayerNormWeights = reader.table(position, 38, armnnSerializer.ConstTensor);
|
|
$.forgetLayerNormWeights = reader.table(position, 40, armnnSerializer.ConstTensor);
|
|
$.cellLayerNormWeights = reader.table(position, 42, armnnSerializer.ConstTensor);
|
|
$.outputLayerNormWeights = reader.table(position, 44, armnnSerializer.ConstTensor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.QLstmInputParams();
|
|
$.inputToForgetWeights = reader.object(json.inputToForgetWeights, armnnSerializer.ConstTensor);
|
|
$.inputToCellWeights = reader.object(json.inputToCellWeights, armnnSerializer.ConstTensor);
|
|
$.inputToOutputWeights = reader.object(json.inputToOutputWeights, armnnSerializer.ConstTensor);
|
|
$.recurrentToForgetWeights = reader.object(json.recurrentToForgetWeights, armnnSerializer.ConstTensor);
|
|
$.recurrentToCellWeights = reader.object(json.recurrentToCellWeights, armnnSerializer.ConstTensor);
|
|
$.recurrentToOutputWeights = reader.object(json.recurrentToOutputWeights, armnnSerializer.ConstTensor);
|
|
$.forgetGateBias = reader.object(json.forgetGateBias, armnnSerializer.ConstTensor);
|
|
$.cellBias = reader.object(json.cellBias, armnnSerializer.ConstTensor);
|
|
$.outputGateBias = reader.object(json.outputGateBias, armnnSerializer.ConstTensor);
|
|
$.inputToInputWeights = reader.object(json.inputToInputWeights, armnnSerializer.ConstTensor);
|
|
$.recurrentToInputWeights = reader.object(json.recurrentToInputWeights, armnnSerializer.ConstTensor);
|
|
$.inputGateBias = reader.object(json.inputGateBias, armnnSerializer.ConstTensor);
|
|
$.projectionWeights = reader.object(json.projectionWeights, armnnSerializer.ConstTensor);
|
|
$.projectionBias = reader.object(json.projectionBias, armnnSerializer.ConstTensor);
|
|
$.cellToInputWeights = reader.object(json.cellToInputWeights, armnnSerializer.ConstTensor);
|
|
$.cellToForgetWeights = reader.object(json.cellToForgetWeights, armnnSerializer.ConstTensor);
|
|
$.cellToOutputWeights = reader.object(json.cellToOutputWeights, armnnSerializer.ConstTensor);
|
|
$.inputLayerNormWeights = reader.object(json.inputLayerNormWeights, armnnSerializer.ConstTensor);
|
|
$.forgetLayerNormWeights = reader.object(json.forgetLayerNormWeights, armnnSerializer.ConstTensor);
|
|
$.cellLayerNormWeights = reader.object(json.cellLayerNormWeights, armnnSerializer.ConstTensor);
|
|
$.outputLayerNormWeights = reader.object(json.outputLayerNormWeights, armnnSerializer.ConstTensor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.QLstmDescriptor = class QLstmDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.QLstmDescriptor();
|
|
$.cifgEnabled = reader.bool_(position, 4, true);
|
|
$.peepholeEnabled = reader.bool_(position, 6, false);
|
|
$.projectionEnabled = reader.bool_(position, 8, false);
|
|
$.layerNormEnabled = reader.bool_(position, 10, false);
|
|
$.cellClip = reader.float32_(position, 12, 0);
|
|
$.projectionClip = reader.float32_(position, 14, 0);
|
|
$.inputIntermediateScale = reader.float32_(position, 16, 0);
|
|
$.forgetIntermediateScale = reader.float32_(position, 18, 0);
|
|
$.cellIntermediateScale = reader.float32_(position, 20, 0);
|
|
$.outputIntermediateScale = reader.float32_(position, 22, 0);
|
|
$.hiddenStateZeroPoint = reader.int32_(position, 24, 0);
|
|
$.hiddenStateScale = reader.float32_(position, 26, 0);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.QLstmDescriptor();
|
|
$.cifgEnabled = reader.value(json.cifgEnabled, true);
|
|
$.peepholeEnabled = reader.value(json.peepholeEnabled, false);
|
|
$.projectionEnabled = reader.value(json.projectionEnabled, false);
|
|
$.layerNormEnabled = reader.value(json.layerNormEnabled, false);
|
|
$.cellClip = reader.value(json.cellClip, 0);
|
|
$.projectionClip = reader.value(json.projectionClip, 0);
|
|
$.inputIntermediateScale = reader.value(json.inputIntermediateScale, 0);
|
|
$.forgetIntermediateScale = reader.value(json.forgetIntermediateScale, 0);
|
|
$.cellIntermediateScale = reader.value(json.cellIntermediateScale, 0);
|
|
$.outputIntermediateScale = reader.value(json.outputIntermediateScale, 0);
|
|
$.hiddenStateZeroPoint = reader.value(json.hiddenStateZeroPoint, 0);
|
|
$.hiddenStateScale = reader.value(json.hiddenStateScale, 0);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.QLstmLayer = class QLstmLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.QLstmLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.QLstmDescriptor);
|
|
$.inputParams = reader.table(position, 8, armnnSerializer.QLstmInputParams);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.QLstmLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.QLstmDescriptor);
|
|
$.inputParams = reader.object(json.inputParams, armnnSerializer.QLstmInputParams);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.QuantizedLstmInputParams = class QuantizedLstmInputParams {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.QuantizedLstmInputParams();
|
|
$.inputToInputWeights = reader.table(position, 4, armnnSerializer.ConstTensor);
|
|
$.inputToForgetWeights = reader.table(position, 6, armnnSerializer.ConstTensor);
|
|
$.inputToCellWeights = reader.table(position, 8, armnnSerializer.ConstTensor);
|
|
$.inputToOutputWeights = reader.table(position, 10, armnnSerializer.ConstTensor);
|
|
$.recurrentToInputWeights = reader.table(position, 12, armnnSerializer.ConstTensor);
|
|
$.recurrentToForgetWeights = reader.table(position, 14, armnnSerializer.ConstTensor);
|
|
$.recurrentToCellWeights = reader.table(position, 16, armnnSerializer.ConstTensor);
|
|
$.recurrentToOutputWeights = reader.table(position, 18, armnnSerializer.ConstTensor);
|
|
$.inputGateBias = reader.table(position, 20, armnnSerializer.ConstTensor);
|
|
$.forgetGateBias = reader.table(position, 22, armnnSerializer.ConstTensor);
|
|
$.cellBias = reader.table(position, 24, armnnSerializer.ConstTensor);
|
|
$.outputGateBias = reader.table(position, 26, armnnSerializer.ConstTensor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.QuantizedLstmInputParams();
|
|
$.inputToInputWeights = reader.object(json.inputToInputWeights, armnnSerializer.ConstTensor);
|
|
$.inputToForgetWeights = reader.object(json.inputToForgetWeights, armnnSerializer.ConstTensor);
|
|
$.inputToCellWeights = reader.object(json.inputToCellWeights, armnnSerializer.ConstTensor);
|
|
$.inputToOutputWeights = reader.object(json.inputToOutputWeights, armnnSerializer.ConstTensor);
|
|
$.recurrentToInputWeights = reader.object(json.recurrentToInputWeights, armnnSerializer.ConstTensor);
|
|
$.recurrentToForgetWeights = reader.object(json.recurrentToForgetWeights, armnnSerializer.ConstTensor);
|
|
$.recurrentToCellWeights = reader.object(json.recurrentToCellWeights, armnnSerializer.ConstTensor);
|
|
$.recurrentToOutputWeights = reader.object(json.recurrentToOutputWeights, armnnSerializer.ConstTensor);
|
|
$.inputGateBias = reader.object(json.inputGateBias, armnnSerializer.ConstTensor);
|
|
$.forgetGateBias = reader.object(json.forgetGateBias, armnnSerializer.ConstTensor);
|
|
$.cellBias = reader.object(json.cellBias, armnnSerializer.ConstTensor);
|
|
$.outputGateBias = reader.object(json.outputGateBias, armnnSerializer.ConstTensor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.QuantizedLstmLayer = class QuantizedLstmLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.QuantizedLstmLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.inputParams = reader.table(position, 6, armnnSerializer.QuantizedLstmInputParams);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.QuantizedLstmLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.inputParams = reader.object(json.inputParams, armnnSerializer.QuantizedLstmInputParams);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.DequantizeLayer = class DequantizeLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.DequantizeLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.DequantizeLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.MergeLayer = class MergeLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.MergeLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.MergeLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.SwitchLayer = class SwitchLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.SwitchLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.SwitchLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.PreluLayer = class PreluLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.PreluLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.PreluLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.TransposeConvolution2dLayer = class TransposeConvolution2dLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.TransposeConvolution2dLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.TransposeConvolution2dDescriptor);
|
|
$.weights = reader.table(position, 8, armnnSerializer.ConstTensor);
|
|
$.biases = reader.table(position, 10, armnnSerializer.ConstTensor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.TransposeConvolution2dLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.TransposeConvolution2dDescriptor);
|
|
$.weights = reader.object(json.weights, armnnSerializer.ConstTensor);
|
|
$.biases = reader.object(json.biases, armnnSerializer.ConstTensor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.TransposeConvolution2dDescriptor = class TransposeConvolution2dDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.TransposeConvolution2dDescriptor();
|
|
$.padLeft = reader.uint32_(position, 4, 0);
|
|
$.padRight = reader.uint32_(position, 6, 0);
|
|
$.padTop = reader.uint32_(position, 8, 0);
|
|
$.padBottom = reader.uint32_(position, 10, 0);
|
|
$.strideX = reader.uint32_(position, 12, 0);
|
|
$.strideY = reader.uint32_(position, 14, 0);
|
|
$.biasEnabled = reader.bool_(position, 16, false);
|
|
$.dataLayout = reader.int8_(position, 18, 1);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.TransposeConvolution2dDescriptor();
|
|
$.padLeft = reader.value(json.padLeft, 0);
|
|
$.padRight = reader.value(json.padRight, 0);
|
|
$.padTop = reader.value(json.padTop, 0);
|
|
$.padBottom = reader.value(json.padBottom, 0);
|
|
$.strideX = reader.value(json.strideX, 0);
|
|
$.strideY = reader.value(json.strideY, 0);
|
|
$.biasEnabled = reader.value(json.biasEnabled, false);
|
|
$.dataLayout = armnnSerializer.DataLayout[json.dataLayout];
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.TransposeLayer = class TransposeLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.TransposeLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.TransposeDescriptor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.TransposeLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.TransposeDescriptor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.TransposeDescriptor = class TransposeDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.TransposeDescriptor();
|
|
$.dimMappings = reader.array(position, 4, Uint32Array);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.TransposeDescriptor();
|
|
$.dimMappings = reader.array(json.dimMappings, Uint32Array);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.ResizeLayer = class ResizeLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.ResizeLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.ResizeDescriptor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.ResizeLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.ResizeDescriptor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.ResizeDescriptor = class ResizeDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.ResizeDescriptor();
|
|
$.targetHeight = reader.uint32_(position, 4, 0);
|
|
$.targetWidth = reader.uint32_(position, 6, 0);
|
|
$.method = reader.int8_(position, 8, 0);
|
|
$.dataLayout = reader.int8_(position, 10, 0);
|
|
$.alignCorners = reader.bool_(position, 12, false);
|
|
$.halfPixelCenters = reader.bool_(position, 14, false);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.ResizeDescriptor();
|
|
$.targetHeight = reader.value(json.targetHeight, 0);
|
|
$.targetWidth = reader.value(json.targetWidth, 0);
|
|
$.method = armnnSerializer.ResizeMethod[json.method];
|
|
$.dataLayout = armnnSerializer.DataLayout[json.dataLayout];
|
|
$.alignCorners = reader.value(json.alignCorners, false);
|
|
$.halfPixelCenters = reader.value(json.halfPixelCenters, false);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.ReverseV2Layer = class ReverseV2Layer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.ReverseV2Layer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.ReverseV2Layer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.StackLayer = class StackLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.StackLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.StackDescriptor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.StackLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.StackDescriptor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.StackDescriptor = class StackDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.StackDescriptor();
|
|
$.axis = reader.uint32_(position, 4, 0);
|
|
$.numInputs = reader.uint32_(position, 6, 0);
|
|
$.inputShape = reader.array(position, 8, Uint32Array);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.StackDescriptor();
|
|
$.axis = reader.value(json.axis, 0);
|
|
$.numInputs = reader.value(json.numInputs, 0);
|
|
$.inputShape = reader.array(json.inputShape, Uint32Array);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.StandInDescriptor = class StandInDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.StandInDescriptor();
|
|
$.numInputs = reader.uint32_(position, 4, 0);
|
|
$.numOutputs = reader.uint32_(position, 6, 0);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.StandInDescriptor();
|
|
$.numInputs = reader.value(json.numInputs, 0);
|
|
$.numOutputs = reader.value(json.numOutputs, 0);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.StandInLayer = class StandInLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.StandInLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.StandInDescriptor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.StandInLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.StandInDescriptor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.RankLayer = class RankLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.RankLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.RankLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.ReduceLayer = class ReduceLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.ReduceLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.ReduceDescriptor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.ReduceLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.ReduceDescriptor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.ReduceDescriptor = class ReduceDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.ReduceDescriptor();
|
|
$.keepDims = reader.bool_(position, 4, false);
|
|
$.axis = reader.array(position, 6, Uint32Array);
|
|
$.reduceOperation = reader.int8_(position, 8, 0);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.ReduceDescriptor();
|
|
$.keepDims = reader.value(json.keepDims, false);
|
|
$.axis = reader.array(json.axis, Uint32Array);
|
|
$.reduceOperation = armnnSerializer.ReduceOperation[json.reduceOperation];
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.UnidirectionalSequenceLstmDescriptor = class UnidirectionalSequenceLstmDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.UnidirectionalSequenceLstmDescriptor();
|
|
$.activationFunc = reader.uint32_(position, 4, 0);
|
|
$.clippingThresCell = reader.float32_(position, 6, 0);
|
|
$.clippingThresProj = reader.float32_(position, 8, 0);
|
|
$.cifgEnabled = reader.bool_(position, 10, true);
|
|
$.peepholeEnabled = reader.bool_(position, 12, false);
|
|
$.projectionEnabled = reader.bool_(position, 14, false);
|
|
$.layerNormEnabled = reader.bool_(position, 16, false);
|
|
$.timeMajor = reader.bool_(position, 18, false);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.UnidirectionalSequenceLstmDescriptor();
|
|
$.activationFunc = reader.value(json.activationFunc, 0);
|
|
$.clippingThresCell = reader.value(json.clippingThresCell, 0);
|
|
$.clippingThresProj = reader.value(json.clippingThresProj, 0);
|
|
$.cifgEnabled = reader.value(json.cifgEnabled, true);
|
|
$.peepholeEnabled = reader.value(json.peepholeEnabled, false);
|
|
$.projectionEnabled = reader.value(json.projectionEnabled, false);
|
|
$.layerNormEnabled = reader.value(json.layerNormEnabled, false);
|
|
$.timeMajor = reader.value(json.timeMajor, false);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.UnidirectionalSequenceLstmLayer = class UnidirectionalSequenceLstmLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.UnidirectionalSequenceLstmLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.UnidirectionalSequenceLstmDescriptor);
|
|
$.inputParams = reader.table(position, 8, armnnSerializer.LstmInputParams);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.UnidirectionalSequenceLstmLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.UnidirectionalSequenceLstmDescriptor);
|
|
$.inputParams = reader.object(json.inputParams, armnnSerializer.LstmInputParams);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.BatchMatMulDescriptor = class BatchMatMulDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.BatchMatMulDescriptor();
|
|
$.transposeX = reader.bool_(position, 4, false);
|
|
$.transposeY = reader.bool_(position, 6, false);
|
|
$.adjointX = reader.bool_(position, 8, false);
|
|
$.adjointY = reader.bool_(position, 10, false);
|
|
$.dataLayoutX = reader.int8_(position, 12, 1);
|
|
$.dataLayoutY = reader.int8_(position, 14, 1);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.BatchMatMulDescriptor();
|
|
$.transposeX = reader.value(json.transposeX, false);
|
|
$.transposeY = reader.value(json.transposeY, false);
|
|
$.adjointX = reader.value(json.adjointX, false);
|
|
$.adjointY = reader.value(json.adjointY, false);
|
|
$.dataLayoutX = armnnSerializer.DataLayout[json.dataLayoutX];
|
|
$.dataLayoutY = armnnSerializer.DataLayout[json.dataLayoutY];
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.BatchMatMulLayer = class BatchMatMulLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.BatchMatMulLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.BatchMatMulDescriptor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.BatchMatMulLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.BatchMatMulDescriptor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.TileDescriptor = class TileDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.TileDescriptor();
|
|
$.m_Multiples = reader.array(position, 4, Uint32Array);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.TileDescriptor();
|
|
$.m_Multiples = reader.array(json.m_Multiples, Uint32Array);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.TileLayer = class TileLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.TileLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.TileDescriptor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.TileLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.TileDescriptor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.ScatterNdDescriptor = class ScatterNdDescriptor {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.ScatterNdDescriptor();
|
|
$.m_Function = reader.int8_(position, 4, 0);
|
|
$.m_InputEnabled = reader.bool_(position, 6, true);
|
|
$.m_Axis = reader.int32_(position, 8, 0);
|
|
$.m_AxisEnabled = reader.bool_(position, 10, false);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.ScatterNdDescriptor();
|
|
$.m_Function = armnnSerializer.ScatterNdFunction[json.m_Function];
|
|
$.m_InputEnabled = reader.value(json.m_InputEnabled, true);
|
|
$.m_Axis = reader.value(json.m_Axis, 0);
|
|
$.m_AxisEnabled = reader.value(json.m_AxisEnabled, false);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.ScatterNdLayer = class ScatterNdLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.ScatterNdLayer();
|
|
$.base = reader.table(position, 4, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.table(position, 6, armnnSerializer.ScatterNdDescriptor);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.ScatterNdLayer();
|
|
$.base = reader.object(json.base, armnnSerializer.LayerBase);
|
|
$.descriptor = reader.object(json.descriptor, armnnSerializer.ScatterNdDescriptor);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.Layer = class {
|
|
|
|
static decode(reader, position, type) {
|
|
switch (type) {
|
|
case 1: return armnnSerializer.ActivationLayer.decode(reader, position);
|
|
case 2: return armnnSerializer.AdditionLayer.decode(reader, position);
|
|
case 3: return armnnSerializer.BatchToSpaceNdLayer.decode(reader, position);
|
|
case 4: return armnnSerializer.BatchNormalizationLayer.decode(reader, position);
|
|
case 5: return armnnSerializer.ConstantLayer.decode(reader, position);
|
|
case 6: return armnnSerializer.Convolution2dLayer.decode(reader, position);
|
|
case 7: return armnnSerializer.DepthwiseConvolution2dLayer.decode(reader, position);
|
|
case 8: return armnnSerializer.FullyConnectedLayer.decode(reader, position);
|
|
case 9: return armnnSerializer.InputLayer.decode(reader, position);
|
|
case 10: return armnnSerializer.MultiplicationLayer.decode(reader, position);
|
|
case 11: return armnnSerializer.OutputLayer.decode(reader, position);
|
|
case 12: return armnnSerializer.PermuteLayer.decode(reader, position);
|
|
case 13: return armnnSerializer.Pooling2dLayer.decode(reader, position);
|
|
case 14: return armnnSerializer.ReshapeLayer.decode(reader, position);
|
|
case 15: return armnnSerializer.SoftmaxLayer.decode(reader, position);
|
|
case 16: return armnnSerializer.SpaceToBatchNdLayer.decode(reader, position);
|
|
case 17: return armnnSerializer.DivisionLayer.decode(reader, position);
|
|
case 18: return armnnSerializer.MinimumLayer.decode(reader, position);
|
|
case 19: return armnnSerializer.EqualLayer.decode(reader, position);
|
|
case 20: return armnnSerializer.MaximumLayer.decode(reader, position);
|
|
case 21: return armnnSerializer.NormalizationLayer.decode(reader, position);
|
|
case 22: return armnnSerializer.PadLayer.decode(reader, position);
|
|
case 23: return armnnSerializer.RsqrtLayer.decode(reader, position);
|
|
case 24: return armnnSerializer.FloorLayer.decode(reader, position);
|
|
case 25: return armnnSerializer.GreaterLayer.decode(reader, position);
|
|
case 26: return armnnSerializer.ResizeBilinearLayer.decode(reader, position);
|
|
case 27: return armnnSerializer.SubtractionLayer.decode(reader, position);
|
|
case 28: return armnnSerializer.StridedSliceLayer.decode(reader, position);
|
|
case 29: return armnnSerializer.GatherLayer.decode(reader, position);
|
|
case 30: return armnnSerializer.MeanLayer.decode(reader, position);
|
|
case 31: return armnnSerializer.MergerLayer.decode(reader, position);
|
|
case 32: return armnnSerializer.L2NormalizationLayer.decode(reader, position);
|
|
case 33: return armnnSerializer.SplitterLayer.decode(reader, position);
|
|
case 34: return armnnSerializer.DetectionPostProcessLayer.decode(reader, position);
|
|
case 35: return armnnSerializer.LstmLayer.decode(reader, position);
|
|
case 36: return armnnSerializer.QuantizedLstmLayer.decode(reader, position);
|
|
case 37: return armnnSerializer.QuantizeLayer.decode(reader, position);
|
|
case 38: return armnnSerializer.DequantizeLayer.decode(reader, position);
|
|
case 39: return armnnSerializer.MergeLayer.decode(reader, position);
|
|
case 40: return armnnSerializer.SwitchLayer.decode(reader, position);
|
|
case 41: return armnnSerializer.ConcatLayer.decode(reader, position);
|
|
case 42: return armnnSerializer.SpaceToDepthLayer.decode(reader, position);
|
|
case 43: return armnnSerializer.PreluLayer.decode(reader, position);
|
|
case 44: return armnnSerializer.TransposeConvolution2dLayer.decode(reader, position);
|
|
case 45: return armnnSerializer.ResizeLayer.decode(reader, position);
|
|
case 46: return armnnSerializer.StackLayer.decode(reader, position);
|
|
case 47: return armnnSerializer.AbsLayer.decode(reader, position);
|
|
case 48: return armnnSerializer.ArgMinMaxLayer.decode(reader, position);
|
|
case 49: return armnnSerializer.SliceLayer.decode(reader, position);
|
|
case 50: return armnnSerializer.DepthToSpaceLayer.decode(reader, position);
|
|
case 51: return armnnSerializer.InstanceNormalizationLayer.decode(reader, position);
|
|
case 52: return armnnSerializer.LogSoftmaxLayer.decode(reader, position);
|
|
case 53: return armnnSerializer.ComparisonLayer.decode(reader, position);
|
|
case 54: return armnnSerializer.StandInLayer.decode(reader, position);
|
|
case 55: return armnnSerializer.ElementwiseUnaryLayer.decode(reader, position);
|
|
case 56: return armnnSerializer.TransposeLayer.decode(reader, position);
|
|
case 57: return armnnSerializer.QLstmLayer.decode(reader, position);
|
|
case 58: return armnnSerializer.FillLayer.decode(reader, position);
|
|
case 59: return armnnSerializer.RankLayer.decode(reader, position);
|
|
case 60: return armnnSerializer.LogicalBinaryLayer.decode(reader, position);
|
|
case 61: return armnnSerializer.ReduceLayer.decode(reader, position);
|
|
case 62: return armnnSerializer.CastLayer.decode(reader, position);
|
|
case 63: return armnnSerializer.ShapeLayer.decode(reader, position);
|
|
case 64: return armnnSerializer.UnidirectionalSequenceLstmLayer.decode(reader, position);
|
|
case 65: return armnnSerializer.ChannelShuffleLayer.decode(reader, position);
|
|
case 66: return armnnSerializer.Convolution3dLayer.decode(reader, position);
|
|
case 67: return armnnSerializer.Pooling3dLayer.decode(reader, position);
|
|
case 68: return armnnSerializer.GatherNdLayer.decode(reader, position);
|
|
case 69: return armnnSerializer.BatchMatMulLayer.decode(reader, position);
|
|
case 70: return armnnSerializer.ElementwiseBinaryLayer.decode(reader, position);
|
|
case 71: return armnnSerializer.ReverseV2Layer.decode(reader, position);
|
|
case 72: return armnnSerializer.TileLayer.decode(reader, position);
|
|
case 73: return armnnSerializer.ScatterNdLayer.decode(reader, position);
|
|
default: return undefined;
|
|
}
|
|
}
|
|
|
|
static decodeText(reader, json, type) {
|
|
switch (type) {
|
|
case 'ActivationLayer': return armnnSerializer.ActivationLayer.decodeText(reader, json);
|
|
case 'AdditionLayer': return armnnSerializer.AdditionLayer.decodeText(reader, json);
|
|
case 'BatchToSpaceNdLayer': return armnnSerializer.BatchToSpaceNdLayer.decodeText(reader, json);
|
|
case 'BatchNormalizationLayer': return armnnSerializer.BatchNormalizationLayer.decodeText(reader, json);
|
|
case 'ConstantLayer': return armnnSerializer.ConstantLayer.decodeText(reader, json);
|
|
case 'Convolution2dLayer': return armnnSerializer.Convolution2dLayer.decodeText(reader, json);
|
|
case 'DepthwiseConvolution2dLayer': return armnnSerializer.DepthwiseConvolution2dLayer.decodeText(reader, json);
|
|
case 'FullyConnectedLayer': return armnnSerializer.FullyConnectedLayer.decodeText(reader, json);
|
|
case 'InputLayer': return armnnSerializer.InputLayer.decodeText(reader, json);
|
|
case 'MultiplicationLayer': return armnnSerializer.MultiplicationLayer.decodeText(reader, json);
|
|
case 'OutputLayer': return armnnSerializer.OutputLayer.decodeText(reader, json);
|
|
case 'PermuteLayer': return armnnSerializer.PermuteLayer.decodeText(reader, json);
|
|
case 'Pooling2dLayer': return armnnSerializer.Pooling2dLayer.decodeText(reader, json);
|
|
case 'ReshapeLayer': return armnnSerializer.ReshapeLayer.decodeText(reader, json);
|
|
case 'SoftmaxLayer': return armnnSerializer.SoftmaxLayer.decodeText(reader, json);
|
|
case 'SpaceToBatchNdLayer': return armnnSerializer.SpaceToBatchNdLayer.decodeText(reader, json);
|
|
case 'DivisionLayer': return armnnSerializer.DivisionLayer.decodeText(reader, json);
|
|
case 'MinimumLayer': return armnnSerializer.MinimumLayer.decodeText(reader, json);
|
|
case 'EqualLayer': return armnnSerializer.EqualLayer.decodeText(reader, json);
|
|
case 'MaximumLayer': return armnnSerializer.MaximumLayer.decodeText(reader, json);
|
|
case 'NormalizationLayer': return armnnSerializer.NormalizationLayer.decodeText(reader, json);
|
|
case 'PadLayer': return armnnSerializer.PadLayer.decodeText(reader, json);
|
|
case 'RsqrtLayer': return armnnSerializer.RsqrtLayer.decodeText(reader, json);
|
|
case 'FloorLayer': return armnnSerializer.FloorLayer.decodeText(reader, json);
|
|
case 'GreaterLayer': return armnnSerializer.GreaterLayer.decodeText(reader, json);
|
|
case 'ResizeBilinearLayer': return armnnSerializer.ResizeBilinearLayer.decodeText(reader, json);
|
|
case 'SubtractionLayer': return armnnSerializer.SubtractionLayer.decodeText(reader, json);
|
|
case 'StridedSliceLayer': return armnnSerializer.StridedSliceLayer.decodeText(reader, json);
|
|
case 'GatherLayer': return armnnSerializer.GatherLayer.decodeText(reader, json);
|
|
case 'MeanLayer': return armnnSerializer.MeanLayer.decodeText(reader, json);
|
|
case 'MergerLayer': return armnnSerializer.MergerLayer.decodeText(reader, json);
|
|
case 'L2NormalizationLayer': return armnnSerializer.L2NormalizationLayer.decodeText(reader, json);
|
|
case 'SplitterLayer': return armnnSerializer.SplitterLayer.decodeText(reader, json);
|
|
case 'DetectionPostProcessLayer': return armnnSerializer.DetectionPostProcessLayer.decodeText(reader, json);
|
|
case 'LstmLayer': return armnnSerializer.LstmLayer.decodeText(reader, json);
|
|
case 'QuantizedLstmLayer': return armnnSerializer.QuantizedLstmLayer.decodeText(reader, json);
|
|
case 'QuantizeLayer': return armnnSerializer.QuantizeLayer.decodeText(reader, json);
|
|
case 'DequantizeLayer': return armnnSerializer.DequantizeLayer.decodeText(reader, json);
|
|
case 'MergeLayer': return armnnSerializer.MergeLayer.decodeText(reader, json);
|
|
case 'SwitchLayer': return armnnSerializer.SwitchLayer.decodeText(reader, json);
|
|
case 'ConcatLayer': return armnnSerializer.ConcatLayer.decodeText(reader, json);
|
|
case 'SpaceToDepthLayer': return armnnSerializer.SpaceToDepthLayer.decodeText(reader, json);
|
|
case 'PreluLayer': return armnnSerializer.PreluLayer.decodeText(reader, json);
|
|
case 'TransposeConvolution2dLayer': return armnnSerializer.TransposeConvolution2dLayer.decodeText(reader, json);
|
|
case 'ResizeLayer': return armnnSerializer.ResizeLayer.decodeText(reader, json);
|
|
case 'StackLayer': return armnnSerializer.StackLayer.decodeText(reader, json);
|
|
case 'AbsLayer': return armnnSerializer.AbsLayer.decodeText(reader, json);
|
|
case 'ArgMinMaxLayer': return armnnSerializer.ArgMinMaxLayer.decodeText(reader, json);
|
|
case 'SliceLayer': return armnnSerializer.SliceLayer.decodeText(reader, json);
|
|
case 'DepthToSpaceLayer': return armnnSerializer.DepthToSpaceLayer.decodeText(reader, json);
|
|
case 'InstanceNormalizationLayer': return armnnSerializer.InstanceNormalizationLayer.decodeText(reader, json);
|
|
case 'LogSoftmaxLayer': return armnnSerializer.LogSoftmaxLayer.decodeText(reader, json);
|
|
case 'ComparisonLayer': return armnnSerializer.ComparisonLayer.decodeText(reader, json);
|
|
case 'StandInLayer': return armnnSerializer.StandInLayer.decodeText(reader, json);
|
|
case 'ElementwiseUnaryLayer': return armnnSerializer.ElementwiseUnaryLayer.decodeText(reader, json);
|
|
case 'TransposeLayer': return armnnSerializer.TransposeLayer.decodeText(reader, json);
|
|
case 'QLstmLayer': return armnnSerializer.QLstmLayer.decodeText(reader, json);
|
|
case 'FillLayer': return armnnSerializer.FillLayer.decodeText(reader, json);
|
|
case 'RankLayer': return armnnSerializer.RankLayer.decodeText(reader, json);
|
|
case 'LogicalBinaryLayer': return armnnSerializer.LogicalBinaryLayer.decodeText(reader, json);
|
|
case 'ReduceLayer': return armnnSerializer.ReduceLayer.decodeText(reader, json);
|
|
case 'CastLayer': return armnnSerializer.CastLayer.decodeText(reader, json);
|
|
case 'ShapeLayer': return armnnSerializer.ShapeLayer.decodeText(reader, json);
|
|
case 'UnidirectionalSequenceLstmLayer': return armnnSerializer.UnidirectionalSequenceLstmLayer.decodeText(reader, json);
|
|
case 'ChannelShuffleLayer': return armnnSerializer.ChannelShuffleLayer.decodeText(reader, json);
|
|
case 'Convolution3dLayer': return armnnSerializer.Convolution3dLayer.decodeText(reader, json);
|
|
case 'Pooling3dLayer': return armnnSerializer.Pooling3dLayer.decodeText(reader, json);
|
|
case 'GatherNdLayer': return armnnSerializer.GatherNdLayer.decodeText(reader, json);
|
|
case 'BatchMatMulLayer': return armnnSerializer.BatchMatMulLayer.decodeText(reader, json);
|
|
case 'ElementwiseBinaryLayer': return armnnSerializer.ElementwiseBinaryLayer.decodeText(reader, json);
|
|
case 'ReverseV2Layer': return armnnSerializer.ReverseV2Layer.decodeText(reader, json);
|
|
case 'TileLayer': return armnnSerializer.TileLayer.decodeText(reader, json);
|
|
case 'ScatterNdLayer': return armnnSerializer.ScatterNdLayer.decodeText(reader, json);
|
|
default: return undefined;
|
|
}
|
|
}
|
|
};
|
|
|
|
armnnSerializer.AnyLayer = class AnyLayer {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.AnyLayer();
|
|
$.layer = reader.union(position, 4, armnnSerializer.Layer);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.AnyLayer();
|
|
$.layer = armnnSerializer.Layer.decodeText(reader, json.layer, json.layer_type);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.FeatureCompatibilityVersions = class FeatureCompatibilityVersions {
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.FeatureCompatibilityVersions();
|
|
$.bindingIdsScheme = reader.uint32_(position, 4, 0);
|
|
$.weightsLayoutScheme = reader.uint32_(position, 6, 0);
|
|
$.constantTensorsAsInputs = reader.uint32_(position, 8, 0);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.FeatureCompatibilityVersions();
|
|
$.bindingIdsScheme = reader.value(json.bindingIdsScheme, 0);
|
|
$.weightsLayoutScheme = reader.value(json.weightsLayoutScheme, 0);
|
|
$.constantTensorsAsInputs = reader.value(json.constantTensorsAsInputs, 0);
|
|
return $;
|
|
}
|
|
};
|
|
|
|
armnnSerializer.SerializedGraph = class SerializedGraph {
|
|
|
|
static identifier(reader) {
|
|
return reader.identifier === 'ARMN';
|
|
}
|
|
|
|
static create(reader) {
|
|
return armnnSerializer.SerializedGraph.decode(reader, reader.root);
|
|
}
|
|
|
|
static createText(reader) {
|
|
return armnnSerializer.SerializedGraph.decodeText(reader, reader.root);
|
|
}
|
|
|
|
static decode(reader, position) {
|
|
const $ = new armnnSerializer.SerializedGraph();
|
|
$.layers = reader.tables(position, 4, armnnSerializer.AnyLayer);
|
|
$.inputIds = reader.array(position, 6, Int32Array);
|
|
$.outputIds = reader.array(position, 8, Int32Array);
|
|
$.featureVersions = reader.table(position, 10, armnnSerializer.FeatureCompatibilityVersions);
|
|
return $;
|
|
}
|
|
|
|
static decodeText(reader, json) {
|
|
const $ = new armnnSerializer.SerializedGraph();
|
|
$.layers = reader.objects(json.layers, armnnSerializer.AnyLayer);
|
|
$.inputIds = reader.array(json.inputIds, Int32Array);
|
|
$.outputIds = reader.array(json.outputIds, Int32Array);
|
|
$.featureVersions = reader.object(json.featureVersions, armnnSerializer.FeatureCompatibilityVersions);
|
|
return $;
|
|
}
|
|
};
|