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
2713 lines
90 KiB
JavaScript
2713 lines
90 KiB
JavaScript
|
|
export const onnx = {};
|
|
|
|
onnx.Version = {
|
|
"_START_VERSION": 0,
|
|
"IR_VERSION_2017_10_10": 1,
|
|
"IR_VERSION_2017_10_30": 2,
|
|
"IR_VERSION_2017_11_3": 3,
|
|
"IR_VERSION_2019_1_22": 4,
|
|
"IR_VERSION_2019_3_18": 5,
|
|
"IR_VERSION_2019_9_19": 6,
|
|
"IR_VERSION_2020_5_8": 7,
|
|
"IR_VERSION_2021_7_30": 8,
|
|
"IR_VERSION_2023_5_5": 9,
|
|
"IR_VERSION_2024_3_25": 10,
|
|
"IR_VERSION_2025_05_12": 11,
|
|
"IR_VERSION_2025_08_26": 12,
|
|
"IR_VERSION": 13
|
|
};
|
|
|
|
onnx.AttributeProto = class AttributeProto {
|
|
|
|
constructor() {
|
|
this.floats = [];
|
|
this.ints = [];
|
|
this.strings = [];
|
|
this.tensors = [];
|
|
this.graphs = [];
|
|
this.sparse_tensors = [];
|
|
this.type_protos = [];
|
|
}
|
|
|
|
static decode(reader, length) {
|
|
const message = new onnx.AttributeProto();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.name = reader.string();
|
|
break;
|
|
case 21:
|
|
message.ref_attr_name = reader.string();
|
|
break;
|
|
case 13:
|
|
message.doc_string = reader.string();
|
|
break;
|
|
case 20:
|
|
message.type = reader.int32();
|
|
break;
|
|
case 2:
|
|
message.f = reader.float();
|
|
break;
|
|
case 3:
|
|
message.i = reader.int64();
|
|
break;
|
|
case 4:
|
|
message.s = reader.bytes();
|
|
break;
|
|
case 5:
|
|
message.t = onnx.TensorProto.decode(reader, reader.uint32());
|
|
break;
|
|
case 6:
|
|
message.g = onnx.GraphProto.decode(reader, reader.uint32());
|
|
break;
|
|
case 22:
|
|
message.sparse_tensor = onnx.SparseTensorProto.decode(reader, reader.uint32());
|
|
break;
|
|
case 14:
|
|
message.tp = onnx.TypeProto.decode(reader, reader.uint32());
|
|
break;
|
|
case 7:
|
|
message.floats = reader.floats(message.floats, tag);
|
|
break;
|
|
case 8:
|
|
message.ints = reader.array(message.ints, () => reader.int64(), tag);
|
|
break;
|
|
case 9:
|
|
message.strings.push(reader.bytes());
|
|
break;
|
|
case 10:
|
|
message.tensors.push(onnx.TensorProto.decode(reader, reader.uint32()));
|
|
break;
|
|
case 11:
|
|
message.graphs.push(onnx.GraphProto.decode(reader, reader.uint32()));
|
|
break;
|
|
case 23:
|
|
message.sparse_tensors.push(onnx.SparseTensorProto.decode(reader, reader.uint32()));
|
|
break;
|
|
case 15:
|
|
message.type_protos.push(onnx.TypeProto.decode(reader, reader.uint32()));
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new onnx.AttributeProto();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "name":
|
|
message.name = reader.string();
|
|
break;
|
|
case "ref_attr_name":
|
|
message.ref_attr_name = reader.string();
|
|
break;
|
|
case "doc_string":
|
|
message.doc_string = reader.string();
|
|
break;
|
|
case "type":
|
|
message.type = reader.enum(onnx.AttributeProto.AttributeType);
|
|
break;
|
|
case "f":
|
|
message.f = reader.float();
|
|
break;
|
|
case "i":
|
|
message.i = reader.int64();
|
|
break;
|
|
case "s":
|
|
message.s = reader.bytes();
|
|
break;
|
|
case "t":
|
|
message.t = onnx.TensorProto.decodeText(reader);
|
|
break;
|
|
case "g":
|
|
message.g = onnx.GraphProto.decodeText(reader);
|
|
break;
|
|
case "sparse_tensor":
|
|
message.sparse_tensor = onnx.SparseTensorProto.decodeText(reader);
|
|
break;
|
|
case "tp":
|
|
message.tp = onnx.TypeProto.decodeText(reader);
|
|
break;
|
|
case "floats":
|
|
reader.array(message.floats, () => reader.float());
|
|
break;
|
|
case "ints":
|
|
reader.array(message.ints, () => reader.int64());
|
|
break;
|
|
case "strings":
|
|
reader.array(message.strings, () => reader.bytes());
|
|
break;
|
|
case "tensors":
|
|
message.tensors.push(onnx.TensorProto.decodeText(reader));
|
|
break;
|
|
case "graphs":
|
|
message.graphs.push(onnx.GraphProto.decodeText(reader));
|
|
break;
|
|
case "sparse_tensors":
|
|
message.sparse_tensors.push(onnx.SparseTensorProto.decodeText(reader));
|
|
break;
|
|
case "type_protos":
|
|
message.type_protos.push(onnx.TypeProto.decodeText(reader));
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeJson(obj) {
|
|
const message = new onnx.AttributeProto();
|
|
if ('name' in obj) {
|
|
message.name = obj.name;
|
|
}
|
|
if ('refAttrName' in obj) {
|
|
message.ref_attr_name = obj.refAttrName;
|
|
}
|
|
if ('docString' in obj) {
|
|
message.doc_string = obj.docString;
|
|
}
|
|
if ('type' in obj) {
|
|
message.type = typeof obj.type === 'string' ? onnx.AttributeProto.AttributeType[obj.type] : obj.type;
|
|
}
|
|
if ('f' in obj) {
|
|
message.f = Number(obj.f);
|
|
}
|
|
if ('i' in obj) {
|
|
message.i = BigInt(obj.i);
|
|
}
|
|
if ('s' in obj) {
|
|
message.s = typeof obj.s === 'string' ? Uint8Array.from(atob(obj.s), (c) => c.charCodeAt(0)) : Uint8Array.from(obj.s);
|
|
}
|
|
if ('t' in obj) {
|
|
message.t = onnx.TensorProto.decodeJson(obj.t);
|
|
}
|
|
if ('g' in obj) {
|
|
message.g = onnx.GraphProto.decodeJson(obj.g);
|
|
}
|
|
if ('sparseTensor' in obj) {
|
|
message.sparse_tensor = onnx.SparseTensorProto.decodeJson(obj.sparseTensor);
|
|
}
|
|
if ('tp' in obj) {
|
|
message.tp = onnx.TypeProto.decodeJson(obj.tp);
|
|
}
|
|
if ('floats' in obj) {
|
|
message.floats = obj.floats.map((obj) => Number(obj));
|
|
}
|
|
if ('ints' in obj) {
|
|
message.ints = obj.ints.map((obj) => BigInt(obj));
|
|
}
|
|
if ('strings' in obj) {
|
|
message.strings = obj.strings.map((obj) => typeof obj === 'string' ? Uint8Array.from(atob(obj), (c) => c.charCodeAt(0)) : Uint8Array.from(obj));
|
|
}
|
|
if ('tensors' in obj) {
|
|
message.tensors = obj.tensors.map((obj) => onnx.TensorProto.decodeJson(obj));
|
|
}
|
|
if ('graphs' in obj) {
|
|
message.graphs = obj.graphs.map((obj) => onnx.GraphProto.decodeJson(obj));
|
|
}
|
|
if ('sparseTensors' in obj) {
|
|
message.sparse_tensors = obj.sparseTensors.map((obj) => onnx.SparseTensorProto.decodeJson(obj));
|
|
}
|
|
if ('typeProtos' in obj) {
|
|
message.type_protos = obj.typeProtos.map((obj) => onnx.TypeProto.decodeJson(obj));
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
onnx.AttributeProto.prototype.name = "";
|
|
onnx.AttributeProto.prototype.ref_attr_name = "";
|
|
onnx.AttributeProto.prototype.doc_string = "";
|
|
onnx.AttributeProto.prototype.type = 0;
|
|
onnx.AttributeProto.prototype.f = 0;
|
|
onnx.AttributeProto.prototype.i = 0n;
|
|
onnx.AttributeProto.prototype.s = new Uint8Array([]);
|
|
onnx.AttributeProto.prototype.t = null;
|
|
onnx.AttributeProto.prototype.g = null;
|
|
onnx.AttributeProto.prototype.sparse_tensor = null;
|
|
onnx.AttributeProto.prototype.tp = null;
|
|
|
|
onnx.AttributeProto.AttributeType = {
|
|
"UNDEFINED": 0,
|
|
"FLOAT": 1,
|
|
"INT": 2,
|
|
"STRING": 3,
|
|
"TENSOR": 4,
|
|
"GRAPH": 5,
|
|
"SPARSE_TENSOR": 11,
|
|
"TYPE_PROTO": 13,
|
|
"FLOATS": 6,
|
|
"INTS": 7,
|
|
"STRINGS": 8,
|
|
"TENSORS": 9,
|
|
"GRAPHS": 10,
|
|
"SPARSE_TENSORS": 12,
|
|
"TYPE_PROTOS": 14
|
|
};
|
|
|
|
onnx.ValueInfoProto = class ValueInfoProto {
|
|
|
|
constructor() {
|
|
this.metadata_props = [];
|
|
}
|
|
|
|
static decode(reader, length) {
|
|
const message = new onnx.ValueInfoProto();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.name = reader.string();
|
|
break;
|
|
case 2:
|
|
message.type = onnx.TypeProto.decode(reader, reader.uint32());
|
|
break;
|
|
case 3:
|
|
message.doc_string = reader.string();
|
|
break;
|
|
case 4:
|
|
message.metadata_props.push(onnx.StringStringEntryProto.decode(reader, reader.uint32()));
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new onnx.ValueInfoProto();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "name":
|
|
message.name = reader.string();
|
|
break;
|
|
case "type":
|
|
message.type = onnx.TypeProto.decodeText(reader);
|
|
break;
|
|
case "doc_string":
|
|
message.doc_string = reader.string();
|
|
break;
|
|
case "metadata_props":
|
|
message.metadata_props.push(onnx.StringStringEntryProto.decodeText(reader));
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeJson(obj) {
|
|
const message = new onnx.ValueInfoProto();
|
|
if ('name' in obj) {
|
|
message.name = obj.name;
|
|
}
|
|
if ('type' in obj) {
|
|
message.type = onnx.TypeProto.decodeJson(obj.type);
|
|
}
|
|
if ('docString' in obj) {
|
|
message.doc_string = obj.docString;
|
|
}
|
|
if ('metadataProps' in obj) {
|
|
message.metadata_props = obj.metadataProps.map((obj) => onnx.StringStringEntryProto.decodeJson(obj));
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
onnx.ValueInfoProto.prototype.name = "";
|
|
onnx.ValueInfoProto.prototype.type = null;
|
|
onnx.ValueInfoProto.prototype.doc_string = "";
|
|
|
|
onnx.NodeProto = class NodeProto {
|
|
|
|
constructor() {
|
|
this.input = [];
|
|
this.output = [];
|
|
this.attribute = [];
|
|
this.metadata_props = [];
|
|
this.device_configurations = [];
|
|
}
|
|
|
|
static decode(reader, length) {
|
|
const message = new onnx.NodeProto();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.input.push(reader.string());
|
|
break;
|
|
case 2:
|
|
message.output.push(reader.string());
|
|
break;
|
|
case 3:
|
|
message.name = reader.string();
|
|
break;
|
|
case 4:
|
|
message.op_type = reader.string();
|
|
break;
|
|
case 7:
|
|
message.domain = reader.string();
|
|
break;
|
|
case 8:
|
|
message.overload = reader.string();
|
|
break;
|
|
case 5:
|
|
message.attribute.push(onnx.AttributeProto.decode(reader, reader.uint32()));
|
|
break;
|
|
case 6:
|
|
message.doc_string = reader.string();
|
|
break;
|
|
case 9:
|
|
message.metadata_props.push(onnx.StringStringEntryProto.decode(reader, reader.uint32()));
|
|
break;
|
|
case 10:
|
|
message.device_configurations.push(onnx.NodeDeviceConfigurationProto.decode(reader, reader.uint32()));
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new onnx.NodeProto();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "input":
|
|
reader.array(message.input, () => reader.string());
|
|
break;
|
|
case "output":
|
|
reader.array(message.output, () => reader.string());
|
|
break;
|
|
case "name":
|
|
message.name = reader.string();
|
|
break;
|
|
case "op_type":
|
|
message.op_type = reader.string();
|
|
break;
|
|
case "domain":
|
|
message.domain = reader.string();
|
|
break;
|
|
case "overload":
|
|
message.overload = reader.string();
|
|
break;
|
|
case "attribute":
|
|
message.attribute.push(onnx.AttributeProto.decodeText(reader));
|
|
break;
|
|
case "doc_string":
|
|
message.doc_string = reader.string();
|
|
break;
|
|
case "metadata_props":
|
|
message.metadata_props.push(onnx.StringStringEntryProto.decodeText(reader));
|
|
break;
|
|
case "device_configurations":
|
|
message.device_configurations.push(onnx.NodeDeviceConfigurationProto.decodeText(reader));
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeJson(obj) {
|
|
const message = new onnx.NodeProto();
|
|
if ('input' in obj) {
|
|
message.input = obj.input;
|
|
}
|
|
if ('output' in obj) {
|
|
message.output = obj.output;
|
|
}
|
|
if ('name' in obj) {
|
|
message.name = obj.name;
|
|
}
|
|
if ('opType' in obj) {
|
|
message.op_type = obj.opType;
|
|
}
|
|
if ('domain' in obj) {
|
|
message.domain = obj.domain;
|
|
}
|
|
if ('overload' in obj) {
|
|
message.overload = obj.overload;
|
|
}
|
|
if ('attribute' in obj) {
|
|
message.attribute = obj.attribute.map((obj) => onnx.AttributeProto.decodeJson(obj));
|
|
}
|
|
if ('docString' in obj) {
|
|
message.doc_string = obj.docString;
|
|
}
|
|
if ('metadataProps' in obj) {
|
|
message.metadata_props = obj.metadataProps.map((obj) => onnx.StringStringEntryProto.decodeJson(obj));
|
|
}
|
|
if ('deviceConfigurations' in obj) {
|
|
message.device_configurations = obj.deviceConfigurations.map((obj) => onnx.NodeDeviceConfigurationProto.decodeJson(obj));
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
onnx.NodeProto.prototype.name = "";
|
|
onnx.NodeProto.prototype.op_type = "";
|
|
onnx.NodeProto.prototype.domain = "";
|
|
onnx.NodeProto.prototype.overload = "";
|
|
onnx.NodeProto.prototype.doc_string = "";
|
|
|
|
onnx.IntIntListEntryProto = class IntIntListEntryProto {
|
|
|
|
constructor() {
|
|
this.value = [];
|
|
}
|
|
|
|
static decode(reader, length) {
|
|
const message = new onnx.IntIntListEntryProto();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.key = reader.int64();
|
|
break;
|
|
case 2:
|
|
message.value = reader.array(message.value, () => reader.int64(), tag);
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new onnx.IntIntListEntryProto();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "key":
|
|
message.key = reader.int64();
|
|
break;
|
|
case "value":
|
|
reader.array(message.value, () => reader.int64());
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeJson(obj) {
|
|
const message = new onnx.IntIntListEntryProto();
|
|
if ('key' in obj) {
|
|
message.key = BigInt(obj.key);
|
|
}
|
|
if ('value' in obj) {
|
|
message.value = obj.value.map((obj) => BigInt(obj));
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
onnx.IntIntListEntryProto.prototype.key = 0n;
|
|
|
|
onnx.NodeDeviceConfigurationProto = class NodeDeviceConfigurationProto {
|
|
|
|
constructor() {
|
|
this.sharding_spec = [];
|
|
}
|
|
|
|
static decode(reader, length) {
|
|
const message = new onnx.NodeDeviceConfigurationProto();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.configuration_id = reader.string();
|
|
break;
|
|
case 2:
|
|
message.sharding_spec.push(onnx.ShardingSpecProto.decode(reader, reader.uint32()));
|
|
break;
|
|
case 3:
|
|
message.pipeline_stage = reader.int32();
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new onnx.NodeDeviceConfigurationProto();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "configuration_id":
|
|
message.configuration_id = reader.string();
|
|
break;
|
|
case "sharding_spec":
|
|
message.sharding_spec.push(onnx.ShardingSpecProto.decodeText(reader));
|
|
break;
|
|
case "pipeline_stage":
|
|
message.pipeline_stage = reader.int32();
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeJson(obj) {
|
|
const message = new onnx.NodeDeviceConfigurationProto();
|
|
if ('configurationId' in obj) {
|
|
message.configuration_id = obj.configurationId;
|
|
}
|
|
if ('shardingSpec' in obj) {
|
|
message.sharding_spec = obj.shardingSpec.map((obj) => onnx.ShardingSpecProto.decodeJson(obj));
|
|
}
|
|
if ('pipelineStage' in obj) {
|
|
message.pipeline_stage = Number(obj.pipelineStage);
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
onnx.NodeDeviceConfigurationProto.prototype.configuration_id = "";
|
|
onnx.NodeDeviceConfigurationProto.prototype.pipeline_stage = 0;
|
|
|
|
onnx.ShardingSpecProto = class ShardingSpecProto {
|
|
|
|
constructor() {
|
|
this.device = [];
|
|
this.index_to_device_group_map = [];
|
|
this.sharded_dim = [];
|
|
}
|
|
|
|
static decode(reader, length) {
|
|
const message = new onnx.ShardingSpecProto();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.tensor_name = reader.string();
|
|
break;
|
|
case 2:
|
|
message.device = reader.array(message.device, () => reader.int64(), tag);
|
|
break;
|
|
case 3:
|
|
message.index_to_device_group_map.push(onnx.IntIntListEntryProto.decode(reader, reader.uint32()));
|
|
break;
|
|
case 4:
|
|
message.sharded_dim.push(onnx.ShardedDimProto.decode(reader, reader.uint32()));
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new onnx.ShardingSpecProto();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "tensor_name":
|
|
message.tensor_name = reader.string();
|
|
break;
|
|
case "device":
|
|
reader.array(message.device, () => reader.int64());
|
|
break;
|
|
case "index_to_device_group_map":
|
|
message.index_to_device_group_map.push(onnx.IntIntListEntryProto.decodeText(reader));
|
|
break;
|
|
case "sharded_dim":
|
|
message.sharded_dim.push(onnx.ShardedDimProto.decodeText(reader));
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeJson(obj) {
|
|
const message = new onnx.ShardingSpecProto();
|
|
if ('tensorName' in obj) {
|
|
message.tensor_name = obj.tensorName;
|
|
}
|
|
if ('device' in obj) {
|
|
message.device = obj.device.map((obj) => BigInt(obj));
|
|
}
|
|
if ('indexToDeviceGroupMap' in obj) {
|
|
message.index_to_device_group_map = obj.indexToDeviceGroupMap.map((obj) => onnx.IntIntListEntryProto.decodeJson(obj));
|
|
}
|
|
if ('shardedDim' in obj) {
|
|
message.sharded_dim = obj.shardedDim.map((obj) => onnx.ShardedDimProto.decodeJson(obj));
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
onnx.ShardingSpecProto.prototype.tensor_name = "";
|
|
|
|
onnx.ShardedDimProto = class ShardedDimProto {
|
|
|
|
constructor() {
|
|
this.simple_sharding = [];
|
|
}
|
|
|
|
static decode(reader, length) {
|
|
const message = new onnx.ShardedDimProto();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.axis = reader.int64();
|
|
break;
|
|
case 2:
|
|
message.simple_sharding.push(onnx.SimpleShardedDimProto.decode(reader, reader.uint32()));
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new onnx.ShardedDimProto();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "axis":
|
|
message.axis = reader.int64();
|
|
break;
|
|
case "simple_sharding":
|
|
message.simple_sharding.push(onnx.SimpleShardedDimProto.decodeText(reader));
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeJson(obj) {
|
|
const message = new onnx.ShardedDimProto();
|
|
if ('axis' in obj) {
|
|
message.axis = BigInt(obj.axis);
|
|
}
|
|
if ('simpleSharding' in obj) {
|
|
message.simple_sharding = obj.simpleSharding.map((obj) => onnx.SimpleShardedDimProto.decodeJson(obj));
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
onnx.ShardedDimProto.prototype.axis = 0n;
|
|
|
|
onnx.SimpleShardedDimProto = class SimpleShardedDimProto {
|
|
|
|
get dim() {
|
|
onnx.SimpleShardedDimProto.dimSet = onnx.SimpleShardedDimProto.dimSet || new Set(["dim_value", "dim_param"]);
|
|
return Object.keys(this).find((key) => onnx.SimpleShardedDimProto.dimSet.has(key) && this[key] !== null);
|
|
}
|
|
|
|
static decode(reader, length) {
|
|
const message = new onnx.SimpleShardedDimProto();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.dim_value = reader.int64();
|
|
break;
|
|
case 2:
|
|
message.dim_param = reader.string();
|
|
break;
|
|
case 3:
|
|
message.num_shards = reader.int64();
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new onnx.SimpleShardedDimProto();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "dim_value":
|
|
message.dim_value = reader.int64();
|
|
break;
|
|
case "dim_param":
|
|
message.dim_param = reader.string();
|
|
break;
|
|
case "num_shards":
|
|
message.num_shards = reader.int64();
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeJson(obj) {
|
|
const message = new onnx.SimpleShardedDimProto();
|
|
if ('dimValue' in obj) {
|
|
message.dim_value = BigInt(obj.dimValue);
|
|
}
|
|
if ('dimParam' in obj) {
|
|
message.dim_param = obj.dimParam;
|
|
}
|
|
if ('numShards' in obj) {
|
|
message.num_shards = BigInt(obj.numShards);
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
onnx.SimpleShardedDimProto.prototype.num_shards = 0n;
|
|
|
|
onnx.TrainingInfoProto = class TrainingInfoProto {
|
|
|
|
constructor() {
|
|
this.initialization_binding = [];
|
|
this.update_binding = [];
|
|
}
|
|
|
|
static decode(reader, length) {
|
|
const message = new onnx.TrainingInfoProto();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.initialization = onnx.GraphProto.decode(reader, reader.uint32());
|
|
break;
|
|
case 2:
|
|
message.algorithm = onnx.GraphProto.decode(reader, reader.uint32());
|
|
break;
|
|
case 3:
|
|
message.initialization_binding.push(onnx.StringStringEntryProto.decode(reader, reader.uint32()));
|
|
break;
|
|
case 4:
|
|
message.update_binding.push(onnx.StringStringEntryProto.decode(reader, reader.uint32()));
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new onnx.TrainingInfoProto();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "initialization":
|
|
message.initialization = onnx.GraphProto.decodeText(reader);
|
|
break;
|
|
case "algorithm":
|
|
message.algorithm = onnx.GraphProto.decodeText(reader);
|
|
break;
|
|
case "initialization_binding":
|
|
message.initialization_binding.push(onnx.StringStringEntryProto.decodeText(reader));
|
|
break;
|
|
case "update_binding":
|
|
message.update_binding.push(onnx.StringStringEntryProto.decodeText(reader));
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeJson(obj) {
|
|
const message = new onnx.TrainingInfoProto();
|
|
if ('initialization' in obj) {
|
|
message.initialization = onnx.GraphProto.decodeJson(obj.initialization);
|
|
}
|
|
if ('algorithm' in obj) {
|
|
message.algorithm = onnx.GraphProto.decodeJson(obj.algorithm);
|
|
}
|
|
if ('initializationBinding' in obj) {
|
|
message.initialization_binding = obj.initializationBinding.map((obj) => onnx.StringStringEntryProto.decodeJson(obj));
|
|
}
|
|
if ('updateBinding' in obj) {
|
|
message.update_binding = obj.updateBinding.map((obj) => onnx.StringStringEntryProto.decodeJson(obj));
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
onnx.TrainingInfoProto.prototype.initialization = null;
|
|
onnx.TrainingInfoProto.prototype.algorithm = null;
|
|
|
|
onnx.ModelProto = class ModelProto {
|
|
|
|
constructor() {
|
|
this.opset_import = [];
|
|
this.metadata_props = [];
|
|
this.training_info = [];
|
|
this.functions = [];
|
|
this.configuration = [];
|
|
}
|
|
|
|
static decode(reader, length) {
|
|
const message = new onnx.ModelProto();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.ir_version = reader.int64();
|
|
break;
|
|
case 8:
|
|
message.opset_import.push(onnx.OperatorSetIdProto.decode(reader, reader.uint32()));
|
|
break;
|
|
case 2:
|
|
message.producer_name = reader.string();
|
|
break;
|
|
case 3:
|
|
message.producer_version = reader.string();
|
|
break;
|
|
case 4:
|
|
message.domain = reader.string();
|
|
break;
|
|
case 5:
|
|
message.model_version = reader.int64();
|
|
break;
|
|
case 6:
|
|
message.doc_string = reader.string();
|
|
break;
|
|
case 7:
|
|
message.graph = onnx.GraphProto.decode(reader, reader.uint32());
|
|
break;
|
|
case 14:
|
|
message.metadata_props.push(onnx.StringStringEntryProto.decode(reader, reader.uint32()));
|
|
break;
|
|
case 20:
|
|
message.training_info.push(onnx.TrainingInfoProto.decode(reader, reader.uint32()));
|
|
break;
|
|
case 25:
|
|
message.functions.push(onnx.FunctionProto.decode(reader, reader.uint32()));
|
|
break;
|
|
case 26:
|
|
message.configuration.push(onnx.DeviceConfigurationProto.decode(reader, reader.uint32()));
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new onnx.ModelProto();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "ir_version":
|
|
message.ir_version = reader.int64();
|
|
break;
|
|
case "opset_import":
|
|
message.opset_import.push(onnx.OperatorSetIdProto.decodeText(reader));
|
|
break;
|
|
case "producer_name":
|
|
message.producer_name = reader.string();
|
|
break;
|
|
case "producer_version":
|
|
message.producer_version = reader.string();
|
|
break;
|
|
case "domain":
|
|
message.domain = reader.string();
|
|
break;
|
|
case "model_version":
|
|
message.model_version = reader.int64();
|
|
break;
|
|
case "doc_string":
|
|
message.doc_string = reader.string();
|
|
break;
|
|
case "graph":
|
|
message.graph = onnx.GraphProto.decodeText(reader);
|
|
break;
|
|
case "metadata_props":
|
|
message.metadata_props.push(onnx.StringStringEntryProto.decodeText(reader));
|
|
break;
|
|
case "training_info":
|
|
message.training_info.push(onnx.TrainingInfoProto.decodeText(reader));
|
|
break;
|
|
case "functions":
|
|
message.functions.push(onnx.FunctionProto.decodeText(reader));
|
|
break;
|
|
case "configuration":
|
|
message.configuration.push(onnx.DeviceConfigurationProto.decodeText(reader));
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeJson(obj) {
|
|
const message = new onnx.ModelProto();
|
|
if ('irVersion' in obj) {
|
|
message.ir_version = BigInt(obj.irVersion);
|
|
}
|
|
if ('opsetImport' in obj) {
|
|
message.opset_import = obj.opsetImport.map((obj) => onnx.OperatorSetIdProto.decodeJson(obj));
|
|
}
|
|
if ('producerName' in obj) {
|
|
message.producer_name = obj.producerName;
|
|
}
|
|
if ('producerVersion' in obj) {
|
|
message.producer_version = obj.producerVersion;
|
|
}
|
|
if ('domain' in obj) {
|
|
message.domain = obj.domain;
|
|
}
|
|
if ('modelVersion' in obj) {
|
|
message.model_version = BigInt(obj.modelVersion);
|
|
}
|
|
if ('docString' in obj) {
|
|
message.doc_string = obj.docString;
|
|
}
|
|
if ('graph' in obj) {
|
|
message.graph = onnx.GraphProto.decodeJson(obj.graph);
|
|
}
|
|
if ('metadataProps' in obj) {
|
|
message.metadata_props = obj.metadataProps.map((obj) => onnx.StringStringEntryProto.decodeJson(obj));
|
|
}
|
|
if ('trainingInfo' in obj) {
|
|
message.training_info = obj.trainingInfo.map((obj) => onnx.TrainingInfoProto.decodeJson(obj));
|
|
}
|
|
if ('functions' in obj) {
|
|
message.functions = obj.functions.map((obj) => onnx.FunctionProto.decodeJson(obj));
|
|
}
|
|
if ('configuration' in obj) {
|
|
message.configuration = obj.configuration.map((obj) => onnx.DeviceConfigurationProto.decodeJson(obj));
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
onnx.ModelProto.prototype.ir_version = 0n;
|
|
onnx.ModelProto.prototype.producer_name = "";
|
|
onnx.ModelProto.prototype.producer_version = "";
|
|
onnx.ModelProto.prototype.domain = "";
|
|
onnx.ModelProto.prototype.model_version = 0n;
|
|
onnx.ModelProto.prototype.doc_string = "";
|
|
onnx.ModelProto.prototype.graph = null;
|
|
|
|
onnx.DeviceConfigurationProto = class DeviceConfigurationProto {
|
|
|
|
constructor() {
|
|
this.device = [];
|
|
}
|
|
|
|
static decode(reader, length) {
|
|
const message = new onnx.DeviceConfigurationProto();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.name = reader.string();
|
|
break;
|
|
case 2:
|
|
message.num_devices = reader.int32();
|
|
break;
|
|
case 3:
|
|
message.device.push(reader.string());
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new onnx.DeviceConfigurationProto();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "name":
|
|
message.name = reader.string();
|
|
break;
|
|
case "num_devices":
|
|
message.num_devices = reader.int32();
|
|
break;
|
|
case "device":
|
|
reader.array(message.device, () => reader.string());
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeJson(obj) {
|
|
const message = new onnx.DeviceConfigurationProto();
|
|
if ('name' in obj) {
|
|
message.name = obj.name;
|
|
}
|
|
if ('numDevices' in obj) {
|
|
message.num_devices = Number(obj.numDevices);
|
|
}
|
|
if ('device' in obj) {
|
|
message.device = obj.device;
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
onnx.DeviceConfigurationProto.prototype.name = "";
|
|
onnx.DeviceConfigurationProto.prototype.num_devices = 0;
|
|
|
|
onnx.StringStringEntryProto = class StringStringEntryProto {
|
|
|
|
static decode(reader, length) {
|
|
const message = new onnx.StringStringEntryProto();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.key = reader.string();
|
|
break;
|
|
case 2:
|
|
message.value = reader.string();
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new onnx.StringStringEntryProto();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "key":
|
|
message.key = reader.string();
|
|
break;
|
|
case "value":
|
|
message.value = reader.string();
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeJson(obj) {
|
|
const message = new onnx.StringStringEntryProto();
|
|
if ('key' in obj) {
|
|
message.key = obj.key;
|
|
}
|
|
if ('value' in obj) {
|
|
message.value = obj.value;
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
onnx.StringStringEntryProto.prototype.key = "";
|
|
onnx.StringStringEntryProto.prototype.value = "";
|
|
|
|
onnx.TensorAnnotation = class TensorAnnotation {
|
|
|
|
constructor() {
|
|
this.quant_parameter_tensor_names = [];
|
|
}
|
|
|
|
static decode(reader, length) {
|
|
const message = new onnx.TensorAnnotation();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.tensor_name = reader.string();
|
|
break;
|
|
case 2:
|
|
message.quant_parameter_tensor_names.push(onnx.StringStringEntryProto.decode(reader, reader.uint32()));
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new onnx.TensorAnnotation();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "tensor_name":
|
|
message.tensor_name = reader.string();
|
|
break;
|
|
case "quant_parameter_tensor_names":
|
|
message.quant_parameter_tensor_names.push(onnx.StringStringEntryProto.decodeText(reader));
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeJson(obj) {
|
|
const message = new onnx.TensorAnnotation();
|
|
if ('tensorName' in obj) {
|
|
message.tensor_name = obj.tensorName;
|
|
}
|
|
if ('quantParameterTensorNames' in obj) {
|
|
message.quant_parameter_tensor_names = obj.quantParameterTensorNames.map((obj) => onnx.StringStringEntryProto.decodeJson(obj));
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
onnx.TensorAnnotation.prototype.tensor_name = "";
|
|
|
|
onnx.GraphProto = class GraphProto {
|
|
|
|
constructor() {
|
|
this.node = [];
|
|
this.initializer = [];
|
|
this.sparse_initializer = [];
|
|
this.input = [];
|
|
this.output = [];
|
|
this.value_info = [];
|
|
this.quantization_annotation = [];
|
|
this.metadata_props = [];
|
|
}
|
|
|
|
static decode(reader, length) {
|
|
const message = new onnx.GraphProto();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.node.push(onnx.NodeProto.decode(reader, reader.uint32()));
|
|
break;
|
|
case 2:
|
|
message.name = reader.string();
|
|
break;
|
|
case 5:
|
|
message.initializer.push(onnx.TensorProto.decode(reader, reader.uint32()));
|
|
break;
|
|
case 15:
|
|
message.sparse_initializer.push(onnx.SparseTensorProto.decode(reader, reader.uint32()));
|
|
break;
|
|
case 10:
|
|
message.doc_string = reader.string();
|
|
break;
|
|
case 11:
|
|
message.input.push(onnx.ValueInfoProto.decode(reader, reader.uint32()));
|
|
break;
|
|
case 12:
|
|
message.output.push(onnx.ValueInfoProto.decode(reader, reader.uint32()));
|
|
break;
|
|
case 13:
|
|
message.value_info.push(onnx.ValueInfoProto.decode(reader, reader.uint32()));
|
|
break;
|
|
case 14:
|
|
message.quantization_annotation.push(onnx.TensorAnnotation.decode(reader, reader.uint32()));
|
|
break;
|
|
case 16:
|
|
message.metadata_props.push(onnx.StringStringEntryProto.decode(reader, reader.uint32()));
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new onnx.GraphProto();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "node":
|
|
message.node.push(onnx.NodeProto.decodeText(reader));
|
|
break;
|
|
case "name":
|
|
message.name = reader.string();
|
|
break;
|
|
case "initializer":
|
|
message.initializer.push(onnx.TensorProto.decodeText(reader));
|
|
break;
|
|
case "sparse_initializer":
|
|
message.sparse_initializer.push(onnx.SparseTensorProto.decodeText(reader));
|
|
break;
|
|
case "doc_string":
|
|
message.doc_string = reader.string();
|
|
break;
|
|
case "input":
|
|
message.input.push(onnx.ValueInfoProto.decodeText(reader));
|
|
break;
|
|
case "output":
|
|
message.output.push(onnx.ValueInfoProto.decodeText(reader));
|
|
break;
|
|
case "value_info":
|
|
message.value_info.push(onnx.ValueInfoProto.decodeText(reader));
|
|
break;
|
|
case "quantization_annotation":
|
|
message.quantization_annotation.push(onnx.TensorAnnotation.decodeText(reader));
|
|
break;
|
|
case "metadata_props":
|
|
message.metadata_props.push(onnx.StringStringEntryProto.decodeText(reader));
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeJson(obj) {
|
|
const message = new onnx.GraphProto();
|
|
if ('node' in obj) {
|
|
message.node = obj.node.map((obj) => onnx.NodeProto.decodeJson(obj));
|
|
}
|
|
if ('name' in obj) {
|
|
message.name = obj.name;
|
|
}
|
|
if ('initializer' in obj) {
|
|
message.initializer = obj.initializer.map((obj) => onnx.TensorProto.decodeJson(obj));
|
|
}
|
|
if ('sparseInitializer' in obj) {
|
|
message.sparse_initializer = obj.sparseInitializer.map((obj) => onnx.SparseTensorProto.decodeJson(obj));
|
|
}
|
|
if ('docString' in obj) {
|
|
message.doc_string = obj.docString;
|
|
}
|
|
if ('input' in obj) {
|
|
message.input = obj.input.map((obj) => onnx.ValueInfoProto.decodeJson(obj));
|
|
}
|
|
if ('output' in obj) {
|
|
message.output = obj.output.map((obj) => onnx.ValueInfoProto.decodeJson(obj));
|
|
}
|
|
if ('valueInfo' in obj) {
|
|
message.value_info = obj.valueInfo.map((obj) => onnx.ValueInfoProto.decodeJson(obj));
|
|
}
|
|
if ('quantizationAnnotation' in obj) {
|
|
message.quantization_annotation = obj.quantizationAnnotation.map((obj) => onnx.TensorAnnotation.decodeJson(obj));
|
|
}
|
|
if ('metadataProps' in obj) {
|
|
message.metadata_props = obj.metadataProps.map((obj) => onnx.StringStringEntryProto.decodeJson(obj));
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
onnx.GraphProto.prototype.name = "";
|
|
onnx.GraphProto.prototype.doc_string = "";
|
|
|
|
onnx.TensorProto = class TensorProto {
|
|
|
|
constructor() {
|
|
this.dims = [];
|
|
this.float_data = [];
|
|
this.int32_data = [];
|
|
this.string_data = [];
|
|
this.int64_data = [];
|
|
this.external_data = [];
|
|
this.double_data = [];
|
|
this.uint64_data = [];
|
|
this.metadata_props = [];
|
|
}
|
|
|
|
static decode(reader, length) {
|
|
const message = new onnx.TensorProto();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.dims = reader.array(message.dims, () => reader.int64(), tag);
|
|
break;
|
|
case 2:
|
|
message.data_type = reader.int32();
|
|
break;
|
|
case 3:
|
|
message.segment = onnx.TensorProto.Segment.decode(reader, reader.uint32());
|
|
break;
|
|
case 4:
|
|
message.float_data = reader.floats(message.float_data, tag);
|
|
break;
|
|
case 5:
|
|
message.int32_data = reader.array(message.int32_data, () => reader.int32(), tag);
|
|
break;
|
|
case 6:
|
|
message.string_data.push(reader.bytes());
|
|
break;
|
|
case 7:
|
|
message.int64_data = reader.array(message.int64_data, () => reader.int64(), tag);
|
|
break;
|
|
case 8:
|
|
message.name = reader.string();
|
|
break;
|
|
case 12:
|
|
message.doc_string = reader.string();
|
|
break;
|
|
case 9:
|
|
message.raw_data = reader.bytes();
|
|
break;
|
|
case 13:
|
|
message.external_data.push(onnx.StringStringEntryProto.decode(reader, reader.uint32()));
|
|
break;
|
|
case 14:
|
|
message.data_location = reader.int32();
|
|
break;
|
|
case 10:
|
|
message.double_data = reader.doubles(message.double_data, tag);
|
|
break;
|
|
case 11:
|
|
message.uint64_data = reader.array(message.uint64_data, () => reader.uint64(), tag);
|
|
break;
|
|
case 16:
|
|
message.metadata_props.push(onnx.StringStringEntryProto.decode(reader, reader.uint32()));
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new onnx.TensorProto();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "dims":
|
|
reader.array(message.dims, () => reader.int64());
|
|
break;
|
|
case "data_type":
|
|
message.data_type = reader.int32();
|
|
break;
|
|
case "segment":
|
|
message.segment = onnx.TensorProto.Segment.decodeText(reader);
|
|
break;
|
|
case "float_data":
|
|
reader.array(message.float_data, () => reader.float());
|
|
break;
|
|
case "int32_data":
|
|
reader.array(message.int32_data, () => reader.int32());
|
|
break;
|
|
case "string_data":
|
|
reader.array(message.string_data, () => reader.bytes());
|
|
break;
|
|
case "int64_data":
|
|
reader.array(message.int64_data, () => reader.int64());
|
|
break;
|
|
case "name":
|
|
message.name = reader.string();
|
|
break;
|
|
case "doc_string":
|
|
message.doc_string = reader.string();
|
|
break;
|
|
case "raw_data":
|
|
message.raw_data = reader.bytes();
|
|
break;
|
|
case "external_data":
|
|
message.external_data.push(onnx.StringStringEntryProto.decodeText(reader));
|
|
break;
|
|
case "data_location":
|
|
message.data_location = reader.enum(onnx.TensorProto.DataLocation);
|
|
break;
|
|
case "double_data":
|
|
reader.array(message.double_data, () => reader.double());
|
|
break;
|
|
case "uint64_data":
|
|
reader.array(message.uint64_data, () => reader.uint64());
|
|
break;
|
|
case "metadata_props":
|
|
message.metadata_props.push(onnx.StringStringEntryProto.decodeText(reader));
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeJson(obj) {
|
|
const message = new onnx.TensorProto();
|
|
if ('dims' in obj) {
|
|
message.dims = obj.dims.map((obj) => BigInt(obj));
|
|
}
|
|
if ('dataType' in obj) {
|
|
message.data_type = Number(obj.dataType);
|
|
}
|
|
if ('segment' in obj) {
|
|
message.segment = onnx.TensorProto.Segment.decodeJson(obj.segment);
|
|
}
|
|
if ('floatData' in obj) {
|
|
message.float_data = obj.floatData.map((obj) => Number(obj));
|
|
}
|
|
if ('int32Data' in obj) {
|
|
message.int32_data = obj.int32Data.map((obj) => Number(obj));
|
|
}
|
|
if ('stringData' in obj) {
|
|
message.string_data = obj.stringData.map((obj) => typeof obj === 'string' ? Uint8Array.from(atob(obj), (c) => c.charCodeAt(0)) : Uint8Array.from(obj));
|
|
}
|
|
if ('int64Data' in obj) {
|
|
message.int64_data = obj.int64Data.map((obj) => BigInt(obj));
|
|
}
|
|
if ('name' in obj) {
|
|
message.name = obj.name;
|
|
}
|
|
if ('docString' in obj) {
|
|
message.doc_string = obj.docString;
|
|
}
|
|
if ('rawData' in obj) {
|
|
message.raw_data = typeof obj.rawData === 'string' ? Uint8Array.from(atob(obj.rawData), (c) => c.charCodeAt(0)) : Uint8Array.from(obj.rawData);
|
|
}
|
|
if ('externalData' in obj) {
|
|
message.external_data = obj.externalData.map((obj) => onnx.StringStringEntryProto.decodeJson(obj));
|
|
}
|
|
if ('dataLocation' in obj) {
|
|
message.data_location = typeof obj.dataLocation === 'string' ? onnx.TensorProto.DataLocation[obj.dataLocation] : obj.dataLocation;
|
|
}
|
|
if ('doubleData' in obj) {
|
|
message.double_data = obj.doubleData.map((obj) => Number(obj));
|
|
}
|
|
if ('uint64Data' in obj) {
|
|
message.uint64_data = obj.uint64Data.map((obj) => BigInt(obj));
|
|
}
|
|
if ('metadataProps' in obj) {
|
|
message.metadata_props = obj.metadataProps.map((obj) => onnx.StringStringEntryProto.decodeJson(obj));
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
onnx.TensorProto.prototype.data_type = 0;
|
|
onnx.TensorProto.prototype.segment = null;
|
|
onnx.TensorProto.prototype.name = "";
|
|
onnx.TensorProto.prototype.doc_string = "";
|
|
onnx.TensorProto.prototype.raw_data = new Uint8Array([]);
|
|
onnx.TensorProto.prototype.data_location = 0;
|
|
|
|
onnx.TensorProto.DataType = {
|
|
"UNDEFINED": 0,
|
|
"FLOAT": 1,
|
|
"UINT8": 2,
|
|
"INT8": 3,
|
|
"UINT16": 4,
|
|
"INT16": 5,
|
|
"INT32": 6,
|
|
"INT64": 7,
|
|
"STRING": 8,
|
|
"BOOL": 9,
|
|
"FLOAT16": 10,
|
|
"DOUBLE": 11,
|
|
"UINT32": 12,
|
|
"UINT64": 13,
|
|
"COMPLEX64": 14,
|
|
"COMPLEX128": 15,
|
|
"BFLOAT16": 16,
|
|
"FLOAT8E4M3FN": 17,
|
|
"FLOAT8E4M3FNUZ": 18,
|
|
"FLOAT8E5M2": 19,
|
|
"FLOAT8E5M2FNUZ": 20,
|
|
"UINT4": 21,
|
|
"INT4": 22,
|
|
"FLOAT4E2M1": 23,
|
|
"FLOAT8E8M0": 24,
|
|
"UINT2": 25,
|
|
"INT2": 26
|
|
};
|
|
|
|
onnx.TensorProto.Segment = class Segment {
|
|
|
|
static decode(reader, length) {
|
|
const message = new onnx.TensorProto.Segment();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.begin = reader.int64();
|
|
break;
|
|
case 2:
|
|
message.end = reader.int64();
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new onnx.TensorProto.Segment();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "begin":
|
|
message.begin = reader.int64();
|
|
break;
|
|
case "end":
|
|
message.end = reader.int64();
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeJson(obj) {
|
|
const message = new onnx.TensorProto.Segment();
|
|
if ('begin' in obj) {
|
|
message.begin = BigInt(obj.begin);
|
|
}
|
|
if ('end' in obj) {
|
|
message.end = BigInt(obj.end);
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
onnx.TensorProto.Segment.prototype.begin = 0n;
|
|
onnx.TensorProto.Segment.prototype.end = 0n;
|
|
|
|
onnx.TensorProto.DataLocation = {
|
|
"DEFAULT": 0,
|
|
"EXTERNAL": 1
|
|
};
|
|
|
|
onnx.SparseTensorProto = class SparseTensorProto {
|
|
|
|
constructor() {
|
|
this.dims = [];
|
|
}
|
|
|
|
static decode(reader, length) {
|
|
const message = new onnx.SparseTensorProto();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.values = onnx.TensorProto.decode(reader, reader.uint32());
|
|
break;
|
|
case 2:
|
|
message.indices = onnx.TensorProto.decode(reader, reader.uint32());
|
|
break;
|
|
case 3:
|
|
message.dims = reader.array(message.dims, () => reader.int64(), tag);
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new onnx.SparseTensorProto();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "values":
|
|
message.values = onnx.TensorProto.decodeText(reader);
|
|
break;
|
|
case "indices":
|
|
message.indices = onnx.TensorProto.decodeText(reader);
|
|
break;
|
|
case "dims":
|
|
reader.array(message.dims, () => reader.int64());
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeJson(obj) {
|
|
const message = new onnx.SparseTensorProto();
|
|
if ('values' in obj) {
|
|
message.values = onnx.TensorProto.decodeJson(obj.values);
|
|
}
|
|
if ('indices' in obj) {
|
|
message.indices = onnx.TensorProto.decodeJson(obj.indices);
|
|
}
|
|
if ('dims' in obj) {
|
|
message.dims = obj.dims.map((obj) => BigInt(obj));
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
onnx.SparseTensorProto.prototype.values = null;
|
|
onnx.SparseTensorProto.prototype.indices = null;
|
|
|
|
onnx.TensorShapeProto = class TensorShapeProto {
|
|
|
|
constructor() {
|
|
this.dim = [];
|
|
}
|
|
|
|
static decode(reader, length) {
|
|
const message = new onnx.TensorShapeProto();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.dim.push(onnx.TensorShapeProto.Dimension.decode(reader, reader.uint32()));
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new onnx.TensorShapeProto();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "dim":
|
|
message.dim.push(onnx.TensorShapeProto.Dimension.decodeText(reader));
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeJson(obj) {
|
|
const message = new onnx.TensorShapeProto();
|
|
if ('dim' in obj) {
|
|
message.dim = obj.dim.map((obj) => onnx.TensorShapeProto.Dimension.decodeJson(obj));
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
onnx.TensorShapeProto.Dimension = class Dimension {
|
|
|
|
get value() {
|
|
onnx.TensorShapeProto.Dimension.valueSet = onnx.TensorShapeProto.Dimension.valueSet || new Set(["dim_value", "dim_param"]);
|
|
return Object.keys(this).find((key) => onnx.TensorShapeProto.Dimension.valueSet.has(key) && this[key] !== null);
|
|
}
|
|
|
|
static decode(reader, length) {
|
|
const message = new onnx.TensorShapeProto.Dimension();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.dim_value = reader.int64();
|
|
break;
|
|
case 2:
|
|
message.dim_param = reader.string();
|
|
break;
|
|
case 3:
|
|
message.denotation = reader.string();
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new onnx.TensorShapeProto.Dimension();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "dim_value":
|
|
message.dim_value = reader.int64();
|
|
break;
|
|
case "dim_param":
|
|
message.dim_param = reader.string();
|
|
break;
|
|
case "denotation":
|
|
message.denotation = reader.string();
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeJson(obj) {
|
|
const message = new onnx.TensorShapeProto.Dimension();
|
|
if ('dimValue' in obj) {
|
|
message.dim_value = BigInt(obj.dimValue);
|
|
}
|
|
if ('dimParam' in obj) {
|
|
message.dim_param = obj.dimParam;
|
|
}
|
|
if ('denotation' in obj) {
|
|
message.denotation = obj.denotation;
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
onnx.TensorShapeProto.Dimension.prototype.denotation = "";
|
|
|
|
onnx.TypeProto = class TypeProto {
|
|
|
|
get value() {
|
|
onnx.TypeProto.valueSet = onnx.TypeProto.valueSet || new Set(["tensor_type", "sequence_type", "map_type", "optional_type", "sparse_tensor_type", "opaque_type"]);
|
|
return Object.keys(this).find((key) => onnx.TypeProto.valueSet.has(key) && this[key] !== null);
|
|
}
|
|
|
|
static decode(reader, length) {
|
|
const message = new onnx.TypeProto();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.tensor_type = onnx.TypeProto.Tensor.decode(reader, reader.uint32());
|
|
break;
|
|
case 4:
|
|
message.sequence_type = onnx.TypeProto.Sequence.decode(reader, reader.uint32());
|
|
break;
|
|
case 5:
|
|
message.map_type = onnx.TypeProto.Map.decode(reader, reader.uint32());
|
|
break;
|
|
case 9:
|
|
message.optional_type = onnx.TypeProto.Optional.decode(reader, reader.uint32());
|
|
break;
|
|
case 8:
|
|
message.sparse_tensor_type = onnx.TypeProto.SparseTensor.decode(reader, reader.uint32());
|
|
break;
|
|
case 7:
|
|
message.opaque_type = onnx.TypeProto.Opaque.decode(reader, reader.uint32());
|
|
break;
|
|
case 6:
|
|
message.denotation = reader.string();
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new onnx.TypeProto();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "tensor_type":
|
|
message.tensor_type = onnx.TypeProto.Tensor.decodeText(reader);
|
|
break;
|
|
case "sequence_type":
|
|
message.sequence_type = onnx.TypeProto.Sequence.decodeText(reader);
|
|
break;
|
|
case "map_type":
|
|
message.map_type = onnx.TypeProto.Map.decodeText(reader);
|
|
break;
|
|
case "optional_type":
|
|
message.optional_type = onnx.TypeProto.Optional.decodeText(reader);
|
|
break;
|
|
case "sparse_tensor_type":
|
|
message.sparse_tensor_type = onnx.TypeProto.SparseTensor.decodeText(reader);
|
|
break;
|
|
case "opaque_type":
|
|
message.opaque_type = onnx.TypeProto.Opaque.decodeText(reader);
|
|
break;
|
|
case "denotation":
|
|
message.denotation = reader.string();
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeJson(obj) {
|
|
const message = new onnx.TypeProto();
|
|
if ('tensorType' in obj) {
|
|
message.tensor_type = onnx.TypeProto.Tensor.decodeJson(obj.tensorType);
|
|
}
|
|
if ('sequenceType' in obj) {
|
|
message.sequence_type = onnx.TypeProto.Sequence.decodeJson(obj.sequenceType);
|
|
}
|
|
if ('mapType' in obj) {
|
|
message.map_type = onnx.TypeProto.Map.decodeJson(obj.mapType);
|
|
}
|
|
if ('optionalType' in obj) {
|
|
message.optional_type = onnx.TypeProto.Optional.decodeJson(obj.optionalType);
|
|
}
|
|
if ('sparseTensorType' in obj) {
|
|
message.sparse_tensor_type = onnx.TypeProto.SparseTensor.decodeJson(obj.sparseTensorType);
|
|
}
|
|
if ('opaqueType' in obj) {
|
|
message.opaque_type = onnx.TypeProto.Opaque.decodeJson(obj.opaqueType);
|
|
}
|
|
if ('denotation' in obj) {
|
|
message.denotation = obj.denotation;
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
onnx.TypeProto.prototype.denotation = "";
|
|
|
|
onnx.TypeProto.Tensor = class Tensor {
|
|
|
|
static decode(reader, length) {
|
|
const message = new onnx.TypeProto.Tensor();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.elem_type = reader.int32();
|
|
break;
|
|
case 2:
|
|
message.shape = onnx.TensorShapeProto.decode(reader, reader.uint32());
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new onnx.TypeProto.Tensor();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "elem_type":
|
|
message.elem_type = reader.int32();
|
|
break;
|
|
case "shape":
|
|
message.shape = onnx.TensorShapeProto.decodeText(reader);
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeJson(obj) {
|
|
const message = new onnx.TypeProto.Tensor();
|
|
if ('elemType' in obj) {
|
|
message.elem_type = Number(obj.elemType);
|
|
}
|
|
if ('shape' in obj) {
|
|
message.shape = onnx.TensorShapeProto.decodeJson(obj.shape);
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
onnx.TypeProto.Tensor.prototype.elem_type = 0;
|
|
onnx.TypeProto.Tensor.prototype.shape = null;
|
|
|
|
onnx.TypeProto.Sequence = class Sequence {
|
|
|
|
static decode(reader, length) {
|
|
const message = new onnx.TypeProto.Sequence();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.elem_type = onnx.TypeProto.decode(reader, reader.uint32());
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new onnx.TypeProto.Sequence();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "elem_type":
|
|
message.elem_type = onnx.TypeProto.decodeText(reader);
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeJson(obj) {
|
|
const message = new onnx.TypeProto.Sequence();
|
|
if ('elemType' in obj) {
|
|
message.elem_type = onnx.TypeProto.decodeJson(obj.elemType);
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
onnx.TypeProto.Sequence.prototype.elem_type = null;
|
|
|
|
onnx.TypeProto.Map = class Map {
|
|
|
|
static decode(reader, length) {
|
|
const message = new onnx.TypeProto.Map();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.key_type = reader.int32();
|
|
break;
|
|
case 2:
|
|
message.value_type = onnx.TypeProto.decode(reader, reader.uint32());
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new onnx.TypeProto.Map();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "key_type":
|
|
message.key_type = reader.int32();
|
|
break;
|
|
case "value_type":
|
|
message.value_type = onnx.TypeProto.decodeText(reader);
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeJson(obj) {
|
|
const message = new onnx.TypeProto.Map();
|
|
if ('keyType' in obj) {
|
|
message.key_type = Number(obj.keyType);
|
|
}
|
|
if ('valueType' in obj) {
|
|
message.value_type = onnx.TypeProto.decodeJson(obj.valueType);
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
onnx.TypeProto.Map.prototype.key_type = 0;
|
|
onnx.TypeProto.Map.prototype.value_type = null;
|
|
|
|
onnx.TypeProto.Optional = class Optional {
|
|
|
|
static decode(reader, length) {
|
|
const message = new onnx.TypeProto.Optional();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.elem_type = onnx.TypeProto.decode(reader, reader.uint32());
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new onnx.TypeProto.Optional();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "elem_type":
|
|
message.elem_type = onnx.TypeProto.decodeText(reader);
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeJson(obj) {
|
|
const message = new onnx.TypeProto.Optional();
|
|
if ('elemType' in obj) {
|
|
message.elem_type = onnx.TypeProto.decodeJson(obj.elemType);
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
onnx.TypeProto.Optional.prototype.elem_type = null;
|
|
|
|
onnx.TypeProto.SparseTensor = class SparseTensor {
|
|
|
|
static decode(reader, length) {
|
|
const message = new onnx.TypeProto.SparseTensor();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.elem_type = reader.int32();
|
|
break;
|
|
case 2:
|
|
message.shape = onnx.TensorShapeProto.decode(reader, reader.uint32());
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new onnx.TypeProto.SparseTensor();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "elem_type":
|
|
message.elem_type = reader.int32();
|
|
break;
|
|
case "shape":
|
|
message.shape = onnx.TensorShapeProto.decodeText(reader);
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeJson(obj) {
|
|
const message = new onnx.TypeProto.SparseTensor();
|
|
if ('elemType' in obj) {
|
|
message.elem_type = Number(obj.elemType);
|
|
}
|
|
if ('shape' in obj) {
|
|
message.shape = onnx.TensorShapeProto.decodeJson(obj.shape);
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
onnx.TypeProto.SparseTensor.prototype.elem_type = 0;
|
|
onnx.TypeProto.SparseTensor.prototype.shape = null;
|
|
|
|
onnx.TypeProto.Opaque = class Opaque {
|
|
|
|
static decode(reader, length) {
|
|
const message = new onnx.TypeProto.Opaque();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.domain = reader.string();
|
|
break;
|
|
case 2:
|
|
message.name = reader.string();
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new onnx.TypeProto.Opaque();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "domain":
|
|
message.domain = reader.string();
|
|
break;
|
|
case "name":
|
|
message.name = reader.string();
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeJson(obj) {
|
|
const message = new onnx.TypeProto.Opaque();
|
|
if ('domain' in obj) {
|
|
message.domain = obj.domain;
|
|
}
|
|
if ('name' in obj) {
|
|
message.name = obj.name;
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
onnx.TypeProto.Opaque.prototype.domain = "";
|
|
onnx.TypeProto.Opaque.prototype.name = "";
|
|
|
|
onnx.OperatorSetIdProto = class OperatorSetIdProto {
|
|
|
|
static decode(reader, length) {
|
|
const message = new onnx.OperatorSetIdProto();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.domain = reader.string();
|
|
break;
|
|
case 2:
|
|
message.version = reader.int64();
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new onnx.OperatorSetIdProto();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "domain":
|
|
message.domain = reader.string();
|
|
break;
|
|
case "version":
|
|
message.version = reader.int64();
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeJson(obj) {
|
|
const message = new onnx.OperatorSetIdProto();
|
|
if ('domain' in obj) {
|
|
message.domain = obj.domain;
|
|
}
|
|
if ('version' in obj) {
|
|
message.version = BigInt(obj.version);
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
onnx.OperatorSetIdProto.prototype.domain = "";
|
|
onnx.OperatorSetIdProto.prototype.version = 0n;
|
|
|
|
onnx.OperatorStatus = {
|
|
"EXPERIMENTAL": 0,
|
|
"STABLE": 1
|
|
};
|
|
|
|
onnx.FunctionProto = class FunctionProto {
|
|
|
|
constructor() {
|
|
this.input = [];
|
|
this.output = [];
|
|
this.attribute = [];
|
|
this.attribute_proto = [];
|
|
this.node = [];
|
|
this.opset_import = [];
|
|
this.value_info = [];
|
|
this.metadata_props = [];
|
|
}
|
|
|
|
static decode(reader, length) {
|
|
const message = new onnx.FunctionProto();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.name = reader.string();
|
|
break;
|
|
case 4:
|
|
message.input.push(reader.string());
|
|
break;
|
|
case 5:
|
|
message.output.push(reader.string());
|
|
break;
|
|
case 6:
|
|
message.attribute.push(reader.string());
|
|
break;
|
|
case 11:
|
|
message.attribute_proto.push(onnx.AttributeProto.decode(reader, reader.uint32()));
|
|
break;
|
|
case 7:
|
|
message.node.push(onnx.NodeProto.decode(reader, reader.uint32()));
|
|
break;
|
|
case 8:
|
|
message.doc_string = reader.string();
|
|
break;
|
|
case 9:
|
|
message.opset_import.push(onnx.OperatorSetIdProto.decode(reader, reader.uint32()));
|
|
break;
|
|
case 10:
|
|
message.domain = reader.string();
|
|
break;
|
|
case 13:
|
|
message.overload = reader.string();
|
|
break;
|
|
case 12:
|
|
message.value_info.push(onnx.ValueInfoProto.decode(reader, reader.uint32()));
|
|
break;
|
|
case 14:
|
|
message.metadata_props.push(onnx.StringStringEntryProto.decode(reader, reader.uint32()));
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new onnx.FunctionProto();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "name":
|
|
message.name = reader.string();
|
|
break;
|
|
case "input":
|
|
reader.array(message.input, () => reader.string());
|
|
break;
|
|
case "output":
|
|
reader.array(message.output, () => reader.string());
|
|
break;
|
|
case "attribute":
|
|
reader.array(message.attribute, () => reader.string());
|
|
break;
|
|
case "attribute_proto":
|
|
message.attribute_proto.push(onnx.AttributeProto.decodeText(reader));
|
|
break;
|
|
case "node":
|
|
message.node.push(onnx.NodeProto.decodeText(reader));
|
|
break;
|
|
case "doc_string":
|
|
message.doc_string = reader.string();
|
|
break;
|
|
case "opset_import":
|
|
message.opset_import.push(onnx.OperatorSetIdProto.decodeText(reader));
|
|
break;
|
|
case "domain":
|
|
message.domain = reader.string();
|
|
break;
|
|
case "overload":
|
|
message.overload = reader.string();
|
|
break;
|
|
case "value_info":
|
|
message.value_info.push(onnx.ValueInfoProto.decodeText(reader));
|
|
break;
|
|
case "metadata_props":
|
|
message.metadata_props.push(onnx.StringStringEntryProto.decodeText(reader));
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeJson(obj) {
|
|
const message = new onnx.FunctionProto();
|
|
if ('name' in obj) {
|
|
message.name = obj.name;
|
|
}
|
|
if ('input' in obj) {
|
|
message.input = obj.input;
|
|
}
|
|
if ('output' in obj) {
|
|
message.output = obj.output;
|
|
}
|
|
if ('attribute' in obj) {
|
|
message.attribute = obj.attribute;
|
|
}
|
|
if ('attributeProto' in obj) {
|
|
message.attribute_proto = obj.attributeProto.map((obj) => onnx.AttributeProto.decodeJson(obj));
|
|
}
|
|
if ('node' in obj) {
|
|
message.node = obj.node.map((obj) => onnx.NodeProto.decodeJson(obj));
|
|
}
|
|
if ('docString' in obj) {
|
|
message.doc_string = obj.docString;
|
|
}
|
|
if ('opsetImport' in obj) {
|
|
message.opset_import = obj.opsetImport.map((obj) => onnx.OperatorSetIdProto.decodeJson(obj));
|
|
}
|
|
if ('domain' in obj) {
|
|
message.domain = obj.domain;
|
|
}
|
|
if ('overload' in obj) {
|
|
message.overload = obj.overload;
|
|
}
|
|
if ('valueInfo' in obj) {
|
|
message.value_info = obj.valueInfo.map((obj) => onnx.ValueInfoProto.decodeJson(obj));
|
|
}
|
|
if ('metadataProps' in obj) {
|
|
message.metadata_props = obj.metadataProps.map((obj) => onnx.StringStringEntryProto.decodeJson(obj));
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
onnx.FunctionProto.prototype.name = "";
|
|
onnx.FunctionProto.prototype.doc_string = "";
|
|
onnx.FunctionProto.prototype.domain = "";
|
|
onnx.FunctionProto.prototype.overload = "";
|
|
|
|
onnx.OperatorProto = class OperatorProto {
|
|
|
|
static decode(reader, length) {
|
|
const message = new onnx.OperatorProto();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.op_type = reader.string();
|
|
break;
|
|
case 2:
|
|
message.since_version = reader.int64();
|
|
break;
|
|
case 3:
|
|
message.status = reader.int32();
|
|
break;
|
|
case 10:
|
|
message.doc_string = reader.string();
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new onnx.OperatorProto();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "op_type":
|
|
message.op_type = reader.string();
|
|
break;
|
|
case "since_version":
|
|
message.since_version = reader.int64();
|
|
break;
|
|
case "status":
|
|
message.status = reader.enum(onnx.OperatorStatus);
|
|
break;
|
|
case "doc_string":
|
|
message.doc_string = reader.string();
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeJson(obj) {
|
|
const message = new onnx.OperatorProto();
|
|
if ('opType' in obj) {
|
|
message.op_type = obj.opType;
|
|
}
|
|
if ('sinceVersion' in obj) {
|
|
message.since_version = BigInt(obj.sinceVersion);
|
|
}
|
|
if ('status' in obj) {
|
|
message.status = typeof obj.status === 'string' ? onnx.OperatorStatus[obj.status] : obj.status;
|
|
}
|
|
if ('docString' in obj) {
|
|
message.doc_string = obj.docString;
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
onnx.OperatorProto.prototype.op_type = "";
|
|
onnx.OperatorProto.prototype.since_version = 0n;
|
|
onnx.OperatorProto.prototype.status = 0;
|
|
onnx.OperatorProto.prototype.doc_string = "";
|
|
|
|
onnx.OperatorSetProto = class OperatorSetProto {
|
|
|
|
constructor() {
|
|
this.operator = [];
|
|
this.functions = [];
|
|
}
|
|
|
|
static decode(reader, length) {
|
|
const message = new onnx.OperatorSetProto();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.magic = reader.string();
|
|
break;
|
|
case 2:
|
|
message.ir_version = reader.int64();
|
|
break;
|
|
case 3:
|
|
message.ir_version_prerelease = reader.string();
|
|
break;
|
|
case 7:
|
|
message.ir_build_metadata = reader.string();
|
|
break;
|
|
case 4:
|
|
message.domain = reader.string();
|
|
break;
|
|
case 5:
|
|
message.opset_version = reader.int64();
|
|
break;
|
|
case 6:
|
|
message.doc_string = reader.string();
|
|
break;
|
|
case 8:
|
|
message.operator.push(onnx.OperatorProto.decode(reader, reader.uint32()));
|
|
break;
|
|
case 9:
|
|
message.functions.push(onnx.FunctionProto.decode(reader, reader.uint32()));
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new onnx.OperatorSetProto();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "magic":
|
|
message.magic = reader.string();
|
|
break;
|
|
case "ir_version":
|
|
message.ir_version = reader.int64();
|
|
break;
|
|
case "ir_version_prerelease":
|
|
message.ir_version_prerelease = reader.string();
|
|
break;
|
|
case "ir_build_metadata":
|
|
message.ir_build_metadata = reader.string();
|
|
break;
|
|
case "domain":
|
|
message.domain = reader.string();
|
|
break;
|
|
case "opset_version":
|
|
message.opset_version = reader.int64();
|
|
break;
|
|
case "doc_string":
|
|
message.doc_string = reader.string();
|
|
break;
|
|
case "operator":
|
|
message.operator.push(onnx.OperatorProto.decodeText(reader));
|
|
break;
|
|
case "functions":
|
|
message.functions.push(onnx.FunctionProto.decodeText(reader));
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeJson(obj) {
|
|
const message = new onnx.OperatorSetProto();
|
|
if ('magic' in obj) {
|
|
message.magic = obj.magic;
|
|
}
|
|
if ('irVersion' in obj) {
|
|
message.ir_version = BigInt(obj.irVersion);
|
|
}
|
|
if ('irVersionPrerelease' in obj) {
|
|
message.ir_version_prerelease = obj.irVersionPrerelease;
|
|
}
|
|
if ('irBuildMetadata' in obj) {
|
|
message.ir_build_metadata = obj.irBuildMetadata;
|
|
}
|
|
if ('domain' in obj) {
|
|
message.domain = obj.domain;
|
|
}
|
|
if ('opsetVersion' in obj) {
|
|
message.opset_version = BigInt(obj.opsetVersion);
|
|
}
|
|
if ('docString' in obj) {
|
|
message.doc_string = obj.docString;
|
|
}
|
|
if ('operator' in obj) {
|
|
message.operator = obj.operator.map((obj) => onnx.OperatorProto.decodeJson(obj));
|
|
}
|
|
if ('functions' in obj) {
|
|
message.functions = obj.functions.map((obj) => onnx.FunctionProto.decodeJson(obj));
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
onnx.OperatorSetProto.prototype.magic = "";
|
|
onnx.OperatorSetProto.prototype.ir_version = 0n;
|
|
onnx.OperatorSetProto.prototype.ir_version_prerelease = "";
|
|
onnx.OperatorSetProto.prototype.ir_build_metadata = "";
|
|
onnx.OperatorSetProto.prototype.domain = "";
|
|
onnx.OperatorSetProto.prototype.opset_version = 0n;
|
|
onnx.OperatorSetProto.prototype.doc_string = "";
|