mirror of
https://github.com/saymrwulf/onnxruntime.git
synced 2026-05-25 22:26:24 +00:00
34c5424456
### Description [js] update a few packages - update semver - update reference of onnx_proto to local folder in order to upgrade protobufjs@7.2.4 Resolve AB#18513
7658 lines
344 KiB
JavaScript
7658 lines
344 KiB
JavaScript
/*eslint-disable block-scoped-var, id-length, no-control-regex, no-magic-numbers, no-prototype-builtins, no-redeclare, no-shadow, no-var, sort-vars*/
|
|
"use strict";
|
|
|
|
var $protobuf = require("protobufjs/minimal");
|
|
|
|
// Common aliases
|
|
var $Reader = $protobuf.Reader, $Writer = $protobuf.Writer, $util = $protobuf.util;
|
|
|
|
// Exported root namespace
|
|
var $root = $protobuf.roots["default"] || ($protobuf.roots["default"] = {});
|
|
|
|
$root.onnx = (function() {
|
|
|
|
/**
|
|
* Namespace onnx.
|
|
* @exports onnx
|
|
* @namespace
|
|
*/
|
|
var onnx = {};
|
|
|
|
/**
|
|
* Version enum.
|
|
* @name onnx.Version
|
|
* @enum {number}
|
|
* @property {number} _START_VERSION=0 _START_VERSION value
|
|
* @property {number} IR_VERSION_2017_10_10=1 IR_VERSION_2017_10_10 value
|
|
* @property {number} IR_VERSION_2017_10_30=2 IR_VERSION_2017_10_30 value
|
|
* @property {number} IR_VERSION_2017_11_3=3 IR_VERSION_2017_11_3 value
|
|
* @property {number} IR_VERSION_2019_1_22=4 IR_VERSION_2019_1_22 value
|
|
* @property {number} IR_VERSION_2019_3_18=5 IR_VERSION_2019_3_18 value
|
|
* @property {number} IR_VERSION_2019_9_19=6 IR_VERSION_2019_9_19 value
|
|
* @property {number} IR_VERSION_2020_5_8=7 IR_VERSION_2020_5_8 value
|
|
* @property {number} IR_VERSION_2021_7_30=8 IR_VERSION_2021_7_30 value
|
|
* @property {number} IR_VERSION=9 IR_VERSION value
|
|
*/
|
|
onnx.Version = (function() {
|
|
var valuesById = {}, values = Object.create(valuesById);
|
|
values[valuesById[0] = "_START_VERSION"] = 0;
|
|
values[valuesById[1] = "IR_VERSION_2017_10_10"] = 1;
|
|
values[valuesById[2] = "IR_VERSION_2017_10_30"] = 2;
|
|
values[valuesById[3] = "IR_VERSION_2017_11_3"] = 3;
|
|
values[valuesById[4] = "IR_VERSION_2019_1_22"] = 4;
|
|
values[valuesById[5] = "IR_VERSION_2019_3_18"] = 5;
|
|
values[valuesById[6] = "IR_VERSION_2019_9_19"] = 6;
|
|
values[valuesById[7] = "IR_VERSION_2020_5_8"] = 7;
|
|
values[valuesById[8] = "IR_VERSION_2021_7_30"] = 8;
|
|
values[valuesById[9] = "IR_VERSION"] = 9;
|
|
return values;
|
|
})();
|
|
|
|
onnx.AttributeProto = (function() {
|
|
|
|
/**
|
|
* Properties of an AttributeProto.
|
|
* @memberof onnx
|
|
* @interface IAttributeProto
|
|
* @property {string|null} [name] AttributeProto name
|
|
* @property {string|null} [refAttrName] AttributeProto refAttrName
|
|
* @property {string|null} [docString] AttributeProto docString
|
|
* @property {onnx.AttributeProto.AttributeType|null} [type] AttributeProto type
|
|
* @property {number|null} [f] AttributeProto f
|
|
* @property {number|Long|null} [i] AttributeProto i
|
|
* @property {Uint8Array|null} [s] AttributeProto s
|
|
* @property {onnx.ITensorProto|null} [t] AttributeProto t
|
|
* @property {onnx.IGraphProto|null} [g] AttributeProto g
|
|
* @property {onnx.ISparseTensorProto|null} [sparseTensor] AttributeProto sparseTensor
|
|
* @property {onnx.ITypeProto|null} [tp] AttributeProto tp
|
|
* @property {Array.<number>|null} [floats] AttributeProto floats
|
|
* @property {Array.<number|Long>|null} [ints] AttributeProto ints
|
|
* @property {Array.<Uint8Array>|null} [strings] AttributeProto strings
|
|
* @property {Array.<onnx.ITensorProto>|null} [tensors] AttributeProto tensors
|
|
* @property {Array.<onnx.IGraphProto>|null} [graphs] AttributeProto graphs
|
|
* @property {Array.<onnx.ISparseTensorProto>|null} [sparseTensors] AttributeProto sparseTensors
|
|
* @property {Array.<onnx.ITypeProto>|null} [typeProtos] AttributeProto typeProtos
|
|
*/
|
|
|
|
/**
|
|
* Constructs a new AttributeProto.
|
|
* @memberof onnx
|
|
* @classdesc Represents an AttributeProto.
|
|
* @implements IAttributeProto
|
|
* @constructor
|
|
* @param {onnx.IAttributeProto=} [properties] Properties to set
|
|
*/
|
|
function AttributeProto(properties) {
|
|
this.floats = [];
|
|
this.ints = [];
|
|
this.strings = [];
|
|
this.tensors = [];
|
|
this.graphs = [];
|
|
this.sparseTensors = [];
|
|
this.typeProtos = [];
|
|
if (properties)
|
|
for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
|
|
if (properties[keys[i]] != null)
|
|
this[keys[i]] = properties[keys[i]];
|
|
}
|
|
|
|
/**
|
|
* AttributeProto name.
|
|
* @member {string} name
|
|
* @memberof onnx.AttributeProto
|
|
* @instance
|
|
*/
|
|
AttributeProto.prototype.name = "";
|
|
|
|
/**
|
|
* AttributeProto refAttrName.
|
|
* @member {string} refAttrName
|
|
* @memberof onnx.AttributeProto
|
|
* @instance
|
|
*/
|
|
AttributeProto.prototype.refAttrName = "";
|
|
|
|
/**
|
|
* AttributeProto docString.
|
|
* @member {string} docString
|
|
* @memberof onnx.AttributeProto
|
|
* @instance
|
|
*/
|
|
AttributeProto.prototype.docString = "";
|
|
|
|
/**
|
|
* AttributeProto type.
|
|
* @member {onnx.AttributeProto.AttributeType} type
|
|
* @memberof onnx.AttributeProto
|
|
* @instance
|
|
*/
|
|
AttributeProto.prototype.type = 0;
|
|
|
|
/**
|
|
* AttributeProto f.
|
|
* @member {number} f
|
|
* @memberof onnx.AttributeProto
|
|
* @instance
|
|
*/
|
|
AttributeProto.prototype.f = 0;
|
|
|
|
/**
|
|
* AttributeProto i.
|
|
* @member {number|Long} i
|
|
* @memberof onnx.AttributeProto
|
|
* @instance
|
|
*/
|
|
AttributeProto.prototype.i = $util.Long ? $util.Long.fromBits(0,0,false) : 0;
|
|
|
|
/**
|
|
* AttributeProto s.
|
|
* @member {Uint8Array} s
|
|
* @memberof onnx.AttributeProto
|
|
* @instance
|
|
*/
|
|
AttributeProto.prototype.s = $util.newBuffer([]);
|
|
|
|
/**
|
|
* AttributeProto t.
|
|
* @member {onnx.ITensorProto|null|undefined} t
|
|
* @memberof onnx.AttributeProto
|
|
* @instance
|
|
*/
|
|
AttributeProto.prototype.t = null;
|
|
|
|
/**
|
|
* AttributeProto g.
|
|
* @member {onnx.IGraphProto|null|undefined} g
|
|
* @memberof onnx.AttributeProto
|
|
* @instance
|
|
*/
|
|
AttributeProto.prototype.g = null;
|
|
|
|
/**
|
|
* AttributeProto sparseTensor.
|
|
* @member {onnx.ISparseTensorProto|null|undefined} sparseTensor
|
|
* @memberof onnx.AttributeProto
|
|
* @instance
|
|
*/
|
|
AttributeProto.prototype.sparseTensor = null;
|
|
|
|
/**
|
|
* AttributeProto tp.
|
|
* @member {onnx.ITypeProto|null|undefined} tp
|
|
* @memberof onnx.AttributeProto
|
|
* @instance
|
|
*/
|
|
AttributeProto.prototype.tp = null;
|
|
|
|
/**
|
|
* AttributeProto floats.
|
|
* @member {Array.<number>} floats
|
|
* @memberof onnx.AttributeProto
|
|
* @instance
|
|
*/
|
|
AttributeProto.prototype.floats = $util.emptyArray;
|
|
|
|
/**
|
|
* AttributeProto ints.
|
|
* @member {Array.<number|Long>} ints
|
|
* @memberof onnx.AttributeProto
|
|
* @instance
|
|
*/
|
|
AttributeProto.prototype.ints = $util.emptyArray;
|
|
|
|
/**
|
|
* AttributeProto strings.
|
|
* @member {Array.<Uint8Array>} strings
|
|
* @memberof onnx.AttributeProto
|
|
* @instance
|
|
*/
|
|
AttributeProto.prototype.strings = $util.emptyArray;
|
|
|
|
/**
|
|
* AttributeProto tensors.
|
|
* @member {Array.<onnx.ITensorProto>} tensors
|
|
* @memberof onnx.AttributeProto
|
|
* @instance
|
|
*/
|
|
AttributeProto.prototype.tensors = $util.emptyArray;
|
|
|
|
/**
|
|
* AttributeProto graphs.
|
|
* @member {Array.<onnx.IGraphProto>} graphs
|
|
* @memberof onnx.AttributeProto
|
|
* @instance
|
|
*/
|
|
AttributeProto.prototype.graphs = $util.emptyArray;
|
|
|
|
/**
|
|
* AttributeProto sparseTensors.
|
|
* @member {Array.<onnx.ISparseTensorProto>} sparseTensors
|
|
* @memberof onnx.AttributeProto
|
|
* @instance
|
|
*/
|
|
AttributeProto.prototype.sparseTensors = $util.emptyArray;
|
|
|
|
/**
|
|
* AttributeProto typeProtos.
|
|
* @member {Array.<onnx.ITypeProto>} typeProtos
|
|
* @memberof onnx.AttributeProto
|
|
* @instance
|
|
*/
|
|
AttributeProto.prototype.typeProtos = $util.emptyArray;
|
|
|
|
/**
|
|
* Creates a new AttributeProto instance using the specified properties.
|
|
* @function create
|
|
* @memberof onnx.AttributeProto
|
|
* @static
|
|
* @param {onnx.IAttributeProto=} [properties] Properties to set
|
|
* @returns {onnx.AttributeProto} AttributeProto instance
|
|
*/
|
|
AttributeProto.create = function create(properties) {
|
|
return new AttributeProto(properties);
|
|
};
|
|
|
|
/**
|
|
* Encodes the specified AttributeProto message. Does not implicitly {@link onnx.AttributeProto.verify|verify} messages.
|
|
* @function encode
|
|
* @memberof onnx.AttributeProto
|
|
* @static
|
|
* @param {onnx.IAttributeProto} message AttributeProto message or plain object to encode
|
|
* @param {$protobuf.Writer} [writer] Writer to encode to
|
|
* @returns {$protobuf.Writer} Writer
|
|
*/
|
|
AttributeProto.encode = function encode(message, writer) {
|
|
if (!writer)
|
|
writer = $Writer.create();
|
|
if (message.name != null && Object.hasOwnProperty.call(message, "name"))
|
|
writer.uint32(/* id 1, wireType 2 =*/10).string(message.name);
|
|
if (message.f != null && Object.hasOwnProperty.call(message, "f"))
|
|
writer.uint32(/* id 2, wireType 5 =*/21).float(message.f);
|
|
if (message.i != null && Object.hasOwnProperty.call(message, "i"))
|
|
writer.uint32(/* id 3, wireType 0 =*/24).int64(message.i);
|
|
if (message.s != null && Object.hasOwnProperty.call(message, "s"))
|
|
writer.uint32(/* id 4, wireType 2 =*/34).bytes(message.s);
|
|
if (message.t != null && Object.hasOwnProperty.call(message, "t"))
|
|
$root.onnx.TensorProto.encode(message.t, writer.uint32(/* id 5, wireType 2 =*/42).fork()).ldelim();
|
|
if (message.g != null && Object.hasOwnProperty.call(message, "g"))
|
|
$root.onnx.GraphProto.encode(message.g, writer.uint32(/* id 6, wireType 2 =*/50).fork()).ldelim();
|
|
if (message.floats != null && message.floats.length) {
|
|
writer.uint32(/* id 7, wireType 2 =*/58).fork();
|
|
for (var i = 0; i < message.floats.length; ++i)
|
|
writer.float(message.floats[i]);
|
|
writer.ldelim();
|
|
}
|
|
if (message.ints != null && message.ints.length) {
|
|
writer.uint32(/* id 8, wireType 2 =*/66).fork();
|
|
for (var i = 0; i < message.ints.length; ++i)
|
|
writer.int64(message.ints[i]);
|
|
writer.ldelim();
|
|
}
|
|
if (message.strings != null && message.strings.length)
|
|
for (var i = 0; i < message.strings.length; ++i)
|
|
writer.uint32(/* id 9, wireType 2 =*/74).bytes(message.strings[i]);
|
|
if (message.tensors != null && message.tensors.length)
|
|
for (var i = 0; i < message.tensors.length; ++i)
|
|
$root.onnx.TensorProto.encode(message.tensors[i], writer.uint32(/* id 10, wireType 2 =*/82).fork()).ldelim();
|
|
if (message.graphs != null && message.graphs.length)
|
|
for (var i = 0; i < message.graphs.length; ++i)
|
|
$root.onnx.GraphProto.encode(message.graphs[i], writer.uint32(/* id 11, wireType 2 =*/90).fork()).ldelim();
|
|
if (message.docString != null && Object.hasOwnProperty.call(message, "docString"))
|
|
writer.uint32(/* id 13, wireType 2 =*/106).string(message.docString);
|
|
if (message.tp != null && Object.hasOwnProperty.call(message, "tp"))
|
|
$root.onnx.TypeProto.encode(message.tp, writer.uint32(/* id 14, wireType 2 =*/114).fork()).ldelim();
|
|
if (message.typeProtos != null && message.typeProtos.length)
|
|
for (var i = 0; i < message.typeProtos.length; ++i)
|
|
$root.onnx.TypeProto.encode(message.typeProtos[i], writer.uint32(/* id 15, wireType 2 =*/122).fork()).ldelim();
|
|
if (message.type != null && Object.hasOwnProperty.call(message, "type"))
|
|
writer.uint32(/* id 20, wireType 0 =*/160).int32(message.type);
|
|
if (message.refAttrName != null && Object.hasOwnProperty.call(message, "refAttrName"))
|
|
writer.uint32(/* id 21, wireType 2 =*/170).string(message.refAttrName);
|
|
if (message.sparseTensor != null && Object.hasOwnProperty.call(message, "sparseTensor"))
|
|
$root.onnx.SparseTensorProto.encode(message.sparseTensor, writer.uint32(/* id 22, wireType 2 =*/178).fork()).ldelim();
|
|
if (message.sparseTensors != null && message.sparseTensors.length)
|
|
for (var i = 0; i < message.sparseTensors.length; ++i)
|
|
$root.onnx.SparseTensorProto.encode(message.sparseTensors[i], writer.uint32(/* id 23, wireType 2 =*/186).fork()).ldelim();
|
|
return writer;
|
|
};
|
|
|
|
/**
|
|
* Encodes the specified AttributeProto message, length delimited. Does not implicitly {@link onnx.AttributeProto.verify|verify} messages.
|
|
* @function encodeDelimited
|
|
* @memberof onnx.AttributeProto
|
|
* @static
|
|
* @param {onnx.IAttributeProto} message AttributeProto message or plain object to encode
|
|
* @param {$protobuf.Writer} [writer] Writer to encode to
|
|
* @returns {$protobuf.Writer} Writer
|
|
*/
|
|
AttributeProto.encodeDelimited = function encodeDelimited(message, writer) {
|
|
return this.encode(message, writer).ldelim();
|
|
};
|
|
|
|
/**
|
|
* Decodes an AttributeProto message from the specified reader or buffer.
|
|
* @function decode
|
|
* @memberof onnx.AttributeProto
|
|
* @static
|
|
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
|
|
* @param {number} [length] Message length if known beforehand
|
|
* @returns {onnx.AttributeProto} AttributeProto
|
|
* @throws {Error} If the payload is not a reader or valid buffer
|
|
* @throws {$protobuf.util.ProtocolError} If required fields are missing
|
|
*/
|
|
AttributeProto.decode = function decode(reader, length) {
|
|
if (!(reader instanceof $Reader))
|
|
reader = $Reader.create(reader);
|
|
var end = length === undefined ? reader.len : reader.pos + length, message = new $root.onnx.AttributeProto();
|
|
while (reader.pos < end) {
|
|
var tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1: {
|
|
message.name = reader.string();
|
|
break;
|
|
}
|
|
case 21: {
|
|
message.refAttrName = reader.string();
|
|
break;
|
|
}
|
|
case 13: {
|
|
message.docString = 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 = $root.onnx.TensorProto.decode(reader, reader.uint32());
|
|
break;
|
|
}
|
|
case 6: {
|
|
message.g = $root.onnx.GraphProto.decode(reader, reader.uint32());
|
|
break;
|
|
}
|
|
case 22: {
|
|
message.sparseTensor = $root.onnx.SparseTensorProto.decode(reader, reader.uint32());
|
|
break;
|
|
}
|
|
case 14: {
|
|
message.tp = $root.onnx.TypeProto.decode(reader, reader.uint32());
|
|
break;
|
|
}
|
|
case 7: {
|
|
if (!(message.floats && message.floats.length))
|
|
message.floats = [];
|
|
if ((tag & 7) === 2) {
|
|
var end2 = reader.uint32() + reader.pos;
|
|
while (reader.pos < end2)
|
|
message.floats.push(reader.float());
|
|
} else
|
|
message.floats.push(reader.float());
|
|
break;
|
|
}
|
|
case 8: {
|
|
if (!(message.ints && message.ints.length))
|
|
message.ints = [];
|
|
if ((tag & 7) === 2) {
|
|
var end2 = reader.uint32() + reader.pos;
|
|
while (reader.pos < end2)
|
|
message.ints.push(reader.int64());
|
|
} else
|
|
message.ints.push(reader.int64());
|
|
break;
|
|
}
|
|
case 9: {
|
|
if (!(message.strings && message.strings.length))
|
|
message.strings = [];
|
|
message.strings.push(reader.bytes());
|
|
break;
|
|
}
|
|
case 10: {
|
|
if (!(message.tensors && message.tensors.length))
|
|
message.tensors = [];
|
|
message.tensors.push($root.onnx.TensorProto.decode(reader, reader.uint32()));
|
|
break;
|
|
}
|
|
case 11: {
|
|
if (!(message.graphs && message.graphs.length))
|
|
message.graphs = [];
|
|
message.graphs.push($root.onnx.GraphProto.decode(reader, reader.uint32()));
|
|
break;
|
|
}
|
|
case 23: {
|
|
if (!(message.sparseTensors && message.sparseTensors.length))
|
|
message.sparseTensors = [];
|
|
message.sparseTensors.push($root.onnx.SparseTensorProto.decode(reader, reader.uint32()));
|
|
break;
|
|
}
|
|
case 15: {
|
|
if (!(message.typeProtos && message.typeProtos.length))
|
|
message.typeProtos = [];
|
|
message.typeProtos.push($root.onnx.TypeProto.decode(reader, reader.uint32()));
|
|
break;
|
|
}
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
};
|
|
|
|
/**
|
|
* Decodes an AttributeProto message from the specified reader or buffer, length delimited.
|
|
* @function decodeDelimited
|
|
* @memberof onnx.AttributeProto
|
|
* @static
|
|
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
|
|
* @returns {onnx.AttributeProto} AttributeProto
|
|
* @throws {Error} If the payload is not a reader or valid buffer
|
|
* @throws {$protobuf.util.ProtocolError} If required fields are missing
|
|
*/
|
|
AttributeProto.decodeDelimited = function decodeDelimited(reader) {
|
|
if (!(reader instanceof $Reader))
|
|
reader = new $Reader(reader);
|
|
return this.decode(reader, reader.uint32());
|
|
};
|
|
|
|
/**
|
|
* Verifies an AttributeProto message.
|
|
* @function verify
|
|
* @memberof onnx.AttributeProto
|
|
* @static
|
|
* @param {Object.<string,*>} message Plain object to verify
|
|
* @returns {string|null} `null` if valid, otherwise the reason why it is not
|
|
*/
|
|
AttributeProto.verify = function verify(message) {
|
|
if (typeof message !== "object" || message === null)
|
|
return "object expected";
|
|
if (message.name != null && message.hasOwnProperty("name"))
|
|
if (!$util.isString(message.name))
|
|
return "name: string expected";
|
|
if (message.refAttrName != null && message.hasOwnProperty("refAttrName"))
|
|
if (!$util.isString(message.refAttrName))
|
|
return "refAttrName: string expected";
|
|
if (message.docString != null && message.hasOwnProperty("docString"))
|
|
if (!$util.isString(message.docString))
|
|
return "docString: string expected";
|
|
if (message.type != null && message.hasOwnProperty("type"))
|
|
switch (message.type) {
|
|
default:
|
|
return "type: enum value expected";
|
|
case 0:
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
case 4:
|
|
case 5:
|
|
case 11:
|
|
case 13:
|
|
case 6:
|
|
case 7:
|
|
case 8:
|
|
case 9:
|
|
case 10:
|
|
case 12:
|
|
case 14:
|
|
break;
|
|
}
|
|
if (message.f != null && message.hasOwnProperty("f"))
|
|
if (typeof message.f !== "number")
|
|
return "f: number expected";
|
|
if (message.i != null && message.hasOwnProperty("i"))
|
|
if (!$util.isInteger(message.i) && !(message.i && $util.isInteger(message.i.low) && $util.isInteger(message.i.high)))
|
|
return "i: integer|Long expected";
|
|
if (message.s != null && message.hasOwnProperty("s"))
|
|
if (!(message.s && typeof message.s.length === "number" || $util.isString(message.s)))
|
|
return "s: buffer expected";
|
|
if (message.t != null && message.hasOwnProperty("t")) {
|
|
var error = $root.onnx.TensorProto.verify(message.t);
|
|
if (error)
|
|
return "t." + error;
|
|
}
|
|
if (message.g != null && message.hasOwnProperty("g")) {
|
|
var error = $root.onnx.GraphProto.verify(message.g);
|
|
if (error)
|
|
return "g." + error;
|
|
}
|
|
if (message.sparseTensor != null && message.hasOwnProperty("sparseTensor")) {
|
|
var error = $root.onnx.SparseTensorProto.verify(message.sparseTensor);
|
|
if (error)
|
|
return "sparseTensor." + error;
|
|
}
|
|
if (message.tp != null && message.hasOwnProperty("tp")) {
|
|
var error = $root.onnx.TypeProto.verify(message.tp);
|
|
if (error)
|
|
return "tp." + error;
|
|
}
|
|
if (message.floats != null && message.hasOwnProperty("floats")) {
|
|
if (!Array.isArray(message.floats))
|
|
return "floats: array expected";
|
|
for (var i = 0; i < message.floats.length; ++i)
|
|
if (typeof message.floats[i] !== "number")
|
|
return "floats: number[] expected";
|
|
}
|
|
if (message.ints != null && message.hasOwnProperty("ints")) {
|
|
if (!Array.isArray(message.ints))
|
|
return "ints: array expected";
|
|
for (var i = 0; i < message.ints.length; ++i)
|
|
if (!$util.isInteger(message.ints[i]) && !(message.ints[i] && $util.isInteger(message.ints[i].low) && $util.isInteger(message.ints[i].high)))
|
|
return "ints: integer|Long[] expected";
|
|
}
|
|
if (message.strings != null && message.hasOwnProperty("strings")) {
|
|
if (!Array.isArray(message.strings))
|
|
return "strings: array expected";
|
|
for (var i = 0; i < message.strings.length; ++i)
|
|
if (!(message.strings[i] && typeof message.strings[i].length === "number" || $util.isString(message.strings[i])))
|
|
return "strings: buffer[] expected";
|
|
}
|
|
if (message.tensors != null && message.hasOwnProperty("tensors")) {
|
|
if (!Array.isArray(message.tensors))
|
|
return "tensors: array expected";
|
|
for (var i = 0; i < message.tensors.length; ++i) {
|
|
var error = $root.onnx.TensorProto.verify(message.tensors[i]);
|
|
if (error)
|
|
return "tensors." + error;
|
|
}
|
|
}
|
|
if (message.graphs != null && message.hasOwnProperty("graphs")) {
|
|
if (!Array.isArray(message.graphs))
|
|
return "graphs: array expected";
|
|
for (var i = 0; i < message.graphs.length; ++i) {
|
|
var error = $root.onnx.GraphProto.verify(message.graphs[i]);
|
|
if (error)
|
|
return "graphs." + error;
|
|
}
|
|
}
|
|
if (message.sparseTensors != null && message.hasOwnProperty("sparseTensors")) {
|
|
if (!Array.isArray(message.sparseTensors))
|
|
return "sparseTensors: array expected";
|
|
for (var i = 0; i < message.sparseTensors.length; ++i) {
|
|
var error = $root.onnx.SparseTensorProto.verify(message.sparseTensors[i]);
|
|
if (error)
|
|
return "sparseTensors." + error;
|
|
}
|
|
}
|
|
if (message.typeProtos != null && message.hasOwnProperty("typeProtos")) {
|
|
if (!Array.isArray(message.typeProtos))
|
|
return "typeProtos: array expected";
|
|
for (var i = 0; i < message.typeProtos.length; ++i) {
|
|
var error = $root.onnx.TypeProto.verify(message.typeProtos[i]);
|
|
if (error)
|
|
return "typeProtos." + error;
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
|
|
/**
|
|
* Creates an AttributeProto message from a plain object. Also converts values to their respective internal types.
|
|
* @function fromObject
|
|
* @memberof onnx.AttributeProto
|
|
* @static
|
|
* @param {Object.<string,*>} object Plain object
|
|
* @returns {onnx.AttributeProto} AttributeProto
|
|
*/
|
|
AttributeProto.fromObject = function fromObject(object) {
|
|
if (object instanceof $root.onnx.AttributeProto)
|
|
return object;
|
|
var message = new $root.onnx.AttributeProto();
|
|
if (object.name != null)
|
|
message.name = String(object.name);
|
|
if (object.refAttrName != null)
|
|
message.refAttrName = String(object.refAttrName);
|
|
if (object.docString != null)
|
|
message.docString = String(object.docString);
|
|
switch (object.type) {
|
|
default:
|
|
if (typeof object.type === "number") {
|
|
message.type = object.type;
|
|
break;
|
|
}
|
|
break;
|
|
case "UNDEFINED":
|
|
case 0:
|
|
message.type = 0;
|
|
break;
|
|
case "FLOAT":
|
|
case 1:
|
|
message.type = 1;
|
|
break;
|
|
case "INT":
|
|
case 2:
|
|
message.type = 2;
|
|
break;
|
|
case "STRING":
|
|
case 3:
|
|
message.type = 3;
|
|
break;
|
|
case "TENSOR":
|
|
case 4:
|
|
message.type = 4;
|
|
break;
|
|
case "GRAPH":
|
|
case 5:
|
|
message.type = 5;
|
|
break;
|
|
case "SPARSE_TENSOR":
|
|
case 11:
|
|
message.type = 11;
|
|
break;
|
|
case "TYPE_PROTO":
|
|
case 13:
|
|
message.type = 13;
|
|
break;
|
|
case "FLOATS":
|
|
case 6:
|
|
message.type = 6;
|
|
break;
|
|
case "INTS":
|
|
case 7:
|
|
message.type = 7;
|
|
break;
|
|
case "STRINGS":
|
|
case 8:
|
|
message.type = 8;
|
|
break;
|
|
case "TENSORS":
|
|
case 9:
|
|
message.type = 9;
|
|
break;
|
|
case "GRAPHS":
|
|
case 10:
|
|
message.type = 10;
|
|
break;
|
|
case "SPARSE_TENSORS":
|
|
case 12:
|
|
message.type = 12;
|
|
break;
|
|
case "TYPE_PROTOS":
|
|
case 14:
|
|
message.type = 14;
|
|
break;
|
|
}
|
|
if (object.f != null)
|
|
message.f = Number(object.f);
|
|
if (object.i != null)
|
|
if ($util.Long)
|
|
(message.i = $util.Long.fromValue(object.i)).unsigned = false;
|
|
else if (typeof object.i === "string")
|
|
message.i = parseInt(object.i, 10);
|
|
else if (typeof object.i === "number")
|
|
message.i = object.i;
|
|
else if (typeof object.i === "object")
|
|
message.i = new $util.LongBits(object.i.low >>> 0, object.i.high >>> 0).toNumber();
|
|
if (object.s != null)
|
|
if (typeof object.s === "string")
|
|
$util.base64.decode(object.s, message.s = $util.newBuffer($util.base64.length(object.s)), 0);
|
|
else if (object.s.length >= 0)
|
|
message.s = object.s;
|
|
if (object.t != null) {
|
|
if (typeof object.t !== "object")
|
|
throw TypeError(".onnx.AttributeProto.t: object expected");
|
|
message.t = $root.onnx.TensorProto.fromObject(object.t);
|
|
}
|
|
if (object.g != null) {
|
|
if (typeof object.g !== "object")
|
|
throw TypeError(".onnx.AttributeProto.g: object expected");
|
|
message.g = $root.onnx.GraphProto.fromObject(object.g);
|
|
}
|
|
if (object.sparseTensor != null) {
|
|
if (typeof object.sparseTensor !== "object")
|
|
throw TypeError(".onnx.AttributeProto.sparseTensor: object expected");
|
|
message.sparseTensor = $root.onnx.SparseTensorProto.fromObject(object.sparseTensor);
|
|
}
|
|
if (object.tp != null) {
|
|
if (typeof object.tp !== "object")
|
|
throw TypeError(".onnx.AttributeProto.tp: object expected");
|
|
message.tp = $root.onnx.TypeProto.fromObject(object.tp);
|
|
}
|
|
if (object.floats) {
|
|
if (!Array.isArray(object.floats))
|
|
throw TypeError(".onnx.AttributeProto.floats: array expected");
|
|
message.floats = [];
|
|
for (var i = 0; i < object.floats.length; ++i)
|
|
message.floats[i] = Number(object.floats[i]);
|
|
}
|
|
if (object.ints) {
|
|
if (!Array.isArray(object.ints))
|
|
throw TypeError(".onnx.AttributeProto.ints: array expected");
|
|
message.ints = [];
|
|
for (var i = 0; i < object.ints.length; ++i)
|
|
if ($util.Long)
|
|
(message.ints[i] = $util.Long.fromValue(object.ints[i])).unsigned = false;
|
|
else if (typeof object.ints[i] === "string")
|
|
message.ints[i] = parseInt(object.ints[i], 10);
|
|
else if (typeof object.ints[i] === "number")
|
|
message.ints[i] = object.ints[i];
|
|
else if (typeof object.ints[i] === "object")
|
|
message.ints[i] = new $util.LongBits(object.ints[i].low >>> 0, object.ints[i].high >>> 0).toNumber();
|
|
}
|
|
if (object.strings) {
|
|
if (!Array.isArray(object.strings))
|
|
throw TypeError(".onnx.AttributeProto.strings: array expected");
|
|
message.strings = [];
|
|
for (var i = 0; i < object.strings.length; ++i)
|
|
if (typeof object.strings[i] === "string")
|
|
$util.base64.decode(object.strings[i], message.strings[i] = $util.newBuffer($util.base64.length(object.strings[i])), 0);
|
|
else if (object.strings[i].length >= 0)
|
|
message.strings[i] = object.strings[i];
|
|
}
|
|
if (object.tensors) {
|
|
if (!Array.isArray(object.tensors))
|
|
throw TypeError(".onnx.AttributeProto.tensors: array expected");
|
|
message.tensors = [];
|
|
for (var i = 0; i < object.tensors.length; ++i) {
|
|
if (typeof object.tensors[i] !== "object")
|
|
throw TypeError(".onnx.AttributeProto.tensors: object expected");
|
|
message.tensors[i] = $root.onnx.TensorProto.fromObject(object.tensors[i]);
|
|
}
|
|
}
|
|
if (object.graphs) {
|
|
if (!Array.isArray(object.graphs))
|
|
throw TypeError(".onnx.AttributeProto.graphs: array expected");
|
|
message.graphs = [];
|
|
for (var i = 0; i < object.graphs.length; ++i) {
|
|
if (typeof object.graphs[i] !== "object")
|
|
throw TypeError(".onnx.AttributeProto.graphs: object expected");
|
|
message.graphs[i] = $root.onnx.GraphProto.fromObject(object.graphs[i]);
|
|
}
|
|
}
|
|
if (object.sparseTensors) {
|
|
if (!Array.isArray(object.sparseTensors))
|
|
throw TypeError(".onnx.AttributeProto.sparseTensors: array expected");
|
|
message.sparseTensors = [];
|
|
for (var i = 0; i < object.sparseTensors.length; ++i) {
|
|
if (typeof object.sparseTensors[i] !== "object")
|
|
throw TypeError(".onnx.AttributeProto.sparseTensors: object expected");
|
|
message.sparseTensors[i] = $root.onnx.SparseTensorProto.fromObject(object.sparseTensors[i]);
|
|
}
|
|
}
|
|
if (object.typeProtos) {
|
|
if (!Array.isArray(object.typeProtos))
|
|
throw TypeError(".onnx.AttributeProto.typeProtos: array expected");
|
|
message.typeProtos = [];
|
|
for (var i = 0; i < object.typeProtos.length; ++i) {
|
|
if (typeof object.typeProtos[i] !== "object")
|
|
throw TypeError(".onnx.AttributeProto.typeProtos: object expected");
|
|
message.typeProtos[i] = $root.onnx.TypeProto.fromObject(object.typeProtos[i]);
|
|
}
|
|
}
|
|
return message;
|
|
};
|
|
|
|
/**
|
|
* Creates a plain object from an AttributeProto message. Also converts values to other types if specified.
|
|
* @function toObject
|
|
* @memberof onnx.AttributeProto
|
|
* @static
|
|
* @param {onnx.AttributeProto} message AttributeProto
|
|
* @param {$protobuf.IConversionOptions} [options] Conversion options
|
|
* @returns {Object.<string,*>} Plain object
|
|
*/
|
|
AttributeProto.toObject = function toObject(message, options) {
|
|
if (!options)
|
|
options = {};
|
|
var object = {};
|
|
if (options.arrays || options.defaults) {
|
|
object.floats = [];
|
|
object.ints = [];
|
|
object.strings = [];
|
|
object.tensors = [];
|
|
object.graphs = [];
|
|
object.typeProtos = [];
|
|
object.sparseTensors = [];
|
|
}
|
|
if (options.defaults) {
|
|
object.name = "";
|
|
object.f = 0;
|
|
if ($util.Long) {
|
|
var long = new $util.Long(0, 0, false);
|
|
object.i = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
|
|
} else
|
|
object.i = options.longs === String ? "0" : 0;
|
|
if (options.bytes === String)
|
|
object.s = "";
|
|
else {
|
|
object.s = [];
|
|
if (options.bytes !== Array)
|
|
object.s = $util.newBuffer(object.s);
|
|
}
|
|
object.t = null;
|
|
object.g = null;
|
|
object.docString = "";
|
|
object.tp = null;
|
|
object.type = options.enums === String ? "UNDEFINED" : 0;
|
|
object.refAttrName = "";
|
|
object.sparseTensor = null;
|
|
}
|
|
if (message.name != null && message.hasOwnProperty("name"))
|
|
object.name = message.name;
|
|
if (message.f != null && message.hasOwnProperty("f"))
|
|
object.f = options.json && !isFinite(message.f) ? String(message.f) : message.f;
|
|
if (message.i != null && message.hasOwnProperty("i"))
|
|
if (typeof message.i === "number")
|
|
object.i = options.longs === String ? String(message.i) : message.i;
|
|
else
|
|
object.i = options.longs === String ? $util.Long.prototype.toString.call(message.i) : options.longs === Number ? new $util.LongBits(message.i.low >>> 0, message.i.high >>> 0).toNumber() : message.i;
|
|
if (message.s != null && message.hasOwnProperty("s"))
|
|
object.s = options.bytes === String ? $util.base64.encode(message.s, 0, message.s.length) : options.bytes === Array ? Array.prototype.slice.call(message.s) : message.s;
|
|
if (message.t != null && message.hasOwnProperty("t"))
|
|
object.t = $root.onnx.TensorProto.toObject(message.t, options);
|
|
if (message.g != null && message.hasOwnProperty("g"))
|
|
object.g = $root.onnx.GraphProto.toObject(message.g, options);
|
|
if (message.floats && message.floats.length) {
|
|
object.floats = [];
|
|
for (var j = 0; j < message.floats.length; ++j)
|
|
object.floats[j] = options.json && !isFinite(message.floats[j]) ? String(message.floats[j]) : message.floats[j];
|
|
}
|
|
if (message.ints && message.ints.length) {
|
|
object.ints = [];
|
|
for (var j = 0; j < message.ints.length; ++j)
|
|
if (typeof message.ints[j] === "number")
|
|
object.ints[j] = options.longs === String ? String(message.ints[j]) : message.ints[j];
|
|
else
|
|
object.ints[j] = options.longs === String ? $util.Long.prototype.toString.call(message.ints[j]) : options.longs === Number ? new $util.LongBits(message.ints[j].low >>> 0, message.ints[j].high >>> 0).toNumber() : message.ints[j];
|
|
}
|
|
if (message.strings && message.strings.length) {
|
|
object.strings = [];
|
|
for (var j = 0; j < message.strings.length; ++j)
|
|
object.strings[j] = options.bytes === String ? $util.base64.encode(message.strings[j], 0, message.strings[j].length) : options.bytes === Array ? Array.prototype.slice.call(message.strings[j]) : message.strings[j];
|
|
}
|
|
if (message.tensors && message.tensors.length) {
|
|
object.tensors = [];
|
|
for (var j = 0; j < message.tensors.length; ++j)
|
|
object.tensors[j] = $root.onnx.TensorProto.toObject(message.tensors[j], options);
|
|
}
|
|
if (message.graphs && message.graphs.length) {
|
|
object.graphs = [];
|
|
for (var j = 0; j < message.graphs.length; ++j)
|
|
object.graphs[j] = $root.onnx.GraphProto.toObject(message.graphs[j], options);
|
|
}
|
|
if (message.docString != null && message.hasOwnProperty("docString"))
|
|
object.docString = message.docString;
|
|
if (message.tp != null && message.hasOwnProperty("tp"))
|
|
object.tp = $root.onnx.TypeProto.toObject(message.tp, options);
|
|
if (message.typeProtos && message.typeProtos.length) {
|
|
object.typeProtos = [];
|
|
for (var j = 0; j < message.typeProtos.length; ++j)
|
|
object.typeProtos[j] = $root.onnx.TypeProto.toObject(message.typeProtos[j], options);
|
|
}
|
|
if (message.type != null && message.hasOwnProperty("type"))
|
|
object.type = options.enums === String ? $root.onnx.AttributeProto.AttributeType[message.type] === undefined ? message.type : $root.onnx.AttributeProto.AttributeType[message.type] : message.type;
|
|
if (message.refAttrName != null && message.hasOwnProperty("refAttrName"))
|
|
object.refAttrName = message.refAttrName;
|
|
if (message.sparseTensor != null && message.hasOwnProperty("sparseTensor"))
|
|
object.sparseTensor = $root.onnx.SparseTensorProto.toObject(message.sparseTensor, options);
|
|
if (message.sparseTensors && message.sparseTensors.length) {
|
|
object.sparseTensors = [];
|
|
for (var j = 0; j < message.sparseTensors.length; ++j)
|
|
object.sparseTensors[j] = $root.onnx.SparseTensorProto.toObject(message.sparseTensors[j], options);
|
|
}
|
|
return object;
|
|
};
|
|
|
|
/**
|
|
* Converts this AttributeProto to JSON.
|
|
* @function toJSON
|
|
* @memberof onnx.AttributeProto
|
|
* @instance
|
|
* @returns {Object.<string,*>} JSON object
|
|
*/
|
|
AttributeProto.prototype.toJSON = function toJSON() {
|
|
return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
|
|
};
|
|
|
|
/**
|
|
* Gets the default type url for AttributeProto
|
|
* @function getTypeUrl
|
|
* @memberof onnx.AttributeProto
|
|
* @static
|
|
* @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
|
|
* @returns {string} The default type url
|
|
*/
|
|
AttributeProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
|
|
if (typeUrlPrefix === undefined) {
|
|
typeUrlPrefix = "type.googleapis.com";
|
|
}
|
|
return typeUrlPrefix + "/onnx.AttributeProto";
|
|
};
|
|
|
|
/**
|
|
* AttributeType enum.
|
|
* @name onnx.AttributeProto.AttributeType
|
|
* @enum {number}
|
|
* @property {number} UNDEFINED=0 UNDEFINED value
|
|
* @property {number} FLOAT=1 FLOAT value
|
|
* @property {number} INT=2 INT value
|
|
* @property {number} STRING=3 STRING value
|
|
* @property {number} TENSOR=4 TENSOR value
|
|
* @property {number} GRAPH=5 GRAPH value
|
|
* @property {number} SPARSE_TENSOR=11 SPARSE_TENSOR value
|
|
* @property {number} TYPE_PROTO=13 TYPE_PROTO value
|
|
* @property {number} FLOATS=6 FLOATS value
|
|
* @property {number} INTS=7 INTS value
|
|
* @property {number} STRINGS=8 STRINGS value
|
|
* @property {number} TENSORS=9 TENSORS value
|
|
* @property {number} GRAPHS=10 GRAPHS value
|
|
* @property {number} SPARSE_TENSORS=12 SPARSE_TENSORS value
|
|
* @property {number} TYPE_PROTOS=14 TYPE_PROTOS value
|
|
*/
|
|
AttributeProto.AttributeType = (function() {
|
|
var valuesById = {}, values = Object.create(valuesById);
|
|
values[valuesById[0] = "UNDEFINED"] = 0;
|
|
values[valuesById[1] = "FLOAT"] = 1;
|
|
values[valuesById[2] = "INT"] = 2;
|
|
values[valuesById[3] = "STRING"] = 3;
|
|
values[valuesById[4] = "TENSOR"] = 4;
|
|
values[valuesById[5] = "GRAPH"] = 5;
|
|
values[valuesById[11] = "SPARSE_TENSOR"] = 11;
|
|
values[valuesById[13] = "TYPE_PROTO"] = 13;
|
|
values[valuesById[6] = "FLOATS"] = 6;
|
|
values[valuesById[7] = "INTS"] = 7;
|
|
values[valuesById[8] = "STRINGS"] = 8;
|
|
values[valuesById[9] = "TENSORS"] = 9;
|
|
values[valuesById[10] = "GRAPHS"] = 10;
|
|
values[valuesById[12] = "SPARSE_TENSORS"] = 12;
|
|
values[valuesById[14] = "TYPE_PROTOS"] = 14;
|
|
return values;
|
|
})();
|
|
|
|
return AttributeProto;
|
|
})();
|
|
|
|
onnx.ValueInfoProto = (function() {
|
|
|
|
/**
|
|
* Properties of a ValueInfoProto.
|
|
* @memberof onnx
|
|
* @interface IValueInfoProto
|
|
* @property {string|null} [name] ValueInfoProto name
|
|
* @property {onnx.ITypeProto|null} [type] ValueInfoProto type
|
|
* @property {string|null} [docString] ValueInfoProto docString
|
|
*/
|
|
|
|
/**
|
|
* Constructs a new ValueInfoProto.
|
|
* @memberof onnx
|
|
* @classdesc Represents a ValueInfoProto.
|
|
* @implements IValueInfoProto
|
|
* @constructor
|
|
* @param {onnx.IValueInfoProto=} [properties] Properties to set
|
|
*/
|
|
function ValueInfoProto(properties) {
|
|
if (properties)
|
|
for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
|
|
if (properties[keys[i]] != null)
|
|
this[keys[i]] = properties[keys[i]];
|
|
}
|
|
|
|
/**
|
|
* ValueInfoProto name.
|
|
* @member {string} name
|
|
* @memberof onnx.ValueInfoProto
|
|
* @instance
|
|
*/
|
|
ValueInfoProto.prototype.name = "";
|
|
|
|
/**
|
|
* ValueInfoProto type.
|
|
* @member {onnx.ITypeProto|null|undefined} type
|
|
* @memberof onnx.ValueInfoProto
|
|
* @instance
|
|
*/
|
|
ValueInfoProto.prototype.type = null;
|
|
|
|
/**
|
|
* ValueInfoProto docString.
|
|
* @member {string} docString
|
|
* @memberof onnx.ValueInfoProto
|
|
* @instance
|
|
*/
|
|
ValueInfoProto.prototype.docString = "";
|
|
|
|
/**
|
|
* Creates a new ValueInfoProto instance using the specified properties.
|
|
* @function create
|
|
* @memberof onnx.ValueInfoProto
|
|
* @static
|
|
* @param {onnx.IValueInfoProto=} [properties] Properties to set
|
|
* @returns {onnx.ValueInfoProto} ValueInfoProto instance
|
|
*/
|
|
ValueInfoProto.create = function create(properties) {
|
|
return new ValueInfoProto(properties);
|
|
};
|
|
|
|
/**
|
|
* Encodes the specified ValueInfoProto message. Does not implicitly {@link onnx.ValueInfoProto.verify|verify} messages.
|
|
* @function encode
|
|
* @memberof onnx.ValueInfoProto
|
|
* @static
|
|
* @param {onnx.IValueInfoProto} message ValueInfoProto message or plain object to encode
|
|
* @param {$protobuf.Writer} [writer] Writer to encode to
|
|
* @returns {$protobuf.Writer} Writer
|
|
*/
|
|
ValueInfoProto.encode = function encode(message, writer) {
|
|
if (!writer)
|
|
writer = $Writer.create();
|
|
if (message.name != null && Object.hasOwnProperty.call(message, "name"))
|
|
writer.uint32(/* id 1, wireType 2 =*/10).string(message.name);
|
|
if (message.type != null && Object.hasOwnProperty.call(message, "type"))
|
|
$root.onnx.TypeProto.encode(message.type, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();
|
|
if (message.docString != null && Object.hasOwnProperty.call(message, "docString"))
|
|
writer.uint32(/* id 3, wireType 2 =*/26).string(message.docString);
|
|
return writer;
|
|
};
|
|
|
|
/**
|
|
* Encodes the specified ValueInfoProto message, length delimited. Does not implicitly {@link onnx.ValueInfoProto.verify|verify} messages.
|
|
* @function encodeDelimited
|
|
* @memberof onnx.ValueInfoProto
|
|
* @static
|
|
* @param {onnx.IValueInfoProto} message ValueInfoProto message or plain object to encode
|
|
* @param {$protobuf.Writer} [writer] Writer to encode to
|
|
* @returns {$protobuf.Writer} Writer
|
|
*/
|
|
ValueInfoProto.encodeDelimited = function encodeDelimited(message, writer) {
|
|
return this.encode(message, writer).ldelim();
|
|
};
|
|
|
|
/**
|
|
* Decodes a ValueInfoProto message from the specified reader or buffer.
|
|
* @function decode
|
|
* @memberof onnx.ValueInfoProto
|
|
* @static
|
|
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
|
|
* @param {number} [length] Message length if known beforehand
|
|
* @returns {onnx.ValueInfoProto} ValueInfoProto
|
|
* @throws {Error} If the payload is not a reader or valid buffer
|
|
* @throws {$protobuf.util.ProtocolError} If required fields are missing
|
|
*/
|
|
ValueInfoProto.decode = function decode(reader, length) {
|
|
if (!(reader instanceof $Reader))
|
|
reader = $Reader.create(reader);
|
|
var end = length === undefined ? reader.len : reader.pos + length, message = new $root.onnx.ValueInfoProto();
|
|
while (reader.pos < end) {
|
|
var tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1: {
|
|
message.name = reader.string();
|
|
break;
|
|
}
|
|
case 2: {
|
|
message.type = $root.onnx.TypeProto.decode(reader, reader.uint32());
|
|
break;
|
|
}
|
|
case 3: {
|
|
message.docString = reader.string();
|
|
break;
|
|
}
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
};
|
|
|
|
/**
|
|
* Decodes a ValueInfoProto message from the specified reader or buffer, length delimited.
|
|
* @function decodeDelimited
|
|
* @memberof onnx.ValueInfoProto
|
|
* @static
|
|
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
|
|
* @returns {onnx.ValueInfoProto} ValueInfoProto
|
|
* @throws {Error} If the payload is not a reader or valid buffer
|
|
* @throws {$protobuf.util.ProtocolError} If required fields are missing
|
|
*/
|
|
ValueInfoProto.decodeDelimited = function decodeDelimited(reader) {
|
|
if (!(reader instanceof $Reader))
|
|
reader = new $Reader(reader);
|
|
return this.decode(reader, reader.uint32());
|
|
};
|
|
|
|
/**
|
|
* Verifies a ValueInfoProto message.
|
|
* @function verify
|
|
* @memberof onnx.ValueInfoProto
|
|
* @static
|
|
* @param {Object.<string,*>} message Plain object to verify
|
|
* @returns {string|null} `null` if valid, otherwise the reason why it is not
|
|
*/
|
|
ValueInfoProto.verify = function verify(message) {
|
|
if (typeof message !== "object" || message === null)
|
|
return "object expected";
|
|
if (message.name != null && message.hasOwnProperty("name"))
|
|
if (!$util.isString(message.name))
|
|
return "name: string expected";
|
|
if (message.type != null && message.hasOwnProperty("type")) {
|
|
var error = $root.onnx.TypeProto.verify(message.type);
|
|
if (error)
|
|
return "type." + error;
|
|
}
|
|
if (message.docString != null && message.hasOwnProperty("docString"))
|
|
if (!$util.isString(message.docString))
|
|
return "docString: string expected";
|
|
return null;
|
|
};
|
|
|
|
/**
|
|
* Creates a ValueInfoProto message from a plain object. Also converts values to their respective internal types.
|
|
* @function fromObject
|
|
* @memberof onnx.ValueInfoProto
|
|
* @static
|
|
* @param {Object.<string,*>} object Plain object
|
|
* @returns {onnx.ValueInfoProto} ValueInfoProto
|
|
*/
|
|
ValueInfoProto.fromObject = function fromObject(object) {
|
|
if (object instanceof $root.onnx.ValueInfoProto)
|
|
return object;
|
|
var message = new $root.onnx.ValueInfoProto();
|
|
if (object.name != null)
|
|
message.name = String(object.name);
|
|
if (object.type != null) {
|
|
if (typeof object.type !== "object")
|
|
throw TypeError(".onnx.ValueInfoProto.type: object expected");
|
|
message.type = $root.onnx.TypeProto.fromObject(object.type);
|
|
}
|
|
if (object.docString != null)
|
|
message.docString = String(object.docString);
|
|
return message;
|
|
};
|
|
|
|
/**
|
|
* Creates a plain object from a ValueInfoProto message. Also converts values to other types if specified.
|
|
* @function toObject
|
|
* @memberof onnx.ValueInfoProto
|
|
* @static
|
|
* @param {onnx.ValueInfoProto} message ValueInfoProto
|
|
* @param {$protobuf.IConversionOptions} [options] Conversion options
|
|
* @returns {Object.<string,*>} Plain object
|
|
*/
|
|
ValueInfoProto.toObject = function toObject(message, options) {
|
|
if (!options)
|
|
options = {};
|
|
var object = {};
|
|
if (options.defaults) {
|
|
object.name = "";
|
|
object.type = null;
|
|
object.docString = "";
|
|
}
|
|
if (message.name != null && message.hasOwnProperty("name"))
|
|
object.name = message.name;
|
|
if (message.type != null && message.hasOwnProperty("type"))
|
|
object.type = $root.onnx.TypeProto.toObject(message.type, options);
|
|
if (message.docString != null && message.hasOwnProperty("docString"))
|
|
object.docString = message.docString;
|
|
return object;
|
|
};
|
|
|
|
/**
|
|
* Converts this ValueInfoProto to JSON.
|
|
* @function toJSON
|
|
* @memberof onnx.ValueInfoProto
|
|
* @instance
|
|
* @returns {Object.<string,*>} JSON object
|
|
*/
|
|
ValueInfoProto.prototype.toJSON = function toJSON() {
|
|
return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
|
|
};
|
|
|
|
/**
|
|
* Gets the default type url for ValueInfoProto
|
|
* @function getTypeUrl
|
|
* @memberof onnx.ValueInfoProto
|
|
* @static
|
|
* @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
|
|
* @returns {string} The default type url
|
|
*/
|
|
ValueInfoProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
|
|
if (typeUrlPrefix === undefined) {
|
|
typeUrlPrefix = "type.googleapis.com";
|
|
}
|
|
return typeUrlPrefix + "/onnx.ValueInfoProto";
|
|
};
|
|
|
|
return ValueInfoProto;
|
|
})();
|
|
|
|
onnx.NodeProto = (function() {
|
|
|
|
/**
|
|
* Properties of a NodeProto.
|
|
* @memberof onnx
|
|
* @interface INodeProto
|
|
* @property {Array.<string>|null} [input] NodeProto input
|
|
* @property {Array.<string>|null} [output] NodeProto output
|
|
* @property {string|null} [name] NodeProto name
|
|
* @property {string|null} [opType] NodeProto opType
|
|
* @property {string|null} [domain] NodeProto domain
|
|
* @property {Array.<onnx.IAttributeProto>|null} [attribute] NodeProto attribute
|
|
* @property {string|null} [docString] NodeProto docString
|
|
*/
|
|
|
|
/**
|
|
* Constructs a new NodeProto.
|
|
* @memberof onnx
|
|
* @classdesc Represents a NodeProto.
|
|
* @implements INodeProto
|
|
* @constructor
|
|
* @param {onnx.INodeProto=} [properties] Properties to set
|
|
*/
|
|
function NodeProto(properties) {
|
|
this.input = [];
|
|
this.output = [];
|
|
this.attribute = [];
|
|
if (properties)
|
|
for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
|
|
if (properties[keys[i]] != null)
|
|
this[keys[i]] = properties[keys[i]];
|
|
}
|
|
|
|
/**
|
|
* NodeProto input.
|
|
* @member {Array.<string>} input
|
|
* @memberof onnx.NodeProto
|
|
* @instance
|
|
*/
|
|
NodeProto.prototype.input = $util.emptyArray;
|
|
|
|
/**
|
|
* NodeProto output.
|
|
* @member {Array.<string>} output
|
|
* @memberof onnx.NodeProto
|
|
* @instance
|
|
*/
|
|
NodeProto.prototype.output = $util.emptyArray;
|
|
|
|
/**
|
|
* NodeProto name.
|
|
* @member {string} name
|
|
* @memberof onnx.NodeProto
|
|
* @instance
|
|
*/
|
|
NodeProto.prototype.name = "";
|
|
|
|
/**
|
|
* NodeProto opType.
|
|
* @member {string} opType
|
|
* @memberof onnx.NodeProto
|
|
* @instance
|
|
*/
|
|
NodeProto.prototype.opType = "";
|
|
|
|
/**
|
|
* NodeProto domain.
|
|
* @member {string} domain
|
|
* @memberof onnx.NodeProto
|
|
* @instance
|
|
*/
|
|
NodeProto.prototype.domain = "";
|
|
|
|
/**
|
|
* NodeProto attribute.
|
|
* @member {Array.<onnx.IAttributeProto>} attribute
|
|
* @memberof onnx.NodeProto
|
|
* @instance
|
|
*/
|
|
NodeProto.prototype.attribute = $util.emptyArray;
|
|
|
|
/**
|
|
* NodeProto docString.
|
|
* @member {string} docString
|
|
* @memberof onnx.NodeProto
|
|
* @instance
|
|
*/
|
|
NodeProto.prototype.docString = "";
|
|
|
|
/**
|
|
* Creates a new NodeProto instance using the specified properties.
|
|
* @function create
|
|
* @memberof onnx.NodeProto
|
|
* @static
|
|
* @param {onnx.INodeProto=} [properties] Properties to set
|
|
* @returns {onnx.NodeProto} NodeProto instance
|
|
*/
|
|
NodeProto.create = function create(properties) {
|
|
return new NodeProto(properties);
|
|
};
|
|
|
|
/**
|
|
* Encodes the specified NodeProto message. Does not implicitly {@link onnx.NodeProto.verify|verify} messages.
|
|
* @function encode
|
|
* @memberof onnx.NodeProto
|
|
* @static
|
|
* @param {onnx.INodeProto} message NodeProto message or plain object to encode
|
|
* @param {$protobuf.Writer} [writer] Writer to encode to
|
|
* @returns {$protobuf.Writer} Writer
|
|
*/
|
|
NodeProto.encode = function encode(message, writer) {
|
|
if (!writer)
|
|
writer = $Writer.create();
|
|
if (message.input != null && message.input.length)
|
|
for (var i = 0; i < message.input.length; ++i)
|
|
writer.uint32(/* id 1, wireType 2 =*/10).string(message.input[i]);
|
|
if (message.output != null && message.output.length)
|
|
for (var i = 0; i < message.output.length; ++i)
|
|
writer.uint32(/* id 2, wireType 2 =*/18).string(message.output[i]);
|
|
if (message.name != null && Object.hasOwnProperty.call(message, "name"))
|
|
writer.uint32(/* id 3, wireType 2 =*/26).string(message.name);
|
|
if (message.opType != null && Object.hasOwnProperty.call(message, "opType"))
|
|
writer.uint32(/* id 4, wireType 2 =*/34).string(message.opType);
|
|
if (message.attribute != null && message.attribute.length)
|
|
for (var i = 0; i < message.attribute.length; ++i)
|
|
$root.onnx.AttributeProto.encode(message.attribute[i], writer.uint32(/* id 5, wireType 2 =*/42).fork()).ldelim();
|
|
if (message.docString != null && Object.hasOwnProperty.call(message, "docString"))
|
|
writer.uint32(/* id 6, wireType 2 =*/50).string(message.docString);
|
|
if (message.domain != null && Object.hasOwnProperty.call(message, "domain"))
|
|
writer.uint32(/* id 7, wireType 2 =*/58).string(message.domain);
|
|
return writer;
|
|
};
|
|
|
|
/**
|
|
* Encodes the specified NodeProto message, length delimited. Does not implicitly {@link onnx.NodeProto.verify|verify} messages.
|
|
* @function encodeDelimited
|
|
* @memberof onnx.NodeProto
|
|
* @static
|
|
* @param {onnx.INodeProto} message NodeProto message or plain object to encode
|
|
* @param {$protobuf.Writer} [writer] Writer to encode to
|
|
* @returns {$protobuf.Writer} Writer
|
|
*/
|
|
NodeProto.encodeDelimited = function encodeDelimited(message, writer) {
|
|
return this.encode(message, writer).ldelim();
|
|
};
|
|
|
|
/**
|
|
* Decodes a NodeProto message from the specified reader or buffer.
|
|
* @function decode
|
|
* @memberof onnx.NodeProto
|
|
* @static
|
|
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
|
|
* @param {number} [length] Message length if known beforehand
|
|
* @returns {onnx.NodeProto} NodeProto
|
|
* @throws {Error} If the payload is not a reader or valid buffer
|
|
* @throws {$protobuf.util.ProtocolError} If required fields are missing
|
|
*/
|
|
NodeProto.decode = function decode(reader, length) {
|
|
if (!(reader instanceof $Reader))
|
|
reader = $Reader.create(reader);
|
|
var end = length === undefined ? reader.len : reader.pos + length, message = new $root.onnx.NodeProto();
|
|
while (reader.pos < end) {
|
|
var tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1: {
|
|
if (!(message.input && message.input.length))
|
|
message.input = [];
|
|
message.input.push(reader.string());
|
|
break;
|
|
}
|
|
case 2: {
|
|
if (!(message.output && message.output.length))
|
|
message.output = [];
|
|
message.output.push(reader.string());
|
|
break;
|
|
}
|
|
case 3: {
|
|
message.name = reader.string();
|
|
break;
|
|
}
|
|
case 4: {
|
|
message.opType = reader.string();
|
|
break;
|
|
}
|
|
case 7: {
|
|
message.domain = reader.string();
|
|
break;
|
|
}
|
|
case 5: {
|
|
if (!(message.attribute && message.attribute.length))
|
|
message.attribute = [];
|
|
message.attribute.push($root.onnx.AttributeProto.decode(reader, reader.uint32()));
|
|
break;
|
|
}
|
|
case 6: {
|
|
message.docString = reader.string();
|
|
break;
|
|
}
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
};
|
|
|
|
/**
|
|
* Decodes a NodeProto message from the specified reader or buffer, length delimited.
|
|
* @function decodeDelimited
|
|
* @memberof onnx.NodeProto
|
|
* @static
|
|
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
|
|
* @returns {onnx.NodeProto} NodeProto
|
|
* @throws {Error} If the payload is not a reader or valid buffer
|
|
* @throws {$protobuf.util.ProtocolError} If required fields are missing
|
|
*/
|
|
NodeProto.decodeDelimited = function decodeDelimited(reader) {
|
|
if (!(reader instanceof $Reader))
|
|
reader = new $Reader(reader);
|
|
return this.decode(reader, reader.uint32());
|
|
};
|
|
|
|
/**
|
|
* Verifies a NodeProto message.
|
|
* @function verify
|
|
* @memberof onnx.NodeProto
|
|
* @static
|
|
* @param {Object.<string,*>} message Plain object to verify
|
|
* @returns {string|null} `null` if valid, otherwise the reason why it is not
|
|
*/
|
|
NodeProto.verify = function verify(message) {
|
|
if (typeof message !== "object" || message === null)
|
|
return "object expected";
|
|
if (message.input != null && message.hasOwnProperty("input")) {
|
|
if (!Array.isArray(message.input))
|
|
return "input: array expected";
|
|
for (var i = 0; i < message.input.length; ++i)
|
|
if (!$util.isString(message.input[i]))
|
|
return "input: string[] expected";
|
|
}
|
|
if (message.output != null && message.hasOwnProperty("output")) {
|
|
if (!Array.isArray(message.output))
|
|
return "output: array expected";
|
|
for (var i = 0; i < message.output.length; ++i)
|
|
if (!$util.isString(message.output[i]))
|
|
return "output: string[] expected";
|
|
}
|
|
if (message.name != null && message.hasOwnProperty("name"))
|
|
if (!$util.isString(message.name))
|
|
return "name: string expected";
|
|
if (message.opType != null && message.hasOwnProperty("opType"))
|
|
if (!$util.isString(message.opType))
|
|
return "opType: string expected";
|
|
if (message.domain != null && message.hasOwnProperty("domain"))
|
|
if (!$util.isString(message.domain))
|
|
return "domain: string expected";
|
|
if (message.attribute != null && message.hasOwnProperty("attribute")) {
|
|
if (!Array.isArray(message.attribute))
|
|
return "attribute: array expected";
|
|
for (var i = 0; i < message.attribute.length; ++i) {
|
|
var error = $root.onnx.AttributeProto.verify(message.attribute[i]);
|
|
if (error)
|
|
return "attribute." + error;
|
|
}
|
|
}
|
|
if (message.docString != null && message.hasOwnProperty("docString"))
|
|
if (!$util.isString(message.docString))
|
|
return "docString: string expected";
|
|
return null;
|
|
};
|
|
|
|
/**
|
|
* Creates a NodeProto message from a plain object. Also converts values to their respective internal types.
|
|
* @function fromObject
|
|
* @memberof onnx.NodeProto
|
|
* @static
|
|
* @param {Object.<string,*>} object Plain object
|
|
* @returns {onnx.NodeProto} NodeProto
|
|
*/
|
|
NodeProto.fromObject = function fromObject(object) {
|
|
if (object instanceof $root.onnx.NodeProto)
|
|
return object;
|
|
var message = new $root.onnx.NodeProto();
|
|
if (object.input) {
|
|
if (!Array.isArray(object.input))
|
|
throw TypeError(".onnx.NodeProto.input: array expected");
|
|
message.input = [];
|
|
for (var i = 0; i < object.input.length; ++i)
|
|
message.input[i] = String(object.input[i]);
|
|
}
|
|
if (object.output) {
|
|
if (!Array.isArray(object.output))
|
|
throw TypeError(".onnx.NodeProto.output: array expected");
|
|
message.output = [];
|
|
for (var i = 0; i < object.output.length; ++i)
|
|
message.output[i] = String(object.output[i]);
|
|
}
|
|
if (object.name != null)
|
|
message.name = String(object.name);
|
|
if (object.opType != null)
|
|
message.opType = String(object.opType);
|
|
if (object.domain != null)
|
|
message.domain = String(object.domain);
|
|
if (object.attribute) {
|
|
if (!Array.isArray(object.attribute))
|
|
throw TypeError(".onnx.NodeProto.attribute: array expected");
|
|
message.attribute = [];
|
|
for (var i = 0; i < object.attribute.length; ++i) {
|
|
if (typeof object.attribute[i] !== "object")
|
|
throw TypeError(".onnx.NodeProto.attribute: object expected");
|
|
message.attribute[i] = $root.onnx.AttributeProto.fromObject(object.attribute[i]);
|
|
}
|
|
}
|
|
if (object.docString != null)
|
|
message.docString = String(object.docString);
|
|
return message;
|
|
};
|
|
|
|
/**
|
|
* Creates a plain object from a NodeProto message. Also converts values to other types if specified.
|
|
* @function toObject
|
|
* @memberof onnx.NodeProto
|
|
* @static
|
|
* @param {onnx.NodeProto} message NodeProto
|
|
* @param {$protobuf.IConversionOptions} [options] Conversion options
|
|
* @returns {Object.<string,*>} Plain object
|
|
*/
|
|
NodeProto.toObject = function toObject(message, options) {
|
|
if (!options)
|
|
options = {};
|
|
var object = {};
|
|
if (options.arrays || options.defaults) {
|
|
object.input = [];
|
|
object.output = [];
|
|
object.attribute = [];
|
|
}
|
|
if (options.defaults) {
|
|
object.name = "";
|
|
object.opType = "";
|
|
object.docString = "";
|
|
object.domain = "";
|
|
}
|
|
if (message.input && message.input.length) {
|
|
object.input = [];
|
|
for (var j = 0; j < message.input.length; ++j)
|
|
object.input[j] = message.input[j];
|
|
}
|
|
if (message.output && message.output.length) {
|
|
object.output = [];
|
|
for (var j = 0; j < message.output.length; ++j)
|
|
object.output[j] = message.output[j];
|
|
}
|
|
if (message.name != null && message.hasOwnProperty("name"))
|
|
object.name = message.name;
|
|
if (message.opType != null && message.hasOwnProperty("opType"))
|
|
object.opType = message.opType;
|
|
if (message.attribute && message.attribute.length) {
|
|
object.attribute = [];
|
|
for (var j = 0; j < message.attribute.length; ++j)
|
|
object.attribute[j] = $root.onnx.AttributeProto.toObject(message.attribute[j], options);
|
|
}
|
|
if (message.docString != null && message.hasOwnProperty("docString"))
|
|
object.docString = message.docString;
|
|
if (message.domain != null && message.hasOwnProperty("domain"))
|
|
object.domain = message.domain;
|
|
return object;
|
|
};
|
|
|
|
/**
|
|
* Converts this NodeProto to JSON.
|
|
* @function toJSON
|
|
* @memberof onnx.NodeProto
|
|
* @instance
|
|
* @returns {Object.<string,*>} JSON object
|
|
*/
|
|
NodeProto.prototype.toJSON = function toJSON() {
|
|
return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
|
|
};
|
|
|
|
/**
|
|
* Gets the default type url for NodeProto
|
|
* @function getTypeUrl
|
|
* @memberof onnx.NodeProto
|
|
* @static
|
|
* @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
|
|
* @returns {string} The default type url
|
|
*/
|
|
NodeProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
|
|
if (typeUrlPrefix === undefined) {
|
|
typeUrlPrefix = "type.googleapis.com";
|
|
}
|
|
return typeUrlPrefix + "/onnx.NodeProto";
|
|
};
|
|
|
|
return NodeProto;
|
|
})();
|
|
|
|
onnx.TrainingInfoProto = (function() {
|
|
|
|
/**
|
|
* Properties of a TrainingInfoProto.
|
|
* @memberof onnx
|
|
* @interface ITrainingInfoProto
|
|
* @property {onnx.IGraphProto|null} [initialization] TrainingInfoProto initialization
|
|
* @property {onnx.IGraphProto|null} [algorithm] TrainingInfoProto algorithm
|
|
* @property {Array.<onnx.IStringStringEntryProto>|null} [initializationBinding] TrainingInfoProto initializationBinding
|
|
* @property {Array.<onnx.IStringStringEntryProto>|null} [updateBinding] TrainingInfoProto updateBinding
|
|
*/
|
|
|
|
/**
|
|
* Constructs a new TrainingInfoProto.
|
|
* @memberof onnx
|
|
* @classdesc Represents a TrainingInfoProto.
|
|
* @implements ITrainingInfoProto
|
|
* @constructor
|
|
* @param {onnx.ITrainingInfoProto=} [properties] Properties to set
|
|
*/
|
|
function TrainingInfoProto(properties) {
|
|
this.initializationBinding = [];
|
|
this.updateBinding = [];
|
|
if (properties)
|
|
for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
|
|
if (properties[keys[i]] != null)
|
|
this[keys[i]] = properties[keys[i]];
|
|
}
|
|
|
|
/**
|
|
* TrainingInfoProto initialization.
|
|
* @member {onnx.IGraphProto|null|undefined} initialization
|
|
* @memberof onnx.TrainingInfoProto
|
|
* @instance
|
|
*/
|
|
TrainingInfoProto.prototype.initialization = null;
|
|
|
|
/**
|
|
* TrainingInfoProto algorithm.
|
|
* @member {onnx.IGraphProto|null|undefined} algorithm
|
|
* @memberof onnx.TrainingInfoProto
|
|
* @instance
|
|
*/
|
|
TrainingInfoProto.prototype.algorithm = null;
|
|
|
|
/**
|
|
* TrainingInfoProto initializationBinding.
|
|
* @member {Array.<onnx.IStringStringEntryProto>} initializationBinding
|
|
* @memberof onnx.TrainingInfoProto
|
|
* @instance
|
|
*/
|
|
TrainingInfoProto.prototype.initializationBinding = $util.emptyArray;
|
|
|
|
/**
|
|
* TrainingInfoProto updateBinding.
|
|
* @member {Array.<onnx.IStringStringEntryProto>} updateBinding
|
|
* @memberof onnx.TrainingInfoProto
|
|
* @instance
|
|
*/
|
|
TrainingInfoProto.prototype.updateBinding = $util.emptyArray;
|
|
|
|
/**
|
|
* Creates a new TrainingInfoProto instance using the specified properties.
|
|
* @function create
|
|
* @memberof onnx.TrainingInfoProto
|
|
* @static
|
|
* @param {onnx.ITrainingInfoProto=} [properties] Properties to set
|
|
* @returns {onnx.TrainingInfoProto} TrainingInfoProto instance
|
|
*/
|
|
TrainingInfoProto.create = function create(properties) {
|
|
return new TrainingInfoProto(properties);
|
|
};
|
|
|
|
/**
|
|
* Encodes the specified TrainingInfoProto message. Does not implicitly {@link onnx.TrainingInfoProto.verify|verify} messages.
|
|
* @function encode
|
|
* @memberof onnx.TrainingInfoProto
|
|
* @static
|
|
* @param {onnx.ITrainingInfoProto} message TrainingInfoProto message or plain object to encode
|
|
* @param {$protobuf.Writer} [writer] Writer to encode to
|
|
* @returns {$protobuf.Writer} Writer
|
|
*/
|
|
TrainingInfoProto.encode = function encode(message, writer) {
|
|
if (!writer)
|
|
writer = $Writer.create();
|
|
if (message.initialization != null && Object.hasOwnProperty.call(message, "initialization"))
|
|
$root.onnx.GraphProto.encode(message.initialization, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
|
|
if (message.algorithm != null && Object.hasOwnProperty.call(message, "algorithm"))
|
|
$root.onnx.GraphProto.encode(message.algorithm, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();
|
|
if (message.initializationBinding != null && message.initializationBinding.length)
|
|
for (var i = 0; i < message.initializationBinding.length; ++i)
|
|
$root.onnx.StringStringEntryProto.encode(message.initializationBinding[i], writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim();
|
|
if (message.updateBinding != null && message.updateBinding.length)
|
|
for (var i = 0; i < message.updateBinding.length; ++i)
|
|
$root.onnx.StringStringEntryProto.encode(message.updateBinding[i], writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim();
|
|
return writer;
|
|
};
|
|
|
|
/**
|
|
* Encodes the specified TrainingInfoProto message, length delimited. Does not implicitly {@link onnx.TrainingInfoProto.verify|verify} messages.
|
|
* @function encodeDelimited
|
|
* @memberof onnx.TrainingInfoProto
|
|
* @static
|
|
* @param {onnx.ITrainingInfoProto} message TrainingInfoProto message or plain object to encode
|
|
* @param {$protobuf.Writer} [writer] Writer to encode to
|
|
* @returns {$protobuf.Writer} Writer
|
|
*/
|
|
TrainingInfoProto.encodeDelimited = function encodeDelimited(message, writer) {
|
|
return this.encode(message, writer).ldelim();
|
|
};
|
|
|
|
/**
|
|
* Decodes a TrainingInfoProto message from the specified reader or buffer.
|
|
* @function decode
|
|
* @memberof onnx.TrainingInfoProto
|
|
* @static
|
|
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
|
|
* @param {number} [length] Message length if known beforehand
|
|
* @returns {onnx.TrainingInfoProto} TrainingInfoProto
|
|
* @throws {Error} If the payload is not a reader or valid buffer
|
|
* @throws {$protobuf.util.ProtocolError} If required fields are missing
|
|
*/
|
|
TrainingInfoProto.decode = function decode(reader, length) {
|
|
if (!(reader instanceof $Reader))
|
|
reader = $Reader.create(reader);
|
|
var end = length === undefined ? reader.len : reader.pos + length, message = new $root.onnx.TrainingInfoProto();
|
|
while (reader.pos < end) {
|
|
var tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1: {
|
|
message.initialization = $root.onnx.GraphProto.decode(reader, reader.uint32());
|
|
break;
|
|
}
|
|
case 2: {
|
|
message.algorithm = $root.onnx.GraphProto.decode(reader, reader.uint32());
|
|
break;
|
|
}
|
|
case 3: {
|
|
if (!(message.initializationBinding && message.initializationBinding.length))
|
|
message.initializationBinding = [];
|
|
message.initializationBinding.push($root.onnx.StringStringEntryProto.decode(reader, reader.uint32()));
|
|
break;
|
|
}
|
|
case 4: {
|
|
if (!(message.updateBinding && message.updateBinding.length))
|
|
message.updateBinding = [];
|
|
message.updateBinding.push($root.onnx.StringStringEntryProto.decode(reader, reader.uint32()));
|
|
break;
|
|
}
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
};
|
|
|
|
/**
|
|
* Decodes a TrainingInfoProto message from the specified reader or buffer, length delimited.
|
|
* @function decodeDelimited
|
|
* @memberof onnx.TrainingInfoProto
|
|
* @static
|
|
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
|
|
* @returns {onnx.TrainingInfoProto} TrainingInfoProto
|
|
* @throws {Error} If the payload is not a reader or valid buffer
|
|
* @throws {$protobuf.util.ProtocolError} If required fields are missing
|
|
*/
|
|
TrainingInfoProto.decodeDelimited = function decodeDelimited(reader) {
|
|
if (!(reader instanceof $Reader))
|
|
reader = new $Reader(reader);
|
|
return this.decode(reader, reader.uint32());
|
|
};
|
|
|
|
/**
|
|
* Verifies a TrainingInfoProto message.
|
|
* @function verify
|
|
* @memberof onnx.TrainingInfoProto
|
|
* @static
|
|
* @param {Object.<string,*>} message Plain object to verify
|
|
* @returns {string|null} `null` if valid, otherwise the reason why it is not
|
|
*/
|
|
TrainingInfoProto.verify = function verify(message) {
|
|
if (typeof message !== "object" || message === null)
|
|
return "object expected";
|
|
if (message.initialization != null && message.hasOwnProperty("initialization")) {
|
|
var error = $root.onnx.GraphProto.verify(message.initialization);
|
|
if (error)
|
|
return "initialization." + error;
|
|
}
|
|
if (message.algorithm != null && message.hasOwnProperty("algorithm")) {
|
|
var error = $root.onnx.GraphProto.verify(message.algorithm);
|
|
if (error)
|
|
return "algorithm." + error;
|
|
}
|
|
if (message.initializationBinding != null && message.hasOwnProperty("initializationBinding")) {
|
|
if (!Array.isArray(message.initializationBinding))
|
|
return "initializationBinding: array expected";
|
|
for (var i = 0; i < message.initializationBinding.length; ++i) {
|
|
var error = $root.onnx.StringStringEntryProto.verify(message.initializationBinding[i]);
|
|
if (error)
|
|
return "initializationBinding." + error;
|
|
}
|
|
}
|
|
if (message.updateBinding != null && message.hasOwnProperty("updateBinding")) {
|
|
if (!Array.isArray(message.updateBinding))
|
|
return "updateBinding: array expected";
|
|
for (var i = 0; i < message.updateBinding.length; ++i) {
|
|
var error = $root.onnx.StringStringEntryProto.verify(message.updateBinding[i]);
|
|
if (error)
|
|
return "updateBinding." + error;
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
|
|
/**
|
|
* Creates a TrainingInfoProto message from a plain object. Also converts values to their respective internal types.
|
|
* @function fromObject
|
|
* @memberof onnx.TrainingInfoProto
|
|
* @static
|
|
* @param {Object.<string,*>} object Plain object
|
|
* @returns {onnx.TrainingInfoProto} TrainingInfoProto
|
|
*/
|
|
TrainingInfoProto.fromObject = function fromObject(object) {
|
|
if (object instanceof $root.onnx.TrainingInfoProto)
|
|
return object;
|
|
var message = new $root.onnx.TrainingInfoProto();
|
|
if (object.initialization != null) {
|
|
if (typeof object.initialization !== "object")
|
|
throw TypeError(".onnx.TrainingInfoProto.initialization: object expected");
|
|
message.initialization = $root.onnx.GraphProto.fromObject(object.initialization);
|
|
}
|
|
if (object.algorithm != null) {
|
|
if (typeof object.algorithm !== "object")
|
|
throw TypeError(".onnx.TrainingInfoProto.algorithm: object expected");
|
|
message.algorithm = $root.onnx.GraphProto.fromObject(object.algorithm);
|
|
}
|
|
if (object.initializationBinding) {
|
|
if (!Array.isArray(object.initializationBinding))
|
|
throw TypeError(".onnx.TrainingInfoProto.initializationBinding: array expected");
|
|
message.initializationBinding = [];
|
|
for (var i = 0; i < object.initializationBinding.length; ++i) {
|
|
if (typeof object.initializationBinding[i] !== "object")
|
|
throw TypeError(".onnx.TrainingInfoProto.initializationBinding: object expected");
|
|
message.initializationBinding[i] = $root.onnx.StringStringEntryProto.fromObject(object.initializationBinding[i]);
|
|
}
|
|
}
|
|
if (object.updateBinding) {
|
|
if (!Array.isArray(object.updateBinding))
|
|
throw TypeError(".onnx.TrainingInfoProto.updateBinding: array expected");
|
|
message.updateBinding = [];
|
|
for (var i = 0; i < object.updateBinding.length; ++i) {
|
|
if (typeof object.updateBinding[i] !== "object")
|
|
throw TypeError(".onnx.TrainingInfoProto.updateBinding: object expected");
|
|
message.updateBinding[i] = $root.onnx.StringStringEntryProto.fromObject(object.updateBinding[i]);
|
|
}
|
|
}
|
|
return message;
|
|
};
|
|
|
|
/**
|
|
* Creates a plain object from a TrainingInfoProto message. Also converts values to other types if specified.
|
|
* @function toObject
|
|
* @memberof onnx.TrainingInfoProto
|
|
* @static
|
|
* @param {onnx.TrainingInfoProto} message TrainingInfoProto
|
|
* @param {$protobuf.IConversionOptions} [options] Conversion options
|
|
* @returns {Object.<string,*>} Plain object
|
|
*/
|
|
TrainingInfoProto.toObject = function toObject(message, options) {
|
|
if (!options)
|
|
options = {};
|
|
var object = {};
|
|
if (options.arrays || options.defaults) {
|
|
object.initializationBinding = [];
|
|
object.updateBinding = [];
|
|
}
|
|
if (options.defaults) {
|
|
object.initialization = null;
|
|
object.algorithm = null;
|
|
}
|
|
if (message.initialization != null && message.hasOwnProperty("initialization"))
|
|
object.initialization = $root.onnx.GraphProto.toObject(message.initialization, options);
|
|
if (message.algorithm != null && message.hasOwnProperty("algorithm"))
|
|
object.algorithm = $root.onnx.GraphProto.toObject(message.algorithm, options);
|
|
if (message.initializationBinding && message.initializationBinding.length) {
|
|
object.initializationBinding = [];
|
|
for (var j = 0; j < message.initializationBinding.length; ++j)
|
|
object.initializationBinding[j] = $root.onnx.StringStringEntryProto.toObject(message.initializationBinding[j], options);
|
|
}
|
|
if (message.updateBinding && message.updateBinding.length) {
|
|
object.updateBinding = [];
|
|
for (var j = 0; j < message.updateBinding.length; ++j)
|
|
object.updateBinding[j] = $root.onnx.StringStringEntryProto.toObject(message.updateBinding[j], options);
|
|
}
|
|
return object;
|
|
};
|
|
|
|
/**
|
|
* Converts this TrainingInfoProto to JSON.
|
|
* @function toJSON
|
|
* @memberof onnx.TrainingInfoProto
|
|
* @instance
|
|
* @returns {Object.<string,*>} JSON object
|
|
*/
|
|
TrainingInfoProto.prototype.toJSON = function toJSON() {
|
|
return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
|
|
};
|
|
|
|
/**
|
|
* Gets the default type url for TrainingInfoProto
|
|
* @function getTypeUrl
|
|
* @memberof onnx.TrainingInfoProto
|
|
* @static
|
|
* @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
|
|
* @returns {string} The default type url
|
|
*/
|
|
TrainingInfoProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
|
|
if (typeUrlPrefix === undefined) {
|
|
typeUrlPrefix = "type.googleapis.com";
|
|
}
|
|
return typeUrlPrefix + "/onnx.TrainingInfoProto";
|
|
};
|
|
|
|
return TrainingInfoProto;
|
|
})();
|
|
|
|
onnx.ModelProto = (function() {
|
|
|
|
/**
|
|
* Properties of a ModelProto.
|
|
* @memberof onnx
|
|
* @interface IModelProto
|
|
* @property {number|Long|null} [irVersion] ModelProto irVersion
|
|
* @property {Array.<onnx.IOperatorSetIdProto>|null} [opsetImport] ModelProto opsetImport
|
|
* @property {string|null} [producerName] ModelProto producerName
|
|
* @property {string|null} [producerVersion] ModelProto producerVersion
|
|
* @property {string|null} [domain] ModelProto domain
|
|
* @property {number|Long|null} [modelVersion] ModelProto modelVersion
|
|
* @property {string|null} [docString] ModelProto docString
|
|
* @property {onnx.IGraphProto|null} [graph] ModelProto graph
|
|
* @property {Array.<onnx.IStringStringEntryProto>|null} [metadataProps] ModelProto metadataProps
|
|
* @property {Array.<onnx.ITrainingInfoProto>|null} [trainingInfo] ModelProto trainingInfo
|
|
* @property {Array.<onnx.IFunctionProto>|null} [functions] ModelProto functions
|
|
*/
|
|
|
|
/**
|
|
* Constructs a new ModelProto.
|
|
* @memberof onnx
|
|
* @classdesc Represents a ModelProto.
|
|
* @implements IModelProto
|
|
* @constructor
|
|
* @param {onnx.IModelProto=} [properties] Properties to set
|
|
*/
|
|
function ModelProto(properties) {
|
|
this.opsetImport = [];
|
|
this.metadataProps = [];
|
|
this.trainingInfo = [];
|
|
this.functions = [];
|
|
if (properties)
|
|
for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
|
|
if (properties[keys[i]] != null)
|
|
this[keys[i]] = properties[keys[i]];
|
|
}
|
|
|
|
/**
|
|
* ModelProto irVersion.
|
|
* @member {number|Long} irVersion
|
|
* @memberof onnx.ModelProto
|
|
* @instance
|
|
*/
|
|
ModelProto.prototype.irVersion = $util.Long ? $util.Long.fromBits(0,0,false) : 0;
|
|
|
|
/**
|
|
* ModelProto opsetImport.
|
|
* @member {Array.<onnx.IOperatorSetIdProto>} opsetImport
|
|
* @memberof onnx.ModelProto
|
|
* @instance
|
|
*/
|
|
ModelProto.prototype.opsetImport = $util.emptyArray;
|
|
|
|
/**
|
|
* ModelProto producerName.
|
|
* @member {string} producerName
|
|
* @memberof onnx.ModelProto
|
|
* @instance
|
|
*/
|
|
ModelProto.prototype.producerName = "";
|
|
|
|
/**
|
|
* ModelProto producerVersion.
|
|
* @member {string} producerVersion
|
|
* @memberof onnx.ModelProto
|
|
* @instance
|
|
*/
|
|
ModelProto.prototype.producerVersion = "";
|
|
|
|
/**
|
|
* ModelProto domain.
|
|
* @member {string} domain
|
|
* @memberof onnx.ModelProto
|
|
* @instance
|
|
*/
|
|
ModelProto.prototype.domain = "";
|
|
|
|
/**
|
|
* ModelProto modelVersion.
|
|
* @member {number|Long} modelVersion
|
|
* @memberof onnx.ModelProto
|
|
* @instance
|
|
*/
|
|
ModelProto.prototype.modelVersion = $util.Long ? $util.Long.fromBits(0,0,false) : 0;
|
|
|
|
/**
|
|
* ModelProto docString.
|
|
* @member {string} docString
|
|
* @memberof onnx.ModelProto
|
|
* @instance
|
|
*/
|
|
ModelProto.prototype.docString = "";
|
|
|
|
/**
|
|
* ModelProto graph.
|
|
* @member {onnx.IGraphProto|null|undefined} graph
|
|
* @memberof onnx.ModelProto
|
|
* @instance
|
|
*/
|
|
ModelProto.prototype.graph = null;
|
|
|
|
/**
|
|
* ModelProto metadataProps.
|
|
* @member {Array.<onnx.IStringStringEntryProto>} metadataProps
|
|
* @memberof onnx.ModelProto
|
|
* @instance
|
|
*/
|
|
ModelProto.prototype.metadataProps = $util.emptyArray;
|
|
|
|
/**
|
|
* ModelProto trainingInfo.
|
|
* @member {Array.<onnx.ITrainingInfoProto>} trainingInfo
|
|
* @memberof onnx.ModelProto
|
|
* @instance
|
|
*/
|
|
ModelProto.prototype.trainingInfo = $util.emptyArray;
|
|
|
|
/**
|
|
* ModelProto functions.
|
|
* @member {Array.<onnx.IFunctionProto>} functions
|
|
* @memberof onnx.ModelProto
|
|
* @instance
|
|
*/
|
|
ModelProto.prototype.functions = $util.emptyArray;
|
|
|
|
/**
|
|
* Creates a new ModelProto instance using the specified properties.
|
|
* @function create
|
|
* @memberof onnx.ModelProto
|
|
* @static
|
|
* @param {onnx.IModelProto=} [properties] Properties to set
|
|
* @returns {onnx.ModelProto} ModelProto instance
|
|
*/
|
|
ModelProto.create = function create(properties) {
|
|
return new ModelProto(properties);
|
|
};
|
|
|
|
/**
|
|
* Encodes the specified ModelProto message. Does not implicitly {@link onnx.ModelProto.verify|verify} messages.
|
|
* @function encode
|
|
* @memberof onnx.ModelProto
|
|
* @static
|
|
* @param {onnx.IModelProto} message ModelProto message or plain object to encode
|
|
* @param {$protobuf.Writer} [writer] Writer to encode to
|
|
* @returns {$protobuf.Writer} Writer
|
|
*/
|
|
ModelProto.encode = function encode(message, writer) {
|
|
if (!writer)
|
|
writer = $Writer.create();
|
|
if (message.irVersion != null && Object.hasOwnProperty.call(message, "irVersion"))
|
|
writer.uint32(/* id 1, wireType 0 =*/8).int64(message.irVersion);
|
|
if (message.producerName != null && Object.hasOwnProperty.call(message, "producerName"))
|
|
writer.uint32(/* id 2, wireType 2 =*/18).string(message.producerName);
|
|
if (message.producerVersion != null && Object.hasOwnProperty.call(message, "producerVersion"))
|
|
writer.uint32(/* id 3, wireType 2 =*/26).string(message.producerVersion);
|
|
if (message.domain != null && Object.hasOwnProperty.call(message, "domain"))
|
|
writer.uint32(/* id 4, wireType 2 =*/34).string(message.domain);
|
|
if (message.modelVersion != null && Object.hasOwnProperty.call(message, "modelVersion"))
|
|
writer.uint32(/* id 5, wireType 0 =*/40).int64(message.modelVersion);
|
|
if (message.docString != null && Object.hasOwnProperty.call(message, "docString"))
|
|
writer.uint32(/* id 6, wireType 2 =*/50).string(message.docString);
|
|
if (message.graph != null && Object.hasOwnProperty.call(message, "graph"))
|
|
$root.onnx.GraphProto.encode(message.graph, writer.uint32(/* id 7, wireType 2 =*/58).fork()).ldelim();
|
|
if (message.opsetImport != null && message.opsetImport.length)
|
|
for (var i = 0; i < message.opsetImport.length; ++i)
|
|
$root.onnx.OperatorSetIdProto.encode(message.opsetImport[i], writer.uint32(/* id 8, wireType 2 =*/66).fork()).ldelim();
|
|
if (message.metadataProps != null && message.metadataProps.length)
|
|
for (var i = 0; i < message.metadataProps.length; ++i)
|
|
$root.onnx.StringStringEntryProto.encode(message.metadataProps[i], writer.uint32(/* id 14, wireType 2 =*/114).fork()).ldelim();
|
|
if (message.trainingInfo != null && message.trainingInfo.length)
|
|
for (var i = 0; i < message.trainingInfo.length; ++i)
|
|
$root.onnx.TrainingInfoProto.encode(message.trainingInfo[i], writer.uint32(/* id 20, wireType 2 =*/162).fork()).ldelim();
|
|
if (message.functions != null && message.functions.length)
|
|
for (var i = 0; i < message.functions.length; ++i)
|
|
$root.onnx.FunctionProto.encode(message.functions[i], writer.uint32(/* id 25, wireType 2 =*/202).fork()).ldelim();
|
|
return writer;
|
|
};
|
|
|
|
/**
|
|
* Encodes the specified ModelProto message, length delimited. Does not implicitly {@link onnx.ModelProto.verify|verify} messages.
|
|
* @function encodeDelimited
|
|
* @memberof onnx.ModelProto
|
|
* @static
|
|
* @param {onnx.IModelProto} message ModelProto message or plain object to encode
|
|
* @param {$protobuf.Writer} [writer] Writer to encode to
|
|
* @returns {$protobuf.Writer} Writer
|
|
*/
|
|
ModelProto.encodeDelimited = function encodeDelimited(message, writer) {
|
|
return this.encode(message, writer).ldelim();
|
|
};
|
|
|
|
/**
|
|
* Decodes a ModelProto message from the specified reader or buffer.
|
|
* @function decode
|
|
* @memberof onnx.ModelProto
|
|
* @static
|
|
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
|
|
* @param {number} [length] Message length if known beforehand
|
|
* @returns {onnx.ModelProto} ModelProto
|
|
* @throws {Error} If the payload is not a reader or valid buffer
|
|
* @throws {$protobuf.util.ProtocolError} If required fields are missing
|
|
*/
|
|
ModelProto.decode = function decode(reader, length) {
|
|
if (!(reader instanceof $Reader))
|
|
reader = $Reader.create(reader);
|
|
var end = length === undefined ? reader.len : reader.pos + length, message = new $root.onnx.ModelProto();
|
|
while (reader.pos < end) {
|
|
var tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1: {
|
|
message.irVersion = reader.int64();
|
|
break;
|
|
}
|
|
case 8: {
|
|
if (!(message.opsetImport && message.opsetImport.length))
|
|
message.opsetImport = [];
|
|
message.opsetImport.push($root.onnx.OperatorSetIdProto.decode(reader, reader.uint32()));
|
|
break;
|
|
}
|
|
case 2: {
|
|
message.producerName = reader.string();
|
|
break;
|
|
}
|
|
case 3: {
|
|
message.producerVersion = reader.string();
|
|
break;
|
|
}
|
|
case 4: {
|
|
message.domain = reader.string();
|
|
break;
|
|
}
|
|
case 5: {
|
|
message.modelVersion = reader.int64();
|
|
break;
|
|
}
|
|
case 6: {
|
|
message.docString = reader.string();
|
|
break;
|
|
}
|
|
case 7: {
|
|
message.graph = $root.onnx.GraphProto.decode(reader, reader.uint32());
|
|
break;
|
|
}
|
|
case 14: {
|
|
if (!(message.metadataProps && message.metadataProps.length))
|
|
message.metadataProps = [];
|
|
message.metadataProps.push($root.onnx.StringStringEntryProto.decode(reader, reader.uint32()));
|
|
break;
|
|
}
|
|
case 20: {
|
|
if (!(message.trainingInfo && message.trainingInfo.length))
|
|
message.trainingInfo = [];
|
|
message.trainingInfo.push($root.onnx.TrainingInfoProto.decode(reader, reader.uint32()));
|
|
break;
|
|
}
|
|
case 25: {
|
|
if (!(message.functions && message.functions.length))
|
|
message.functions = [];
|
|
message.functions.push($root.onnx.FunctionProto.decode(reader, reader.uint32()));
|
|
break;
|
|
}
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
};
|
|
|
|
/**
|
|
* Decodes a ModelProto message from the specified reader or buffer, length delimited.
|
|
* @function decodeDelimited
|
|
* @memberof onnx.ModelProto
|
|
* @static
|
|
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
|
|
* @returns {onnx.ModelProto} ModelProto
|
|
* @throws {Error} If the payload is not a reader or valid buffer
|
|
* @throws {$protobuf.util.ProtocolError} If required fields are missing
|
|
*/
|
|
ModelProto.decodeDelimited = function decodeDelimited(reader) {
|
|
if (!(reader instanceof $Reader))
|
|
reader = new $Reader(reader);
|
|
return this.decode(reader, reader.uint32());
|
|
};
|
|
|
|
/**
|
|
* Verifies a ModelProto message.
|
|
* @function verify
|
|
* @memberof onnx.ModelProto
|
|
* @static
|
|
* @param {Object.<string,*>} message Plain object to verify
|
|
* @returns {string|null} `null` if valid, otherwise the reason why it is not
|
|
*/
|
|
ModelProto.verify = function verify(message) {
|
|
if (typeof message !== "object" || message === null)
|
|
return "object expected";
|
|
if (message.irVersion != null && message.hasOwnProperty("irVersion"))
|
|
if (!$util.isInteger(message.irVersion) && !(message.irVersion && $util.isInteger(message.irVersion.low) && $util.isInteger(message.irVersion.high)))
|
|
return "irVersion: integer|Long expected";
|
|
if (message.opsetImport != null && message.hasOwnProperty("opsetImport")) {
|
|
if (!Array.isArray(message.opsetImport))
|
|
return "opsetImport: array expected";
|
|
for (var i = 0; i < message.opsetImport.length; ++i) {
|
|
var error = $root.onnx.OperatorSetIdProto.verify(message.opsetImport[i]);
|
|
if (error)
|
|
return "opsetImport." + error;
|
|
}
|
|
}
|
|
if (message.producerName != null && message.hasOwnProperty("producerName"))
|
|
if (!$util.isString(message.producerName))
|
|
return "producerName: string expected";
|
|
if (message.producerVersion != null && message.hasOwnProperty("producerVersion"))
|
|
if (!$util.isString(message.producerVersion))
|
|
return "producerVersion: string expected";
|
|
if (message.domain != null && message.hasOwnProperty("domain"))
|
|
if (!$util.isString(message.domain))
|
|
return "domain: string expected";
|
|
if (message.modelVersion != null && message.hasOwnProperty("modelVersion"))
|
|
if (!$util.isInteger(message.modelVersion) && !(message.modelVersion && $util.isInteger(message.modelVersion.low) && $util.isInteger(message.modelVersion.high)))
|
|
return "modelVersion: integer|Long expected";
|
|
if (message.docString != null && message.hasOwnProperty("docString"))
|
|
if (!$util.isString(message.docString))
|
|
return "docString: string expected";
|
|
if (message.graph != null && message.hasOwnProperty("graph")) {
|
|
var error = $root.onnx.GraphProto.verify(message.graph);
|
|
if (error)
|
|
return "graph." + error;
|
|
}
|
|
if (message.metadataProps != null && message.hasOwnProperty("metadataProps")) {
|
|
if (!Array.isArray(message.metadataProps))
|
|
return "metadataProps: array expected";
|
|
for (var i = 0; i < message.metadataProps.length; ++i) {
|
|
var error = $root.onnx.StringStringEntryProto.verify(message.metadataProps[i]);
|
|
if (error)
|
|
return "metadataProps." + error;
|
|
}
|
|
}
|
|
if (message.trainingInfo != null && message.hasOwnProperty("trainingInfo")) {
|
|
if (!Array.isArray(message.trainingInfo))
|
|
return "trainingInfo: array expected";
|
|
for (var i = 0; i < message.trainingInfo.length; ++i) {
|
|
var error = $root.onnx.TrainingInfoProto.verify(message.trainingInfo[i]);
|
|
if (error)
|
|
return "trainingInfo." + error;
|
|
}
|
|
}
|
|
if (message.functions != null && message.hasOwnProperty("functions")) {
|
|
if (!Array.isArray(message.functions))
|
|
return "functions: array expected";
|
|
for (var i = 0; i < message.functions.length; ++i) {
|
|
var error = $root.onnx.FunctionProto.verify(message.functions[i]);
|
|
if (error)
|
|
return "functions." + error;
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
|
|
/**
|
|
* Creates a ModelProto message from a plain object. Also converts values to their respective internal types.
|
|
* @function fromObject
|
|
* @memberof onnx.ModelProto
|
|
* @static
|
|
* @param {Object.<string,*>} object Plain object
|
|
* @returns {onnx.ModelProto} ModelProto
|
|
*/
|
|
ModelProto.fromObject = function fromObject(object) {
|
|
if (object instanceof $root.onnx.ModelProto)
|
|
return object;
|
|
var message = new $root.onnx.ModelProto();
|
|
if (object.irVersion != null)
|
|
if ($util.Long)
|
|
(message.irVersion = $util.Long.fromValue(object.irVersion)).unsigned = false;
|
|
else if (typeof object.irVersion === "string")
|
|
message.irVersion = parseInt(object.irVersion, 10);
|
|
else if (typeof object.irVersion === "number")
|
|
message.irVersion = object.irVersion;
|
|
else if (typeof object.irVersion === "object")
|
|
message.irVersion = new $util.LongBits(object.irVersion.low >>> 0, object.irVersion.high >>> 0).toNumber();
|
|
if (object.opsetImport) {
|
|
if (!Array.isArray(object.opsetImport))
|
|
throw TypeError(".onnx.ModelProto.opsetImport: array expected");
|
|
message.opsetImport = [];
|
|
for (var i = 0; i < object.opsetImport.length; ++i) {
|
|
if (typeof object.opsetImport[i] !== "object")
|
|
throw TypeError(".onnx.ModelProto.opsetImport: object expected");
|
|
message.opsetImport[i] = $root.onnx.OperatorSetIdProto.fromObject(object.opsetImport[i]);
|
|
}
|
|
}
|
|
if (object.producerName != null)
|
|
message.producerName = String(object.producerName);
|
|
if (object.producerVersion != null)
|
|
message.producerVersion = String(object.producerVersion);
|
|
if (object.domain != null)
|
|
message.domain = String(object.domain);
|
|
if (object.modelVersion != null)
|
|
if ($util.Long)
|
|
(message.modelVersion = $util.Long.fromValue(object.modelVersion)).unsigned = false;
|
|
else if (typeof object.modelVersion === "string")
|
|
message.modelVersion = parseInt(object.modelVersion, 10);
|
|
else if (typeof object.modelVersion === "number")
|
|
message.modelVersion = object.modelVersion;
|
|
else if (typeof object.modelVersion === "object")
|
|
message.modelVersion = new $util.LongBits(object.modelVersion.low >>> 0, object.modelVersion.high >>> 0).toNumber();
|
|
if (object.docString != null)
|
|
message.docString = String(object.docString);
|
|
if (object.graph != null) {
|
|
if (typeof object.graph !== "object")
|
|
throw TypeError(".onnx.ModelProto.graph: object expected");
|
|
message.graph = $root.onnx.GraphProto.fromObject(object.graph);
|
|
}
|
|
if (object.metadataProps) {
|
|
if (!Array.isArray(object.metadataProps))
|
|
throw TypeError(".onnx.ModelProto.metadataProps: array expected");
|
|
message.metadataProps = [];
|
|
for (var i = 0; i < object.metadataProps.length; ++i) {
|
|
if (typeof object.metadataProps[i] !== "object")
|
|
throw TypeError(".onnx.ModelProto.metadataProps: object expected");
|
|
message.metadataProps[i] = $root.onnx.StringStringEntryProto.fromObject(object.metadataProps[i]);
|
|
}
|
|
}
|
|
if (object.trainingInfo) {
|
|
if (!Array.isArray(object.trainingInfo))
|
|
throw TypeError(".onnx.ModelProto.trainingInfo: array expected");
|
|
message.trainingInfo = [];
|
|
for (var i = 0; i < object.trainingInfo.length; ++i) {
|
|
if (typeof object.trainingInfo[i] !== "object")
|
|
throw TypeError(".onnx.ModelProto.trainingInfo: object expected");
|
|
message.trainingInfo[i] = $root.onnx.TrainingInfoProto.fromObject(object.trainingInfo[i]);
|
|
}
|
|
}
|
|
if (object.functions) {
|
|
if (!Array.isArray(object.functions))
|
|
throw TypeError(".onnx.ModelProto.functions: array expected");
|
|
message.functions = [];
|
|
for (var i = 0; i < object.functions.length; ++i) {
|
|
if (typeof object.functions[i] !== "object")
|
|
throw TypeError(".onnx.ModelProto.functions: object expected");
|
|
message.functions[i] = $root.onnx.FunctionProto.fromObject(object.functions[i]);
|
|
}
|
|
}
|
|
return message;
|
|
};
|
|
|
|
/**
|
|
* Creates a plain object from a ModelProto message. Also converts values to other types if specified.
|
|
* @function toObject
|
|
* @memberof onnx.ModelProto
|
|
* @static
|
|
* @param {onnx.ModelProto} message ModelProto
|
|
* @param {$protobuf.IConversionOptions} [options] Conversion options
|
|
* @returns {Object.<string,*>} Plain object
|
|
*/
|
|
ModelProto.toObject = function toObject(message, options) {
|
|
if (!options)
|
|
options = {};
|
|
var object = {};
|
|
if (options.arrays || options.defaults) {
|
|
object.opsetImport = [];
|
|
object.metadataProps = [];
|
|
object.trainingInfo = [];
|
|
object.functions = [];
|
|
}
|
|
if (options.defaults) {
|
|
if ($util.Long) {
|
|
var long = new $util.Long(0, 0, false);
|
|
object.irVersion = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
|
|
} else
|
|
object.irVersion = options.longs === String ? "0" : 0;
|
|
object.producerName = "";
|
|
object.producerVersion = "";
|
|
object.domain = "";
|
|
if ($util.Long) {
|
|
var long = new $util.Long(0, 0, false);
|
|
object.modelVersion = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
|
|
} else
|
|
object.modelVersion = options.longs === String ? "0" : 0;
|
|
object.docString = "";
|
|
object.graph = null;
|
|
}
|
|
if (message.irVersion != null && message.hasOwnProperty("irVersion"))
|
|
if (typeof message.irVersion === "number")
|
|
object.irVersion = options.longs === String ? String(message.irVersion) : message.irVersion;
|
|
else
|
|
object.irVersion = options.longs === String ? $util.Long.prototype.toString.call(message.irVersion) : options.longs === Number ? new $util.LongBits(message.irVersion.low >>> 0, message.irVersion.high >>> 0).toNumber() : message.irVersion;
|
|
if (message.producerName != null && message.hasOwnProperty("producerName"))
|
|
object.producerName = message.producerName;
|
|
if (message.producerVersion != null && message.hasOwnProperty("producerVersion"))
|
|
object.producerVersion = message.producerVersion;
|
|
if (message.domain != null && message.hasOwnProperty("domain"))
|
|
object.domain = message.domain;
|
|
if (message.modelVersion != null && message.hasOwnProperty("modelVersion"))
|
|
if (typeof message.modelVersion === "number")
|
|
object.modelVersion = options.longs === String ? String(message.modelVersion) : message.modelVersion;
|
|
else
|
|
object.modelVersion = options.longs === String ? $util.Long.prototype.toString.call(message.modelVersion) : options.longs === Number ? new $util.LongBits(message.modelVersion.low >>> 0, message.modelVersion.high >>> 0).toNumber() : message.modelVersion;
|
|
if (message.docString != null && message.hasOwnProperty("docString"))
|
|
object.docString = message.docString;
|
|
if (message.graph != null && message.hasOwnProperty("graph"))
|
|
object.graph = $root.onnx.GraphProto.toObject(message.graph, options);
|
|
if (message.opsetImport && message.opsetImport.length) {
|
|
object.opsetImport = [];
|
|
for (var j = 0; j < message.opsetImport.length; ++j)
|
|
object.opsetImport[j] = $root.onnx.OperatorSetIdProto.toObject(message.opsetImport[j], options);
|
|
}
|
|
if (message.metadataProps && message.metadataProps.length) {
|
|
object.metadataProps = [];
|
|
for (var j = 0; j < message.metadataProps.length; ++j)
|
|
object.metadataProps[j] = $root.onnx.StringStringEntryProto.toObject(message.metadataProps[j], options);
|
|
}
|
|
if (message.trainingInfo && message.trainingInfo.length) {
|
|
object.trainingInfo = [];
|
|
for (var j = 0; j < message.trainingInfo.length; ++j)
|
|
object.trainingInfo[j] = $root.onnx.TrainingInfoProto.toObject(message.trainingInfo[j], options);
|
|
}
|
|
if (message.functions && message.functions.length) {
|
|
object.functions = [];
|
|
for (var j = 0; j < message.functions.length; ++j)
|
|
object.functions[j] = $root.onnx.FunctionProto.toObject(message.functions[j], options);
|
|
}
|
|
return object;
|
|
};
|
|
|
|
/**
|
|
* Converts this ModelProto to JSON.
|
|
* @function toJSON
|
|
* @memberof onnx.ModelProto
|
|
* @instance
|
|
* @returns {Object.<string,*>} JSON object
|
|
*/
|
|
ModelProto.prototype.toJSON = function toJSON() {
|
|
return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
|
|
};
|
|
|
|
/**
|
|
* Gets the default type url for ModelProto
|
|
* @function getTypeUrl
|
|
* @memberof onnx.ModelProto
|
|
* @static
|
|
* @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
|
|
* @returns {string} The default type url
|
|
*/
|
|
ModelProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
|
|
if (typeUrlPrefix === undefined) {
|
|
typeUrlPrefix = "type.googleapis.com";
|
|
}
|
|
return typeUrlPrefix + "/onnx.ModelProto";
|
|
};
|
|
|
|
return ModelProto;
|
|
})();
|
|
|
|
onnx.StringStringEntryProto = (function() {
|
|
|
|
/**
|
|
* Properties of a StringStringEntryProto.
|
|
* @memberof onnx
|
|
* @interface IStringStringEntryProto
|
|
* @property {string|null} [key] StringStringEntryProto key
|
|
* @property {string|null} [value] StringStringEntryProto value
|
|
*/
|
|
|
|
/**
|
|
* Constructs a new StringStringEntryProto.
|
|
* @memberof onnx
|
|
* @classdesc Represents a StringStringEntryProto.
|
|
* @implements IStringStringEntryProto
|
|
* @constructor
|
|
* @param {onnx.IStringStringEntryProto=} [properties] Properties to set
|
|
*/
|
|
function StringStringEntryProto(properties) {
|
|
if (properties)
|
|
for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
|
|
if (properties[keys[i]] != null)
|
|
this[keys[i]] = properties[keys[i]];
|
|
}
|
|
|
|
/**
|
|
* StringStringEntryProto key.
|
|
* @member {string} key
|
|
* @memberof onnx.StringStringEntryProto
|
|
* @instance
|
|
*/
|
|
StringStringEntryProto.prototype.key = "";
|
|
|
|
/**
|
|
* StringStringEntryProto value.
|
|
* @member {string} value
|
|
* @memberof onnx.StringStringEntryProto
|
|
* @instance
|
|
*/
|
|
StringStringEntryProto.prototype.value = "";
|
|
|
|
/**
|
|
* Creates a new StringStringEntryProto instance using the specified properties.
|
|
* @function create
|
|
* @memberof onnx.StringStringEntryProto
|
|
* @static
|
|
* @param {onnx.IStringStringEntryProto=} [properties] Properties to set
|
|
* @returns {onnx.StringStringEntryProto} StringStringEntryProto instance
|
|
*/
|
|
StringStringEntryProto.create = function create(properties) {
|
|
return new StringStringEntryProto(properties);
|
|
};
|
|
|
|
/**
|
|
* Encodes the specified StringStringEntryProto message. Does not implicitly {@link onnx.StringStringEntryProto.verify|verify} messages.
|
|
* @function encode
|
|
* @memberof onnx.StringStringEntryProto
|
|
* @static
|
|
* @param {onnx.IStringStringEntryProto} message StringStringEntryProto message or plain object to encode
|
|
* @param {$protobuf.Writer} [writer] Writer to encode to
|
|
* @returns {$protobuf.Writer} Writer
|
|
*/
|
|
StringStringEntryProto.encode = function encode(message, writer) {
|
|
if (!writer)
|
|
writer = $Writer.create();
|
|
if (message.key != null && Object.hasOwnProperty.call(message, "key"))
|
|
writer.uint32(/* id 1, wireType 2 =*/10).string(message.key);
|
|
if (message.value != null && Object.hasOwnProperty.call(message, "value"))
|
|
writer.uint32(/* id 2, wireType 2 =*/18).string(message.value);
|
|
return writer;
|
|
};
|
|
|
|
/**
|
|
* Encodes the specified StringStringEntryProto message, length delimited. Does not implicitly {@link onnx.StringStringEntryProto.verify|verify} messages.
|
|
* @function encodeDelimited
|
|
* @memberof onnx.StringStringEntryProto
|
|
* @static
|
|
* @param {onnx.IStringStringEntryProto} message StringStringEntryProto message or plain object to encode
|
|
* @param {$protobuf.Writer} [writer] Writer to encode to
|
|
* @returns {$protobuf.Writer} Writer
|
|
*/
|
|
StringStringEntryProto.encodeDelimited = function encodeDelimited(message, writer) {
|
|
return this.encode(message, writer).ldelim();
|
|
};
|
|
|
|
/**
|
|
* Decodes a StringStringEntryProto message from the specified reader or buffer.
|
|
* @function decode
|
|
* @memberof onnx.StringStringEntryProto
|
|
* @static
|
|
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
|
|
* @param {number} [length] Message length if known beforehand
|
|
* @returns {onnx.StringStringEntryProto} StringStringEntryProto
|
|
* @throws {Error} If the payload is not a reader or valid buffer
|
|
* @throws {$protobuf.util.ProtocolError} If required fields are missing
|
|
*/
|
|
StringStringEntryProto.decode = function decode(reader, length) {
|
|
if (!(reader instanceof $Reader))
|
|
reader = $Reader.create(reader);
|
|
var end = length === undefined ? reader.len : reader.pos + length, message = new $root.onnx.StringStringEntryProto();
|
|
while (reader.pos < end) {
|
|
var 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;
|
|
};
|
|
|
|
/**
|
|
* Decodes a StringStringEntryProto message from the specified reader or buffer, length delimited.
|
|
* @function decodeDelimited
|
|
* @memberof onnx.StringStringEntryProto
|
|
* @static
|
|
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
|
|
* @returns {onnx.StringStringEntryProto} StringStringEntryProto
|
|
* @throws {Error} If the payload is not a reader or valid buffer
|
|
* @throws {$protobuf.util.ProtocolError} If required fields are missing
|
|
*/
|
|
StringStringEntryProto.decodeDelimited = function decodeDelimited(reader) {
|
|
if (!(reader instanceof $Reader))
|
|
reader = new $Reader(reader);
|
|
return this.decode(reader, reader.uint32());
|
|
};
|
|
|
|
/**
|
|
* Verifies a StringStringEntryProto message.
|
|
* @function verify
|
|
* @memberof onnx.StringStringEntryProto
|
|
* @static
|
|
* @param {Object.<string,*>} message Plain object to verify
|
|
* @returns {string|null} `null` if valid, otherwise the reason why it is not
|
|
*/
|
|
StringStringEntryProto.verify = function verify(message) {
|
|
if (typeof message !== "object" || message === null)
|
|
return "object expected";
|
|
if (message.key != null && message.hasOwnProperty("key"))
|
|
if (!$util.isString(message.key))
|
|
return "key: string expected";
|
|
if (message.value != null && message.hasOwnProperty("value"))
|
|
if (!$util.isString(message.value))
|
|
return "value: string expected";
|
|
return null;
|
|
};
|
|
|
|
/**
|
|
* Creates a StringStringEntryProto message from a plain object. Also converts values to their respective internal types.
|
|
* @function fromObject
|
|
* @memberof onnx.StringStringEntryProto
|
|
* @static
|
|
* @param {Object.<string,*>} object Plain object
|
|
* @returns {onnx.StringStringEntryProto} StringStringEntryProto
|
|
*/
|
|
StringStringEntryProto.fromObject = function fromObject(object) {
|
|
if (object instanceof $root.onnx.StringStringEntryProto)
|
|
return object;
|
|
var message = new $root.onnx.StringStringEntryProto();
|
|
if (object.key != null)
|
|
message.key = String(object.key);
|
|
if (object.value != null)
|
|
message.value = String(object.value);
|
|
return message;
|
|
};
|
|
|
|
/**
|
|
* Creates a plain object from a StringStringEntryProto message. Also converts values to other types if specified.
|
|
* @function toObject
|
|
* @memberof onnx.StringStringEntryProto
|
|
* @static
|
|
* @param {onnx.StringStringEntryProto} message StringStringEntryProto
|
|
* @param {$protobuf.IConversionOptions} [options] Conversion options
|
|
* @returns {Object.<string,*>} Plain object
|
|
*/
|
|
StringStringEntryProto.toObject = function toObject(message, options) {
|
|
if (!options)
|
|
options = {};
|
|
var object = {};
|
|
if (options.defaults) {
|
|
object.key = "";
|
|
object.value = "";
|
|
}
|
|
if (message.key != null && message.hasOwnProperty("key"))
|
|
object.key = message.key;
|
|
if (message.value != null && message.hasOwnProperty("value"))
|
|
object.value = message.value;
|
|
return object;
|
|
};
|
|
|
|
/**
|
|
* Converts this StringStringEntryProto to JSON.
|
|
* @function toJSON
|
|
* @memberof onnx.StringStringEntryProto
|
|
* @instance
|
|
* @returns {Object.<string,*>} JSON object
|
|
*/
|
|
StringStringEntryProto.prototype.toJSON = function toJSON() {
|
|
return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
|
|
};
|
|
|
|
/**
|
|
* Gets the default type url for StringStringEntryProto
|
|
* @function getTypeUrl
|
|
* @memberof onnx.StringStringEntryProto
|
|
* @static
|
|
* @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
|
|
* @returns {string} The default type url
|
|
*/
|
|
StringStringEntryProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
|
|
if (typeUrlPrefix === undefined) {
|
|
typeUrlPrefix = "type.googleapis.com";
|
|
}
|
|
return typeUrlPrefix + "/onnx.StringStringEntryProto";
|
|
};
|
|
|
|
return StringStringEntryProto;
|
|
})();
|
|
|
|
onnx.TensorAnnotation = (function() {
|
|
|
|
/**
|
|
* Properties of a TensorAnnotation.
|
|
* @memberof onnx
|
|
* @interface ITensorAnnotation
|
|
* @property {string|null} [tensorName] TensorAnnotation tensorName
|
|
* @property {Array.<onnx.IStringStringEntryProto>|null} [quantParameterTensorNames] TensorAnnotation quantParameterTensorNames
|
|
*/
|
|
|
|
/**
|
|
* Constructs a new TensorAnnotation.
|
|
* @memberof onnx
|
|
* @classdesc Represents a TensorAnnotation.
|
|
* @implements ITensorAnnotation
|
|
* @constructor
|
|
* @param {onnx.ITensorAnnotation=} [properties] Properties to set
|
|
*/
|
|
function TensorAnnotation(properties) {
|
|
this.quantParameterTensorNames = [];
|
|
if (properties)
|
|
for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
|
|
if (properties[keys[i]] != null)
|
|
this[keys[i]] = properties[keys[i]];
|
|
}
|
|
|
|
/**
|
|
* TensorAnnotation tensorName.
|
|
* @member {string} tensorName
|
|
* @memberof onnx.TensorAnnotation
|
|
* @instance
|
|
*/
|
|
TensorAnnotation.prototype.tensorName = "";
|
|
|
|
/**
|
|
* TensorAnnotation quantParameterTensorNames.
|
|
* @member {Array.<onnx.IStringStringEntryProto>} quantParameterTensorNames
|
|
* @memberof onnx.TensorAnnotation
|
|
* @instance
|
|
*/
|
|
TensorAnnotation.prototype.quantParameterTensorNames = $util.emptyArray;
|
|
|
|
/**
|
|
* Creates a new TensorAnnotation instance using the specified properties.
|
|
* @function create
|
|
* @memberof onnx.TensorAnnotation
|
|
* @static
|
|
* @param {onnx.ITensorAnnotation=} [properties] Properties to set
|
|
* @returns {onnx.TensorAnnotation} TensorAnnotation instance
|
|
*/
|
|
TensorAnnotation.create = function create(properties) {
|
|
return new TensorAnnotation(properties);
|
|
};
|
|
|
|
/**
|
|
* Encodes the specified TensorAnnotation message. Does not implicitly {@link onnx.TensorAnnotation.verify|verify} messages.
|
|
* @function encode
|
|
* @memberof onnx.TensorAnnotation
|
|
* @static
|
|
* @param {onnx.ITensorAnnotation} message TensorAnnotation message or plain object to encode
|
|
* @param {$protobuf.Writer} [writer] Writer to encode to
|
|
* @returns {$protobuf.Writer} Writer
|
|
*/
|
|
TensorAnnotation.encode = function encode(message, writer) {
|
|
if (!writer)
|
|
writer = $Writer.create();
|
|
if (message.tensorName != null && Object.hasOwnProperty.call(message, "tensorName"))
|
|
writer.uint32(/* id 1, wireType 2 =*/10).string(message.tensorName);
|
|
if (message.quantParameterTensorNames != null && message.quantParameterTensorNames.length)
|
|
for (var i = 0; i < message.quantParameterTensorNames.length; ++i)
|
|
$root.onnx.StringStringEntryProto.encode(message.quantParameterTensorNames[i], writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();
|
|
return writer;
|
|
};
|
|
|
|
/**
|
|
* Encodes the specified TensorAnnotation message, length delimited. Does not implicitly {@link onnx.TensorAnnotation.verify|verify} messages.
|
|
* @function encodeDelimited
|
|
* @memberof onnx.TensorAnnotation
|
|
* @static
|
|
* @param {onnx.ITensorAnnotation} message TensorAnnotation message or plain object to encode
|
|
* @param {$protobuf.Writer} [writer] Writer to encode to
|
|
* @returns {$protobuf.Writer} Writer
|
|
*/
|
|
TensorAnnotation.encodeDelimited = function encodeDelimited(message, writer) {
|
|
return this.encode(message, writer).ldelim();
|
|
};
|
|
|
|
/**
|
|
* Decodes a TensorAnnotation message from the specified reader or buffer.
|
|
* @function decode
|
|
* @memberof onnx.TensorAnnotation
|
|
* @static
|
|
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
|
|
* @param {number} [length] Message length if known beforehand
|
|
* @returns {onnx.TensorAnnotation} TensorAnnotation
|
|
* @throws {Error} If the payload is not a reader or valid buffer
|
|
* @throws {$protobuf.util.ProtocolError} If required fields are missing
|
|
*/
|
|
TensorAnnotation.decode = function decode(reader, length) {
|
|
if (!(reader instanceof $Reader))
|
|
reader = $Reader.create(reader);
|
|
var end = length === undefined ? reader.len : reader.pos + length, message = new $root.onnx.TensorAnnotation();
|
|
while (reader.pos < end) {
|
|
var tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1: {
|
|
message.tensorName = reader.string();
|
|
break;
|
|
}
|
|
case 2: {
|
|
if (!(message.quantParameterTensorNames && message.quantParameterTensorNames.length))
|
|
message.quantParameterTensorNames = [];
|
|
message.quantParameterTensorNames.push($root.onnx.StringStringEntryProto.decode(reader, reader.uint32()));
|
|
break;
|
|
}
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
};
|
|
|
|
/**
|
|
* Decodes a TensorAnnotation message from the specified reader or buffer, length delimited.
|
|
* @function decodeDelimited
|
|
* @memberof onnx.TensorAnnotation
|
|
* @static
|
|
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
|
|
* @returns {onnx.TensorAnnotation} TensorAnnotation
|
|
* @throws {Error} If the payload is not a reader or valid buffer
|
|
* @throws {$protobuf.util.ProtocolError} If required fields are missing
|
|
*/
|
|
TensorAnnotation.decodeDelimited = function decodeDelimited(reader) {
|
|
if (!(reader instanceof $Reader))
|
|
reader = new $Reader(reader);
|
|
return this.decode(reader, reader.uint32());
|
|
};
|
|
|
|
/**
|
|
* Verifies a TensorAnnotation message.
|
|
* @function verify
|
|
* @memberof onnx.TensorAnnotation
|
|
* @static
|
|
* @param {Object.<string,*>} message Plain object to verify
|
|
* @returns {string|null} `null` if valid, otherwise the reason why it is not
|
|
*/
|
|
TensorAnnotation.verify = function verify(message) {
|
|
if (typeof message !== "object" || message === null)
|
|
return "object expected";
|
|
if (message.tensorName != null && message.hasOwnProperty("tensorName"))
|
|
if (!$util.isString(message.tensorName))
|
|
return "tensorName: string expected";
|
|
if (message.quantParameterTensorNames != null && message.hasOwnProperty("quantParameterTensorNames")) {
|
|
if (!Array.isArray(message.quantParameterTensorNames))
|
|
return "quantParameterTensorNames: array expected";
|
|
for (var i = 0; i < message.quantParameterTensorNames.length; ++i) {
|
|
var error = $root.onnx.StringStringEntryProto.verify(message.quantParameterTensorNames[i]);
|
|
if (error)
|
|
return "quantParameterTensorNames." + error;
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
|
|
/**
|
|
* Creates a TensorAnnotation message from a plain object. Also converts values to their respective internal types.
|
|
* @function fromObject
|
|
* @memberof onnx.TensorAnnotation
|
|
* @static
|
|
* @param {Object.<string,*>} object Plain object
|
|
* @returns {onnx.TensorAnnotation} TensorAnnotation
|
|
*/
|
|
TensorAnnotation.fromObject = function fromObject(object) {
|
|
if (object instanceof $root.onnx.TensorAnnotation)
|
|
return object;
|
|
var message = new $root.onnx.TensorAnnotation();
|
|
if (object.tensorName != null)
|
|
message.tensorName = String(object.tensorName);
|
|
if (object.quantParameterTensorNames) {
|
|
if (!Array.isArray(object.quantParameterTensorNames))
|
|
throw TypeError(".onnx.TensorAnnotation.quantParameterTensorNames: array expected");
|
|
message.quantParameterTensorNames = [];
|
|
for (var i = 0; i < object.quantParameterTensorNames.length; ++i) {
|
|
if (typeof object.quantParameterTensorNames[i] !== "object")
|
|
throw TypeError(".onnx.TensorAnnotation.quantParameterTensorNames: object expected");
|
|
message.quantParameterTensorNames[i] = $root.onnx.StringStringEntryProto.fromObject(object.quantParameterTensorNames[i]);
|
|
}
|
|
}
|
|
return message;
|
|
};
|
|
|
|
/**
|
|
* Creates a plain object from a TensorAnnotation message. Also converts values to other types if specified.
|
|
* @function toObject
|
|
* @memberof onnx.TensorAnnotation
|
|
* @static
|
|
* @param {onnx.TensorAnnotation} message TensorAnnotation
|
|
* @param {$protobuf.IConversionOptions} [options] Conversion options
|
|
* @returns {Object.<string,*>} Plain object
|
|
*/
|
|
TensorAnnotation.toObject = function toObject(message, options) {
|
|
if (!options)
|
|
options = {};
|
|
var object = {};
|
|
if (options.arrays || options.defaults)
|
|
object.quantParameterTensorNames = [];
|
|
if (options.defaults)
|
|
object.tensorName = "";
|
|
if (message.tensorName != null && message.hasOwnProperty("tensorName"))
|
|
object.tensorName = message.tensorName;
|
|
if (message.quantParameterTensorNames && message.quantParameterTensorNames.length) {
|
|
object.quantParameterTensorNames = [];
|
|
for (var j = 0; j < message.quantParameterTensorNames.length; ++j)
|
|
object.quantParameterTensorNames[j] = $root.onnx.StringStringEntryProto.toObject(message.quantParameterTensorNames[j], options);
|
|
}
|
|
return object;
|
|
};
|
|
|
|
/**
|
|
* Converts this TensorAnnotation to JSON.
|
|
* @function toJSON
|
|
* @memberof onnx.TensorAnnotation
|
|
* @instance
|
|
* @returns {Object.<string,*>} JSON object
|
|
*/
|
|
TensorAnnotation.prototype.toJSON = function toJSON() {
|
|
return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
|
|
};
|
|
|
|
/**
|
|
* Gets the default type url for TensorAnnotation
|
|
* @function getTypeUrl
|
|
* @memberof onnx.TensorAnnotation
|
|
* @static
|
|
* @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
|
|
* @returns {string} The default type url
|
|
*/
|
|
TensorAnnotation.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
|
|
if (typeUrlPrefix === undefined) {
|
|
typeUrlPrefix = "type.googleapis.com";
|
|
}
|
|
return typeUrlPrefix + "/onnx.TensorAnnotation";
|
|
};
|
|
|
|
return TensorAnnotation;
|
|
})();
|
|
|
|
onnx.GraphProto = (function() {
|
|
|
|
/**
|
|
* Properties of a GraphProto.
|
|
* @memberof onnx
|
|
* @interface IGraphProto
|
|
* @property {Array.<onnx.INodeProto>|null} [node] GraphProto node
|
|
* @property {string|null} [name] GraphProto name
|
|
* @property {Array.<onnx.ITensorProto>|null} [initializer] GraphProto initializer
|
|
* @property {Array.<onnx.ISparseTensorProto>|null} [sparseInitializer] GraphProto sparseInitializer
|
|
* @property {string|null} [docString] GraphProto docString
|
|
* @property {Array.<onnx.IValueInfoProto>|null} [input] GraphProto input
|
|
* @property {Array.<onnx.IValueInfoProto>|null} [output] GraphProto output
|
|
* @property {Array.<onnx.IValueInfoProto>|null} [valueInfo] GraphProto valueInfo
|
|
* @property {Array.<onnx.ITensorAnnotation>|null} [quantizationAnnotation] GraphProto quantizationAnnotation
|
|
*/
|
|
|
|
/**
|
|
* Constructs a new GraphProto.
|
|
* @memberof onnx
|
|
* @classdesc Represents a GraphProto.
|
|
* @implements IGraphProto
|
|
* @constructor
|
|
* @param {onnx.IGraphProto=} [properties] Properties to set
|
|
*/
|
|
function GraphProto(properties) {
|
|
this.node = [];
|
|
this.initializer = [];
|
|
this.sparseInitializer = [];
|
|
this.input = [];
|
|
this.output = [];
|
|
this.valueInfo = [];
|
|
this.quantizationAnnotation = [];
|
|
if (properties)
|
|
for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
|
|
if (properties[keys[i]] != null)
|
|
this[keys[i]] = properties[keys[i]];
|
|
}
|
|
|
|
/**
|
|
* GraphProto node.
|
|
* @member {Array.<onnx.INodeProto>} node
|
|
* @memberof onnx.GraphProto
|
|
* @instance
|
|
*/
|
|
GraphProto.prototype.node = $util.emptyArray;
|
|
|
|
/**
|
|
* GraphProto name.
|
|
* @member {string} name
|
|
* @memberof onnx.GraphProto
|
|
* @instance
|
|
*/
|
|
GraphProto.prototype.name = "";
|
|
|
|
/**
|
|
* GraphProto initializer.
|
|
* @member {Array.<onnx.ITensorProto>} initializer
|
|
* @memberof onnx.GraphProto
|
|
* @instance
|
|
*/
|
|
GraphProto.prototype.initializer = $util.emptyArray;
|
|
|
|
/**
|
|
* GraphProto sparseInitializer.
|
|
* @member {Array.<onnx.ISparseTensorProto>} sparseInitializer
|
|
* @memberof onnx.GraphProto
|
|
* @instance
|
|
*/
|
|
GraphProto.prototype.sparseInitializer = $util.emptyArray;
|
|
|
|
/**
|
|
* GraphProto docString.
|
|
* @member {string} docString
|
|
* @memberof onnx.GraphProto
|
|
* @instance
|
|
*/
|
|
GraphProto.prototype.docString = "";
|
|
|
|
/**
|
|
* GraphProto input.
|
|
* @member {Array.<onnx.IValueInfoProto>} input
|
|
* @memberof onnx.GraphProto
|
|
* @instance
|
|
*/
|
|
GraphProto.prototype.input = $util.emptyArray;
|
|
|
|
/**
|
|
* GraphProto output.
|
|
* @member {Array.<onnx.IValueInfoProto>} output
|
|
* @memberof onnx.GraphProto
|
|
* @instance
|
|
*/
|
|
GraphProto.prototype.output = $util.emptyArray;
|
|
|
|
/**
|
|
* GraphProto valueInfo.
|
|
* @member {Array.<onnx.IValueInfoProto>} valueInfo
|
|
* @memberof onnx.GraphProto
|
|
* @instance
|
|
*/
|
|
GraphProto.prototype.valueInfo = $util.emptyArray;
|
|
|
|
/**
|
|
* GraphProto quantizationAnnotation.
|
|
* @member {Array.<onnx.ITensorAnnotation>} quantizationAnnotation
|
|
* @memberof onnx.GraphProto
|
|
* @instance
|
|
*/
|
|
GraphProto.prototype.quantizationAnnotation = $util.emptyArray;
|
|
|
|
/**
|
|
* Creates a new GraphProto instance using the specified properties.
|
|
* @function create
|
|
* @memberof onnx.GraphProto
|
|
* @static
|
|
* @param {onnx.IGraphProto=} [properties] Properties to set
|
|
* @returns {onnx.GraphProto} GraphProto instance
|
|
*/
|
|
GraphProto.create = function create(properties) {
|
|
return new GraphProto(properties);
|
|
};
|
|
|
|
/**
|
|
* Encodes the specified GraphProto message. Does not implicitly {@link onnx.GraphProto.verify|verify} messages.
|
|
* @function encode
|
|
* @memberof onnx.GraphProto
|
|
* @static
|
|
* @param {onnx.IGraphProto} message GraphProto message or plain object to encode
|
|
* @param {$protobuf.Writer} [writer] Writer to encode to
|
|
* @returns {$protobuf.Writer} Writer
|
|
*/
|
|
GraphProto.encode = function encode(message, writer) {
|
|
if (!writer)
|
|
writer = $Writer.create();
|
|
if (message.node != null && message.node.length)
|
|
for (var i = 0; i < message.node.length; ++i)
|
|
$root.onnx.NodeProto.encode(message.node[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
|
|
if (message.name != null && Object.hasOwnProperty.call(message, "name"))
|
|
writer.uint32(/* id 2, wireType 2 =*/18).string(message.name);
|
|
if (message.initializer != null && message.initializer.length)
|
|
for (var i = 0; i < message.initializer.length; ++i)
|
|
$root.onnx.TensorProto.encode(message.initializer[i], writer.uint32(/* id 5, wireType 2 =*/42).fork()).ldelim();
|
|
if (message.docString != null && Object.hasOwnProperty.call(message, "docString"))
|
|
writer.uint32(/* id 10, wireType 2 =*/82).string(message.docString);
|
|
if (message.input != null && message.input.length)
|
|
for (var i = 0; i < message.input.length; ++i)
|
|
$root.onnx.ValueInfoProto.encode(message.input[i], writer.uint32(/* id 11, wireType 2 =*/90).fork()).ldelim();
|
|
if (message.output != null && message.output.length)
|
|
for (var i = 0; i < message.output.length; ++i)
|
|
$root.onnx.ValueInfoProto.encode(message.output[i], writer.uint32(/* id 12, wireType 2 =*/98).fork()).ldelim();
|
|
if (message.valueInfo != null && message.valueInfo.length)
|
|
for (var i = 0; i < message.valueInfo.length; ++i)
|
|
$root.onnx.ValueInfoProto.encode(message.valueInfo[i], writer.uint32(/* id 13, wireType 2 =*/106).fork()).ldelim();
|
|
if (message.quantizationAnnotation != null && message.quantizationAnnotation.length)
|
|
for (var i = 0; i < message.quantizationAnnotation.length; ++i)
|
|
$root.onnx.TensorAnnotation.encode(message.quantizationAnnotation[i], writer.uint32(/* id 14, wireType 2 =*/114).fork()).ldelim();
|
|
if (message.sparseInitializer != null && message.sparseInitializer.length)
|
|
for (var i = 0; i < message.sparseInitializer.length; ++i)
|
|
$root.onnx.SparseTensorProto.encode(message.sparseInitializer[i], writer.uint32(/* id 15, wireType 2 =*/122).fork()).ldelim();
|
|
return writer;
|
|
};
|
|
|
|
/**
|
|
* Encodes the specified GraphProto message, length delimited. Does not implicitly {@link onnx.GraphProto.verify|verify} messages.
|
|
* @function encodeDelimited
|
|
* @memberof onnx.GraphProto
|
|
* @static
|
|
* @param {onnx.IGraphProto} message GraphProto message or plain object to encode
|
|
* @param {$protobuf.Writer} [writer] Writer to encode to
|
|
* @returns {$protobuf.Writer} Writer
|
|
*/
|
|
GraphProto.encodeDelimited = function encodeDelimited(message, writer) {
|
|
return this.encode(message, writer).ldelim();
|
|
};
|
|
|
|
/**
|
|
* Decodes a GraphProto message from the specified reader or buffer.
|
|
* @function decode
|
|
* @memberof onnx.GraphProto
|
|
* @static
|
|
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
|
|
* @param {number} [length] Message length if known beforehand
|
|
* @returns {onnx.GraphProto} GraphProto
|
|
* @throws {Error} If the payload is not a reader or valid buffer
|
|
* @throws {$protobuf.util.ProtocolError} If required fields are missing
|
|
*/
|
|
GraphProto.decode = function decode(reader, length) {
|
|
if (!(reader instanceof $Reader))
|
|
reader = $Reader.create(reader);
|
|
var end = length === undefined ? reader.len : reader.pos + length, message = new $root.onnx.GraphProto();
|
|
while (reader.pos < end) {
|
|
var tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1: {
|
|
if (!(message.node && message.node.length))
|
|
message.node = [];
|
|
message.node.push($root.onnx.NodeProto.decode(reader, reader.uint32()));
|
|
break;
|
|
}
|
|
case 2: {
|
|
message.name = reader.string();
|
|
break;
|
|
}
|
|
case 5: {
|
|
if (!(message.initializer && message.initializer.length))
|
|
message.initializer = [];
|
|
message.initializer.push($root.onnx.TensorProto.decode(reader, reader.uint32()));
|
|
break;
|
|
}
|
|
case 15: {
|
|
if (!(message.sparseInitializer && message.sparseInitializer.length))
|
|
message.sparseInitializer = [];
|
|
message.sparseInitializer.push($root.onnx.SparseTensorProto.decode(reader, reader.uint32()));
|
|
break;
|
|
}
|
|
case 10: {
|
|
message.docString = reader.string();
|
|
break;
|
|
}
|
|
case 11: {
|
|
if (!(message.input && message.input.length))
|
|
message.input = [];
|
|
message.input.push($root.onnx.ValueInfoProto.decode(reader, reader.uint32()));
|
|
break;
|
|
}
|
|
case 12: {
|
|
if (!(message.output && message.output.length))
|
|
message.output = [];
|
|
message.output.push($root.onnx.ValueInfoProto.decode(reader, reader.uint32()));
|
|
break;
|
|
}
|
|
case 13: {
|
|
if (!(message.valueInfo && message.valueInfo.length))
|
|
message.valueInfo = [];
|
|
message.valueInfo.push($root.onnx.ValueInfoProto.decode(reader, reader.uint32()));
|
|
break;
|
|
}
|
|
case 14: {
|
|
if (!(message.quantizationAnnotation && message.quantizationAnnotation.length))
|
|
message.quantizationAnnotation = [];
|
|
message.quantizationAnnotation.push($root.onnx.TensorAnnotation.decode(reader, reader.uint32()));
|
|
break;
|
|
}
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
};
|
|
|
|
/**
|
|
* Decodes a GraphProto message from the specified reader or buffer, length delimited.
|
|
* @function decodeDelimited
|
|
* @memberof onnx.GraphProto
|
|
* @static
|
|
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
|
|
* @returns {onnx.GraphProto} GraphProto
|
|
* @throws {Error} If the payload is not a reader or valid buffer
|
|
* @throws {$protobuf.util.ProtocolError} If required fields are missing
|
|
*/
|
|
GraphProto.decodeDelimited = function decodeDelimited(reader) {
|
|
if (!(reader instanceof $Reader))
|
|
reader = new $Reader(reader);
|
|
return this.decode(reader, reader.uint32());
|
|
};
|
|
|
|
/**
|
|
* Verifies a GraphProto message.
|
|
* @function verify
|
|
* @memberof onnx.GraphProto
|
|
* @static
|
|
* @param {Object.<string,*>} message Plain object to verify
|
|
* @returns {string|null} `null` if valid, otherwise the reason why it is not
|
|
*/
|
|
GraphProto.verify = function verify(message) {
|
|
if (typeof message !== "object" || message === null)
|
|
return "object expected";
|
|
if (message.node != null && message.hasOwnProperty("node")) {
|
|
if (!Array.isArray(message.node))
|
|
return "node: array expected";
|
|
for (var i = 0; i < message.node.length; ++i) {
|
|
var error = $root.onnx.NodeProto.verify(message.node[i]);
|
|
if (error)
|
|
return "node." + error;
|
|
}
|
|
}
|
|
if (message.name != null && message.hasOwnProperty("name"))
|
|
if (!$util.isString(message.name))
|
|
return "name: string expected";
|
|
if (message.initializer != null && message.hasOwnProperty("initializer")) {
|
|
if (!Array.isArray(message.initializer))
|
|
return "initializer: array expected";
|
|
for (var i = 0; i < message.initializer.length; ++i) {
|
|
var error = $root.onnx.TensorProto.verify(message.initializer[i]);
|
|
if (error)
|
|
return "initializer." + error;
|
|
}
|
|
}
|
|
if (message.sparseInitializer != null && message.hasOwnProperty("sparseInitializer")) {
|
|
if (!Array.isArray(message.sparseInitializer))
|
|
return "sparseInitializer: array expected";
|
|
for (var i = 0; i < message.sparseInitializer.length; ++i) {
|
|
var error = $root.onnx.SparseTensorProto.verify(message.sparseInitializer[i]);
|
|
if (error)
|
|
return "sparseInitializer." + error;
|
|
}
|
|
}
|
|
if (message.docString != null && message.hasOwnProperty("docString"))
|
|
if (!$util.isString(message.docString))
|
|
return "docString: string expected";
|
|
if (message.input != null && message.hasOwnProperty("input")) {
|
|
if (!Array.isArray(message.input))
|
|
return "input: array expected";
|
|
for (var i = 0; i < message.input.length; ++i) {
|
|
var error = $root.onnx.ValueInfoProto.verify(message.input[i]);
|
|
if (error)
|
|
return "input." + error;
|
|
}
|
|
}
|
|
if (message.output != null && message.hasOwnProperty("output")) {
|
|
if (!Array.isArray(message.output))
|
|
return "output: array expected";
|
|
for (var i = 0; i < message.output.length; ++i) {
|
|
var error = $root.onnx.ValueInfoProto.verify(message.output[i]);
|
|
if (error)
|
|
return "output." + error;
|
|
}
|
|
}
|
|
if (message.valueInfo != null && message.hasOwnProperty("valueInfo")) {
|
|
if (!Array.isArray(message.valueInfo))
|
|
return "valueInfo: array expected";
|
|
for (var i = 0; i < message.valueInfo.length; ++i) {
|
|
var error = $root.onnx.ValueInfoProto.verify(message.valueInfo[i]);
|
|
if (error)
|
|
return "valueInfo." + error;
|
|
}
|
|
}
|
|
if (message.quantizationAnnotation != null && message.hasOwnProperty("quantizationAnnotation")) {
|
|
if (!Array.isArray(message.quantizationAnnotation))
|
|
return "quantizationAnnotation: array expected";
|
|
for (var i = 0; i < message.quantizationAnnotation.length; ++i) {
|
|
var error = $root.onnx.TensorAnnotation.verify(message.quantizationAnnotation[i]);
|
|
if (error)
|
|
return "quantizationAnnotation." + error;
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
|
|
/**
|
|
* Creates a GraphProto message from a plain object. Also converts values to their respective internal types.
|
|
* @function fromObject
|
|
* @memberof onnx.GraphProto
|
|
* @static
|
|
* @param {Object.<string,*>} object Plain object
|
|
* @returns {onnx.GraphProto} GraphProto
|
|
*/
|
|
GraphProto.fromObject = function fromObject(object) {
|
|
if (object instanceof $root.onnx.GraphProto)
|
|
return object;
|
|
var message = new $root.onnx.GraphProto();
|
|
if (object.node) {
|
|
if (!Array.isArray(object.node))
|
|
throw TypeError(".onnx.GraphProto.node: array expected");
|
|
message.node = [];
|
|
for (var i = 0; i < object.node.length; ++i) {
|
|
if (typeof object.node[i] !== "object")
|
|
throw TypeError(".onnx.GraphProto.node: object expected");
|
|
message.node[i] = $root.onnx.NodeProto.fromObject(object.node[i]);
|
|
}
|
|
}
|
|
if (object.name != null)
|
|
message.name = String(object.name);
|
|
if (object.initializer) {
|
|
if (!Array.isArray(object.initializer))
|
|
throw TypeError(".onnx.GraphProto.initializer: array expected");
|
|
message.initializer = [];
|
|
for (var i = 0; i < object.initializer.length; ++i) {
|
|
if (typeof object.initializer[i] !== "object")
|
|
throw TypeError(".onnx.GraphProto.initializer: object expected");
|
|
message.initializer[i] = $root.onnx.TensorProto.fromObject(object.initializer[i]);
|
|
}
|
|
}
|
|
if (object.sparseInitializer) {
|
|
if (!Array.isArray(object.sparseInitializer))
|
|
throw TypeError(".onnx.GraphProto.sparseInitializer: array expected");
|
|
message.sparseInitializer = [];
|
|
for (var i = 0; i < object.sparseInitializer.length; ++i) {
|
|
if (typeof object.sparseInitializer[i] !== "object")
|
|
throw TypeError(".onnx.GraphProto.sparseInitializer: object expected");
|
|
message.sparseInitializer[i] = $root.onnx.SparseTensorProto.fromObject(object.sparseInitializer[i]);
|
|
}
|
|
}
|
|
if (object.docString != null)
|
|
message.docString = String(object.docString);
|
|
if (object.input) {
|
|
if (!Array.isArray(object.input))
|
|
throw TypeError(".onnx.GraphProto.input: array expected");
|
|
message.input = [];
|
|
for (var i = 0; i < object.input.length; ++i) {
|
|
if (typeof object.input[i] !== "object")
|
|
throw TypeError(".onnx.GraphProto.input: object expected");
|
|
message.input[i] = $root.onnx.ValueInfoProto.fromObject(object.input[i]);
|
|
}
|
|
}
|
|
if (object.output) {
|
|
if (!Array.isArray(object.output))
|
|
throw TypeError(".onnx.GraphProto.output: array expected");
|
|
message.output = [];
|
|
for (var i = 0; i < object.output.length; ++i) {
|
|
if (typeof object.output[i] !== "object")
|
|
throw TypeError(".onnx.GraphProto.output: object expected");
|
|
message.output[i] = $root.onnx.ValueInfoProto.fromObject(object.output[i]);
|
|
}
|
|
}
|
|
if (object.valueInfo) {
|
|
if (!Array.isArray(object.valueInfo))
|
|
throw TypeError(".onnx.GraphProto.valueInfo: array expected");
|
|
message.valueInfo = [];
|
|
for (var i = 0; i < object.valueInfo.length; ++i) {
|
|
if (typeof object.valueInfo[i] !== "object")
|
|
throw TypeError(".onnx.GraphProto.valueInfo: object expected");
|
|
message.valueInfo[i] = $root.onnx.ValueInfoProto.fromObject(object.valueInfo[i]);
|
|
}
|
|
}
|
|
if (object.quantizationAnnotation) {
|
|
if (!Array.isArray(object.quantizationAnnotation))
|
|
throw TypeError(".onnx.GraphProto.quantizationAnnotation: array expected");
|
|
message.quantizationAnnotation = [];
|
|
for (var i = 0; i < object.quantizationAnnotation.length; ++i) {
|
|
if (typeof object.quantizationAnnotation[i] !== "object")
|
|
throw TypeError(".onnx.GraphProto.quantizationAnnotation: object expected");
|
|
message.quantizationAnnotation[i] = $root.onnx.TensorAnnotation.fromObject(object.quantizationAnnotation[i]);
|
|
}
|
|
}
|
|
return message;
|
|
};
|
|
|
|
/**
|
|
* Creates a plain object from a GraphProto message. Also converts values to other types if specified.
|
|
* @function toObject
|
|
* @memberof onnx.GraphProto
|
|
* @static
|
|
* @param {onnx.GraphProto} message GraphProto
|
|
* @param {$protobuf.IConversionOptions} [options] Conversion options
|
|
* @returns {Object.<string,*>} Plain object
|
|
*/
|
|
GraphProto.toObject = function toObject(message, options) {
|
|
if (!options)
|
|
options = {};
|
|
var object = {};
|
|
if (options.arrays || options.defaults) {
|
|
object.node = [];
|
|
object.initializer = [];
|
|
object.input = [];
|
|
object.output = [];
|
|
object.valueInfo = [];
|
|
object.quantizationAnnotation = [];
|
|
object.sparseInitializer = [];
|
|
}
|
|
if (options.defaults) {
|
|
object.name = "";
|
|
object.docString = "";
|
|
}
|
|
if (message.node && message.node.length) {
|
|
object.node = [];
|
|
for (var j = 0; j < message.node.length; ++j)
|
|
object.node[j] = $root.onnx.NodeProto.toObject(message.node[j], options);
|
|
}
|
|
if (message.name != null && message.hasOwnProperty("name"))
|
|
object.name = message.name;
|
|
if (message.initializer && message.initializer.length) {
|
|
object.initializer = [];
|
|
for (var j = 0; j < message.initializer.length; ++j)
|
|
object.initializer[j] = $root.onnx.TensorProto.toObject(message.initializer[j], options);
|
|
}
|
|
if (message.docString != null && message.hasOwnProperty("docString"))
|
|
object.docString = message.docString;
|
|
if (message.input && message.input.length) {
|
|
object.input = [];
|
|
for (var j = 0; j < message.input.length; ++j)
|
|
object.input[j] = $root.onnx.ValueInfoProto.toObject(message.input[j], options);
|
|
}
|
|
if (message.output && message.output.length) {
|
|
object.output = [];
|
|
for (var j = 0; j < message.output.length; ++j)
|
|
object.output[j] = $root.onnx.ValueInfoProto.toObject(message.output[j], options);
|
|
}
|
|
if (message.valueInfo && message.valueInfo.length) {
|
|
object.valueInfo = [];
|
|
for (var j = 0; j < message.valueInfo.length; ++j)
|
|
object.valueInfo[j] = $root.onnx.ValueInfoProto.toObject(message.valueInfo[j], options);
|
|
}
|
|
if (message.quantizationAnnotation && message.quantizationAnnotation.length) {
|
|
object.quantizationAnnotation = [];
|
|
for (var j = 0; j < message.quantizationAnnotation.length; ++j)
|
|
object.quantizationAnnotation[j] = $root.onnx.TensorAnnotation.toObject(message.quantizationAnnotation[j], options);
|
|
}
|
|
if (message.sparseInitializer && message.sparseInitializer.length) {
|
|
object.sparseInitializer = [];
|
|
for (var j = 0; j < message.sparseInitializer.length; ++j)
|
|
object.sparseInitializer[j] = $root.onnx.SparseTensorProto.toObject(message.sparseInitializer[j], options);
|
|
}
|
|
return object;
|
|
};
|
|
|
|
/**
|
|
* Converts this GraphProto to JSON.
|
|
* @function toJSON
|
|
* @memberof onnx.GraphProto
|
|
* @instance
|
|
* @returns {Object.<string,*>} JSON object
|
|
*/
|
|
GraphProto.prototype.toJSON = function toJSON() {
|
|
return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
|
|
};
|
|
|
|
/**
|
|
* Gets the default type url for GraphProto
|
|
* @function getTypeUrl
|
|
* @memberof onnx.GraphProto
|
|
* @static
|
|
* @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
|
|
* @returns {string} The default type url
|
|
*/
|
|
GraphProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
|
|
if (typeUrlPrefix === undefined) {
|
|
typeUrlPrefix = "type.googleapis.com";
|
|
}
|
|
return typeUrlPrefix + "/onnx.GraphProto";
|
|
};
|
|
|
|
return GraphProto;
|
|
})();
|
|
|
|
onnx.TensorProto = (function() {
|
|
|
|
/**
|
|
* Properties of a TensorProto.
|
|
* @memberof onnx
|
|
* @interface ITensorProto
|
|
* @property {Array.<number|Long>|null} [dims] TensorProto dims
|
|
* @property {number|null} [dataType] TensorProto dataType
|
|
* @property {onnx.TensorProto.ISegment|null} [segment] TensorProto segment
|
|
* @property {Array.<number>|null} [floatData] TensorProto floatData
|
|
* @property {Array.<number>|null} [int32Data] TensorProto int32Data
|
|
* @property {Array.<Uint8Array>|null} [stringData] TensorProto stringData
|
|
* @property {Array.<number|Long>|null} [int64Data] TensorProto int64Data
|
|
* @property {string|null} [name] TensorProto name
|
|
* @property {string|null} [docString] TensorProto docString
|
|
* @property {Uint8Array|null} [rawData] TensorProto rawData
|
|
* @property {Array.<onnx.IStringStringEntryProto>|null} [externalData] TensorProto externalData
|
|
* @property {onnx.TensorProto.DataLocation|null} [dataLocation] TensorProto dataLocation
|
|
* @property {Array.<number>|null} [doubleData] TensorProto doubleData
|
|
* @property {Array.<number|Long>|null} [uint64Data] TensorProto uint64Data
|
|
*/
|
|
|
|
/**
|
|
* Constructs a new TensorProto.
|
|
* @memberof onnx
|
|
* @classdesc Represents a TensorProto.
|
|
* @implements ITensorProto
|
|
* @constructor
|
|
* @param {onnx.ITensorProto=} [properties] Properties to set
|
|
*/
|
|
function TensorProto(properties) {
|
|
this.dims = [];
|
|
this.floatData = [];
|
|
this.int32Data = [];
|
|
this.stringData = [];
|
|
this.int64Data = [];
|
|
this.externalData = [];
|
|
this.doubleData = [];
|
|
this.uint64Data = [];
|
|
if (properties)
|
|
for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
|
|
if (properties[keys[i]] != null)
|
|
this[keys[i]] = properties[keys[i]];
|
|
}
|
|
|
|
/**
|
|
* TensorProto dims.
|
|
* @member {Array.<number|Long>} dims
|
|
* @memberof onnx.TensorProto
|
|
* @instance
|
|
*/
|
|
TensorProto.prototype.dims = $util.emptyArray;
|
|
|
|
/**
|
|
* TensorProto dataType.
|
|
* @member {number} dataType
|
|
* @memberof onnx.TensorProto
|
|
* @instance
|
|
*/
|
|
TensorProto.prototype.dataType = 0;
|
|
|
|
/**
|
|
* TensorProto segment.
|
|
* @member {onnx.TensorProto.ISegment|null|undefined} segment
|
|
* @memberof onnx.TensorProto
|
|
* @instance
|
|
*/
|
|
TensorProto.prototype.segment = null;
|
|
|
|
/**
|
|
* TensorProto floatData.
|
|
* @member {Array.<number>} floatData
|
|
* @memberof onnx.TensorProto
|
|
* @instance
|
|
*/
|
|
TensorProto.prototype.floatData = $util.emptyArray;
|
|
|
|
/**
|
|
* TensorProto int32Data.
|
|
* @member {Array.<number>} int32Data
|
|
* @memberof onnx.TensorProto
|
|
* @instance
|
|
*/
|
|
TensorProto.prototype.int32Data = $util.emptyArray;
|
|
|
|
/**
|
|
* TensorProto stringData.
|
|
* @member {Array.<Uint8Array>} stringData
|
|
* @memberof onnx.TensorProto
|
|
* @instance
|
|
*/
|
|
TensorProto.prototype.stringData = $util.emptyArray;
|
|
|
|
/**
|
|
* TensorProto int64Data.
|
|
* @member {Array.<number|Long>} int64Data
|
|
* @memberof onnx.TensorProto
|
|
* @instance
|
|
*/
|
|
TensorProto.prototype.int64Data = $util.emptyArray;
|
|
|
|
/**
|
|
* TensorProto name.
|
|
* @member {string} name
|
|
* @memberof onnx.TensorProto
|
|
* @instance
|
|
*/
|
|
TensorProto.prototype.name = "";
|
|
|
|
/**
|
|
* TensorProto docString.
|
|
* @member {string} docString
|
|
* @memberof onnx.TensorProto
|
|
* @instance
|
|
*/
|
|
TensorProto.prototype.docString = "";
|
|
|
|
/**
|
|
* TensorProto rawData.
|
|
* @member {Uint8Array} rawData
|
|
* @memberof onnx.TensorProto
|
|
* @instance
|
|
*/
|
|
TensorProto.prototype.rawData = $util.newBuffer([]);
|
|
|
|
/**
|
|
* TensorProto externalData.
|
|
* @member {Array.<onnx.IStringStringEntryProto>} externalData
|
|
* @memberof onnx.TensorProto
|
|
* @instance
|
|
*/
|
|
TensorProto.prototype.externalData = $util.emptyArray;
|
|
|
|
/**
|
|
* TensorProto dataLocation.
|
|
* @member {onnx.TensorProto.DataLocation} dataLocation
|
|
* @memberof onnx.TensorProto
|
|
* @instance
|
|
*/
|
|
TensorProto.prototype.dataLocation = 0;
|
|
|
|
/**
|
|
* TensorProto doubleData.
|
|
* @member {Array.<number>} doubleData
|
|
* @memberof onnx.TensorProto
|
|
* @instance
|
|
*/
|
|
TensorProto.prototype.doubleData = $util.emptyArray;
|
|
|
|
/**
|
|
* TensorProto uint64Data.
|
|
* @member {Array.<number|Long>} uint64Data
|
|
* @memberof onnx.TensorProto
|
|
* @instance
|
|
*/
|
|
TensorProto.prototype.uint64Data = $util.emptyArray;
|
|
|
|
/**
|
|
* Creates a new TensorProto instance using the specified properties.
|
|
* @function create
|
|
* @memberof onnx.TensorProto
|
|
* @static
|
|
* @param {onnx.ITensorProto=} [properties] Properties to set
|
|
* @returns {onnx.TensorProto} TensorProto instance
|
|
*/
|
|
TensorProto.create = function create(properties) {
|
|
return new TensorProto(properties);
|
|
};
|
|
|
|
/**
|
|
* Encodes the specified TensorProto message. Does not implicitly {@link onnx.TensorProto.verify|verify} messages.
|
|
* @function encode
|
|
* @memberof onnx.TensorProto
|
|
* @static
|
|
* @param {onnx.ITensorProto} message TensorProto message or plain object to encode
|
|
* @param {$protobuf.Writer} [writer] Writer to encode to
|
|
* @returns {$protobuf.Writer} Writer
|
|
*/
|
|
TensorProto.encode = function encode(message, writer) {
|
|
if (!writer)
|
|
writer = $Writer.create();
|
|
if (message.dims != null && message.dims.length) {
|
|
writer.uint32(/* id 1, wireType 2 =*/10).fork();
|
|
for (var i = 0; i < message.dims.length; ++i)
|
|
writer.int64(message.dims[i]);
|
|
writer.ldelim();
|
|
}
|
|
if (message.dataType != null && Object.hasOwnProperty.call(message, "dataType"))
|
|
writer.uint32(/* id 2, wireType 0 =*/16).int32(message.dataType);
|
|
if (message.segment != null && Object.hasOwnProperty.call(message, "segment"))
|
|
$root.onnx.TensorProto.Segment.encode(message.segment, writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim();
|
|
if (message.floatData != null && message.floatData.length) {
|
|
writer.uint32(/* id 4, wireType 2 =*/34).fork();
|
|
for (var i = 0; i < message.floatData.length; ++i)
|
|
writer.float(message.floatData[i]);
|
|
writer.ldelim();
|
|
}
|
|
if (message.int32Data != null && message.int32Data.length) {
|
|
writer.uint32(/* id 5, wireType 2 =*/42).fork();
|
|
for (var i = 0; i < message.int32Data.length; ++i)
|
|
writer.int32(message.int32Data[i]);
|
|
writer.ldelim();
|
|
}
|
|
if (message.stringData != null && message.stringData.length)
|
|
for (var i = 0; i < message.stringData.length; ++i)
|
|
writer.uint32(/* id 6, wireType 2 =*/50).bytes(message.stringData[i]);
|
|
if (message.int64Data != null && message.int64Data.length) {
|
|
writer.uint32(/* id 7, wireType 2 =*/58).fork();
|
|
for (var i = 0; i < message.int64Data.length; ++i)
|
|
writer.int64(message.int64Data[i]);
|
|
writer.ldelim();
|
|
}
|
|
if (message.name != null && Object.hasOwnProperty.call(message, "name"))
|
|
writer.uint32(/* id 8, wireType 2 =*/66).string(message.name);
|
|
if (message.rawData != null && Object.hasOwnProperty.call(message, "rawData"))
|
|
writer.uint32(/* id 9, wireType 2 =*/74).bytes(message.rawData);
|
|
if (message.doubleData != null && message.doubleData.length) {
|
|
writer.uint32(/* id 10, wireType 2 =*/82).fork();
|
|
for (var i = 0; i < message.doubleData.length; ++i)
|
|
writer.double(message.doubleData[i]);
|
|
writer.ldelim();
|
|
}
|
|
if (message.uint64Data != null && message.uint64Data.length) {
|
|
writer.uint32(/* id 11, wireType 2 =*/90).fork();
|
|
for (var i = 0; i < message.uint64Data.length; ++i)
|
|
writer.uint64(message.uint64Data[i]);
|
|
writer.ldelim();
|
|
}
|
|
if (message.docString != null && Object.hasOwnProperty.call(message, "docString"))
|
|
writer.uint32(/* id 12, wireType 2 =*/98).string(message.docString);
|
|
if (message.externalData != null && message.externalData.length)
|
|
for (var i = 0; i < message.externalData.length; ++i)
|
|
$root.onnx.StringStringEntryProto.encode(message.externalData[i], writer.uint32(/* id 13, wireType 2 =*/106).fork()).ldelim();
|
|
if (message.dataLocation != null && Object.hasOwnProperty.call(message, "dataLocation"))
|
|
writer.uint32(/* id 14, wireType 0 =*/112).int32(message.dataLocation);
|
|
return writer;
|
|
};
|
|
|
|
/**
|
|
* Encodes the specified TensorProto message, length delimited. Does not implicitly {@link onnx.TensorProto.verify|verify} messages.
|
|
* @function encodeDelimited
|
|
* @memberof onnx.TensorProto
|
|
* @static
|
|
* @param {onnx.ITensorProto} message TensorProto message or plain object to encode
|
|
* @param {$protobuf.Writer} [writer] Writer to encode to
|
|
* @returns {$protobuf.Writer} Writer
|
|
*/
|
|
TensorProto.encodeDelimited = function encodeDelimited(message, writer) {
|
|
return this.encode(message, writer).ldelim();
|
|
};
|
|
|
|
/**
|
|
* Decodes a TensorProto message from the specified reader or buffer.
|
|
* @function decode
|
|
* @memberof onnx.TensorProto
|
|
* @static
|
|
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
|
|
* @param {number} [length] Message length if known beforehand
|
|
* @returns {onnx.TensorProto} TensorProto
|
|
* @throws {Error} If the payload is not a reader or valid buffer
|
|
* @throws {$protobuf.util.ProtocolError} If required fields are missing
|
|
*/
|
|
TensorProto.decode = function decode(reader, length) {
|
|
if (!(reader instanceof $Reader))
|
|
reader = $Reader.create(reader);
|
|
var end = length === undefined ? reader.len : reader.pos + length, message = new $root.onnx.TensorProto();
|
|
while (reader.pos < end) {
|
|
var tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1: {
|
|
if (!(message.dims && message.dims.length))
|
|
message.dims = [];
|
|
if ((tag & 7) === 2) {
|
|
var end2 = reader.uint32() + reader.pos;
|
|
while (reader.pos < end2)
|
|
message.dims.push(reader.int64());
|
|
} else
|
|
message.dims.push(reader.int64());
|
|
break;
|
|
}
|
|
case 2: {
|
|
message.dataType = reader.int32();
|
|
break;
|
|
}
|
|
case 3: {
|
|
message.segment = $root.onnx.TensorProto.Segment.decode(reader, reader.uint32());
|
|
break;
|
|
}
|
|
case 4: {
|
|
if (!(message.floatData && message.floatData.length))
|
|
message.floatData = [];
|
|
if ((tag & 7) === 2) {
|
|
var end2 = reader.uint32() + reader.pos;
|
|
while (reader.pos < end2)
|
|
message.floatData.push(reader.float());
|
|
} else
|
|
message.floatData.push(reader.float());
|
|
break;
|
|
}
|
|
case 5: {
|
|
if (!(message.int32Data && message.int32Data.length))
|
|
message.int32Data = [];
|
|
if ((tag & 7) === 2) {
|
|
var end2 = reader.uint32() + reader.pos;
|
|
while (reader.pos < end2)
|
|
message.int32Data.push(reader.int32());
|
|
} else
|
|
message.int32Data.push(reader.int32());
|
|
break;
|
|
}
|
|
case 6: {
|
|
if (!(message.stringData && message.stringData.length))
|
|
message.stringData = [];
|
|
message.stringData.push(reader.bytes());
|
|
break;
|
|
}
|
|
case 7: {
|
|
if (!(message.int64Data && message.int64Data.length))
|
|
message.int64Data = [];
|
|
if ((tag & 7) === 2) {
|
|
var end2 = reader.uint32() + reader.pos;
|
|
while (reader.pos < end2)
|
|
message.int64Data.push(reader.int64());
|
|
} else
|
|
message.int64Data.push(reader.int64());
|
|
break;
|
|
}
|
|
case 8: {
|
|
message.name = reader.string();
|
|
break;
|
|
}
|
|
case 12: {
|
|
message.docString = reader.string();
|
|
break;
|
|
}
|
|
case 9: {
|
|
message.rawData = reader.bytes();
|
|
break;
|
|
}
|
|
case 13: {
|
|
if (!(message.externalData && message.externalData.length))
|
|
message.externalData = [];
|
|
message.externalData.push($root.onnx.StringStringEntryProto.decode(reader, reader.uint32()));
|
|
break;
|
|
}
|
|
case 14: {
|
|
message.dataLocation = reader.int32();
|
|
break;
|
|
}
|
|
case 10: {
|
|
if (!(message.doubleData && message.doubleData.length))
|
|
message.doubleData = [];
|
|
if ((tag & 7) === 2) {
|
|
var end2 = reader.uint32() + reader.pos;
|
|
while (reader.pos < end2)
|
|
message.doubleData.push(reader.double());
|
|
} else
|
|
message.doubleData.push(reader.double());
|
|
break;
|
|
}
|
|
case 11: {
|
|
if (!(message.uint64Data && message.uint64Data.length))
|
|
message.uint64Data = [];
|
|
if ((tag & 7) === 2) {
|
|
var end2 = reader.uint32() + reader.pos;
|
|
while (reader.pos < end2)
|
|
message.uint64Data.push(reader.uint64());
|
|
} else
|
|
message.uint64Data.push(reader.uint64());
|
|
break;
|
|
}
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
};
|
|
|
|
/**
|
|
* Decodes a TensorProto message from the specified reader or buffer, length delimited.
|
|
* @function decodeDelimited
|
|
* @memberof onnx.TensorProto
|
|
* @static
|
|
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
|
|
* @returns {onnx.TensorProto} TensorProto
|
|
* @throws {Error} If the payload is not a reader or valid buffer
|
|
* @throws {$protobuf.util.ProtocolError} If required fields are missing
|
|
*/
|
|
TensorProto.decodeDelimited = function decodeDelimited(reader) {
|
|
if (!(reader instanceof $Reader))
|
|
reader = new $Reader(reader);
|
|
return this.decode(reader, reader.uint32());
|
|
};
|
|
|
|
/**
|
|
* Verifies a TensorProto message.
|
|
* @function verify
|
|
* @memberof onnx.TensorProto
|
|
* @static
|
|
* @param {Object.<string,*>} message Plain object to verify
|
|
* @returns {string|null} `null` if valid, otherwise the reason why it is not
|
|
*/
|
|
TensorProto.verify = function verify(message) {
|
|
if (typeof message !== "object" || message === null)
|
|
return "object expected";
|
|
if (message.dims != null && message.hasOwnProperty("dims")) {
|
|
if (!Array.isArray(message.dims))
|
|
return "dims: array expected";
|
|
for (var i = 0; i < message.dims.length; ++i)
|
|
if (!$util.isInteger(message.dims[i]) && !(message.dims[i] && $util.isInteger(message.dims[i].low) && $util.isInteger(message.dims[i].high)))
|
|
return "dims: integer|Long[] expected";
|
|
}
|
|
if (message.dataType != null && message.hasOwnProperty("dataType"))
|
|
if (!$util.isInteger(message.dataType))
|
|
return "dataType: integer expected";
|
|
if (message.segment != null && message.hasOwnProperty("segment")) {
|
|
var error = $root.onnx.TensorProto.Segment.verify(message.segment);
|
|
if (error)
|
|
return "segment." + error;
|
|
}
|
|
if (message.floatData != null && message.hasOwnProperty("floatData")) {
|
|
if (!Array.isArray(message.floatData))
|
|
return "floatData: array expected";
|
|
for (var i = 0; i < message.floatData.length; ++i)
|
|
if (typeof message.floatData[i] !== "number")
|
|
return "floatData: number[] expected";
|
|
}
|
|
if (message.int32Data != null && message.hasOwnProperty("int32Data")) {
|
|
if (!Array.isArray(message.int32Data))
|
|
return "int32Data: array expected";
|
|
for (var i = 0; i < message.int32Data.length; ++i)
|
|
if (!$util.isInteger(message.int32Data[i]))
|
|
return "int32Data: integer[] expected";
|
|
}
|
|
if (message.stringData != null && message.hasOwnProperty("stringData")) {
|
|
if (!Array.isArray(message.stringData))
|
|
return "stringData: array expected";
|
|
for (var i = 0; i < message.stringData.length; ++i)
|
|
if (!(message.stringData[i] && typeof message.stringData[i].length === "number" || $util.isString(message.stringData[i])))
|
|
return "stringData: buffer[] expected";
|
|
}
|
|
if (message.int64Data != null && message.hasOwnProperty("int64Data")) {
|
|
if (!Array.isArray(message.int64Data))
|
|
return "int64Data: array expected";
|
|
for (var i = 0; i < message.int64Data.length; ++i)
|
|
if (!$util.isInteger(message.int64Data[i]) && !(message.int64Data[i] && $util.isInteger(message.int64Data[i].low) && $util.isInteger(message.int64Data[i].high)))
|
|
return "int64Data: integer|Long[] expected";
|
|
}
|
|
if (message.name != null && message.hasOwnProperty("name"))
|
|
if (!$util.isString(message.name))
|
|
return "name: string expected";
|
|
if (message.docString != null && message.hasOwnProperty("docString"))
|
|
if (!$util.isString(message.docString))
|
|
return "docString: string expected";
|
|
if (message.rawData != null && message.hasOwnProperty("rawData"))
|
|
if (!(message.rawData && typeof message.rawData.length === "number" || $util.isString(message.rawData)))
|
|
return "rawData: buffer expected";
|
|
if (message.externalData != null && message.hasOwnProperty("externalData")) {
|
|
if (!Array.isArray(message.externalData))
|
|
return "externalData: array expected";
|
|
for (var i = 0; i < message.externalData.length; ++i) {
|
|
var error = $root.onnx.StringStringEntryProto.verify(message.externalData[i]);
|
|
if (error)
|
|
return "externalData." + error;
|
|
}
|
|
}
|
|
if (message.dataLocation != null && message.hasOwnProperty("dataLocation"))
|
|
switch (message.dataLocation) {
|
|
default:
|
|
return "dataLocation: enum value expected";
|
|
case 0:
|
|
case 1:
|
|
break;
|
|
}
|
|
if (message.doubleData != null && message.hasOwnProperty("doubleData")) {
|
|
if (!Array.isArray(message.doubleData))
|
|
return "doubleData: array expected";
|
|
for (var i = 0; i < message.doubleData.length; ++i)
|
|
if (typeof message.doubleData[i] !== "number")
|
|
return "doubleData: number[] expected";
|
|
}
|
|
if (message.uint64Data != null && message.hasOwnProperty("uint64Data")) {
|
|
if (!Array.isArray(message.uint64Data))
|
|
return "uint64Data: array expected";
|
|
for (var i = 0; i < message.uint64Data.length; ++i)
|
|
if (!$util.isInteger(message.uint64Data[i]) && !(message.uint64Data[i] && $util.isInteger(message.uint64Data[i].low) && $util.isInteger(message.uint64Data[i].high)))
|
|
return "uint64Data: integer|Long[] expected";
|
|
}
|
|
return null;
|
|
};
|
|
|
|
/**
|
|
* Creates a TensorProto message from a plain object. Also converts values to their respective internal types.
|
|
* @function fromObject
|
|
* @memberof onnx.TensorProto
|
|
* @static
|
|
* @param {Object.<string,*>} object Plain object
|
|
* @returns {onnx.TensorProto} TensorProto
|
|
*/
|
|
TensorProto.fromObject = function fromObject(object) {
|
|
if (object instanceof $root.onnx.TensorProto)
|
|
return object;
|
|
var message = new $root.onnx.TensorProto();
|
|
if (object.dims) {
|
|
if (!Array.isArray(object.dims))
|
|
throw TypeError(".onnx.TensorProto.dims: array expected");
|
|
message.dims = [];
|
|
for (var i = 0; i < object.dims.length; ++i)
|
|
if ($util.Long)
|
|
(message.dims[i] = $util.Long.fromValue(object.dims[i])).unsigned = false;
|
|
else if (typeof object.dims[i] === "string")
|
|
message.dims[i] = parseInt(object.dims[i], 10);
|
|
else if (typeof object.dims[i] === "number")
|
|
message.dims[i] = object.dims[i];
|
|
else if (typeof object.dims[i] === "object")
|
|
message.dims[i] = new $util.LongBits(object.dims[i].low >>> 0, object.dims[i].high >>> 0).toNumber();
|
|
}
|
|
if (object.dataType != null)
|
|
message.dataType = object.dataType | 0;
|
|
if (object.segment != null) {
|
|
if (typeof object.segment !== "object")
|
|
throw TypeError(".onnx.TensorProto.segment: object expected");
|
|
message.segment = $root.onnx.TensorProto.Segment.fromObject(object.segment);
|
|
}
|
|
if (object.floatData) {
|
|
if (!Array.isArray(object.floatData))
|
|
throw TypeError(".onnx.TensorProto.floatData: array expected");
|
|
message.floatData = [];
|
|
for (var i = 0; i < object.floatData.length; ++i)
|
|
message.floatData[i] = Number(object.floatData[i]);
|
|
}
|
|
if (object.int32Data) {
|
|
if (!Array.isArray(object.int32Data))
|
|
throw TypeError(".onnx.TensorProto.int32Data: array expected");
|
|
message.int32Data = [];
|
|
for (var i = 0; i < object.int32Data.length; ++i)
|
|
message.int32Data[i] = object.int32Data[i] | 0;
|
|
}
|
|
if (object.stringData) {
|
|
if (!Array.isArray(object.stringData))
|
|
throw TypeError(".onnx.TensorProto.stringData: array expected");
|
|
message.stringData = [];
|
|
for (var i = 0; i < object.stringData.length; ++i)
|
|
if (typeof object.stringData[i] === "string")
|
|
$util.base64.decode(object.stringData[i], message.stringData[i] = $util.newBuffer($util.base64.length(object.stringData[i])), 0);
|
|
else if (object.stringData[i].length >= 0)
|
|
message.stringData[i] = object.stringData[i];
|
|
}
|
|
if (object.int64Data) {
|
|
if (!Array.isArray(object.int64Data))
|
|
throw TypeError(".onnx.TensorProto.int64Data: array expected");
|
|
message.int64Data = [];
|
|
for (var i = 0; i < object.int64Data.length; ++i)
|
|
if ($util.Long)
|
|
(message.int64Data[i] = $util.Long.fromValue(object.int64Data[i])).unsigned = false;
|
|
else if (typeof object.int64Data[i] === "string")
|
|
message.int64Data[i] = parseInt(object.int64Data[i], 10);
|
|
else if (typeof object.int64Data[i] === "number")
|
|
message.int64Data[i] = object.int64Data[i];
|
|
else if (typeof object.int64Data[i] === "object")
|
|
message.int64Data[i] = new $util.LongBits(object.int64Data[i].low >>> 0, object.int64Data[i].high >>> 0).toNumber();
|
|
}
|
|
if (object.name != null)
|
|
message.name = String(object.name);
|
|
if (object.docString != null)
|
|
message.docString = String(object.docString);
|
|
if (object.rawData != null)
|
|
if (typeof object.rawData === "string")
|
|
$util.base64.decode(object.rawData, message.rawData = $util.newBuffer($util.base64.length(object.rawData)), 0);
|
|
else if (object.rawData.length >= 0)
|
|
message.rawData = object.rawData;
|
|
if (object.externalData) {
|
|
if (!Array.isArray(object.externalData))
|
|
throw TypeError(".onnx.TensorProto.externalData: array expected");
|
|
message.externalData = [];
|
|
for (var i = 0; i < object.externalData.length; ++i) {
|
|
if (typeof object.externalData[i] !== "object")
|
|
throw TypeError(".onnx.TensorProto.externalData: object expected");
|
|
message.externalData[i] = $root.onnx.StringStringEntryProto.fromObject(object.externalData[i]);
|
|
}
|
|
}
|
|
switch (object.dataLocation) {
|
|
default:
|
|
if (typeof object.dataLocation === "number") {
|
|
message.dataLocation = object.dataLocation;
|
|
break;
|
|
}
|
|
break;
|
|
case "DEFAULT":
|
|
case 0:
|
|
message.dataLocation = 0;
|
|
break;
|
|
case "EXTERNAL":
|
|
case 1:
|
|
message.dataLocation = 1;
|
|
break;
|
|
}
|
|
if (object.doubleData) {
|
|
if (!Array.isArray(object.doubleData))
|
|
throw TypeError(".onnx.TensorProto.doubleData: array expected");
|
|
message.doubleData = [];
|
|
for (var i = 0; i < object.doubleData.length; ++i)
|
|
message.doubleData[i] = Number(object.doubleData[i]);
|
|
}
|
|
if (object.uint64Data) {
|
|
if (!Array.isArray(object.uint64Data))
|
|
throw TypeError(".onnx.TensorProto.uint64Data: array expected");
|
|
message.uint64Data = [];
|
|
for (var i = 0; i < object.uint64Data.length; ++i)
|
|
if ($util.Long)
|
|
(message.uint64Data[i] = $util.Long.fromValue(object.uint64Data[i])).unsigned = true;
|
|
else if (typeof object.uint64Data[i] === "string")
|
|
message.uint64Data[i] = parseInt(object.uint64Data[i], 10);
|
|
else if (typeof object.uint64Data[i] === "number")
|
|
message.uint64Data[i] = object.uint64Data[i];
|
|
else if (typeof object.uint64Data[i] === "object")
|
|
message.uint64Data[i] = new $util.LongBits(object.uint64Data[i].low >>> 0, object.uint64Data[i].high >>> 0).toNumber(true);
|
|
}
|
|
return message;
|
|
};
|
|
|
|
/**
|
|
* Creates a plain object from a TensorProto message. Also converts values to other types if specified.
|
|
* @function toObject
|
|
* @memberof onnx.TensorProto
|
|
* @static
|
|
* @param {onnx.TensorProto} message TensorProto
|
|
* @param {$protobuf.IConversionOptions} [options] Conversion options
|
|
* @returns {Object.<string,*>} Plain object
|
|
*/
|
|
TensorProto.toObject = function toObject(message, options) {
|
|
if (!options)
|
|
options = {};
|
|
var object = {};
|
|
if (options.arrays || options.defaults) {
|
|
object.dims = [];
|
|
object.floatData = [];
|
|
object.int32Data = [];
|
|
object.stringData = [];
|
|
object.int64Data = [];
|
|
object.doubleData = [];
|
|
object.uint64Data = [];
|
|
object.externalData = [];
|
|
}
|
|
if (options.defaults) {
|
|
object.dataType = 0;
|
|
object.segment = null;
|
|
object.name = "";
|
|
if (options.bytes === String)
|
|
object.rawData = "";
|
|
else {
|
|
object.rawData = [];
|
|
if (options.bytes !== Array)
|
|
object.rawData = $util.newBuffer(object.rawData);
|
|
}
|
|
object.docString = "";
|
|
object.dataLocation = options.enums === String ? "DEFAULT" : 0;
|
|
}
|
|
if (message.dims && message.dims.length) {
|
|
object.dims = [];
|
|
for (var j = 0; j < message.dims.length; ++j)
|
|
if (typeof message.dims[j] === "number")
|
|
object.dims[j] = options.longs === String ? String(message.dims[j]) : message.dims[j];
|
|
else
|
|
object.dims[j] = options.longs === String ? $util.Long.prototype.toString.call(message.dims[j]) : options.longs === Number ? new $util.LongBits(message.dims[j].low >>> 0, message.dims[j].high >>> 0).toNumber() : message.dims[j];
|
|
}
|
|
if (message.dataType != null && message.hasOwnProperty("dataType"))
|
|
object.dataType = message.dataType;
|
|
if (message.segment != null && message.hasOwnProperty("segment"))
|
|
object.segment = $root.onnx.TensorProto.Segment.toObject(message.segment, options);
|
|
if (message.floatData && message.floatData.length) {
|
|
object.floatData = [];
|
|
for (var j = 0; j < message.floatData.length; ++j)
|
|
object.floatData[j] = options.json && !isFinite(message.floatData[j]) ? String(message.floatData[j]) : message.floatData[j];
|
|
}
|
|
if (message.int32Data && message.int32Data.length) {
|
|
object.int32Data = [];
|
|
for (var j = 0; j < message.int32Data.length; ++j)
|
|
object.int32Data[j] = message.int32Data[j];
|
|
}
|
|
if (message.stringData && message.stringData.length) {
|
|
object.stringData = [];
|
|
for (var j = 0; j < message.stringData.length; ++j)
|
|
object.stringData[j] = options.bytes === String ? $util.base64.encode(message.stringData[j], 0, message.stringData[j].length) : options.bytes === Array ? Array.prototype.slice.call(message.stringData[j]) : message.stringData[j];
|
|
}
|
|
if (message.int64Data && message.int64Data.length) {
|
|
object.int64Data = [];
|
|
for (var j = 0; j < message.int64Data.length; ++j)
|
|
if (typeof message.int64Data[j] === "number")
|
|
object.int64Data[j] = options.longs === String ? String(message.int64Data[j]) : message.int64Data[j];
|
|
else
|
|
object.int64Data[j] = options.longs === String ? $util.Long.prototype.toString.call(message.int64Data[j]) : options.longs === Number ? new $util.LongBits(message.int64Data[j].low >>> 0, message.int64Data[j].high >>> 0).toNumber() : message.int64Data[j];
|
|
}
|
|
if (message.name != null && message.hasOwnProperty("name"))
|
|
object.name = message.name;
|
|
if (message.rawData != null && message.hasOwnProperty("rawData"))
|
|
object.rawData = options.bytes === String ? $util.base64.encode(message.rawData, 0, message.rawData.length) : options.bytes === Array ? Array.prototype.slice.call(message.rawData) : message.rawData;
|
|
if (message.doubleData && message.doubleData.length) {
|
|
object.doubleData = [];
|
|
for (var j = 0; j < message.doubleData.length; ++j)
|
|
object.doubleData[j] = options.json && !isFinite(message.doubleData[j]) ? String(message.doubleData[j]) : message.doubleData[j];
|
|
}
|
|
if (message.uint64Data && message.uint64Data.length) {
|
|
object.uint64Data = [];
|
|
for (var j = 0; j < message.uint64Data.length; ++j)
|
|
if (typeof message.uint64Data[j] === "number")
|
|
object.uint64Data[j] = options.longs === String ? String(message.uint64Data[j]) : message.uint64Data[j];
|
|
else
|
|
object.uint64Data[j] = options.longs === String ? $util.Long.prototype.toString.call(message.uint64Data[j]) : options.longs === Number ? new $util.LongBits(message.uint64Data[j].low >>> 0, message.uint64Data[j].high >>> 0).toNumber(true) : message.uint64Data[j];
|
|
}
|
|
if (message.docString != null && message.hasOwnProperty("docString"))
|
|
object.docString = message.docString;
|
|
if (message.externalData && message.externalData.length) {
|
|
object.externalData = [];
|
|
for (var j = 0; j < message.externalData.length; ++j)
|
|
object.externalData[j] = $root.onnx.StringStringEntryProto.toObject(message.externalData[j], options);
|
|
}
|
|
if (message.dataLocation != null && message.hasOwnProperty("dataLocation"))
|
|
object.dataLocation = options.enums === String ? $root.onnx.TensorProto.DataLocation[message.dataLocation] === undefined ? message.dataLocation : $root.onnx.TensorProto.DataLocation[message.dataLocation] : message.dataLocation;
|
|
return object;
|
|
};
|
|
|
|
/**
|
|
* Converts this TensorProto to JSON.
|
|
* @function toJSON
|
|
* @memberof onnx.TensorProto
|
|
* @instance
|
|
* @returns {Object.<string,*>} JSON object
|
|
*/
|
|
TensorProto.prototype.toJSON = function toJSON() {
|
|
return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
|
|
};
|
|
|
|
/**
|
|
* Gets the default type url for TensorProto
|
|
* @function getTypeUrl
|
|
* @memberof onnx.TensorProto
|
|
* @static
|
|
* @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
|
|
* @returns {string} The default type url
|
|
*/
|
|
TensorProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
|
|
if (typeUrlPrefix === undefined) {
|
|
typeUrlPrefix = "type.googleapis.com";
|
|
}
|
|
return typeUrlPrefix + "/onnx.TensorProto";
|
|
};
|
|
|
|
/**
|
|
* DataType enum.
|
|
* @name onnx.TensorProto.DataType
|
|
* @enum {number}
|
|
* @property {number} UNDEFINED=0 UNDEFINED value
|
|
* @property {number} FLOAT=1 FLOAT value
|
|
* @property {number} UINT8=2 UINT8 value
|
|
* @property {number} INT8=3 INT8 value
|
|
* @property {number} UINT16=4 UINT16 value
|
|
* @property {number} INT16=5 INT16 value
|
|
* @property {number} INT32=6 INT32 value
|
|
* @property {number} INT64=7 INT64 value
|
|
* @property {number} STRING=8 STRING value
|
|
* @property {number} BOOL=9 BOOL value
|
|
* @property {number} FLOAT16=10 FLOAT16 value
|
|
* @property {number} DOUBLE=11 DOUBLE value
|
|
* @property {number} UINT32=12 UINT32 value
|
|
* @property {number} UINT64=13 UINT64 value
|
|
* @property {number} COMPLEX64=14 COMPLEX64 value
|
|
* @property {number} COMPLEX128=15 COMPLEX128 value
|
|
* @property {number} BFLOAT16=16 BFLOAT16 value
|
|
* @property {number} FLOAT8E4M3FN=17 FLOAT8E4M3FN value
|
|
* @property {number} FLOAT8E4M3FNUZ=18 FLOAT8E4M3FNUZ value
|
|
* @property {number} FLOAT8E5M2=19 FLOAT8E5M2 value
|
|
* @property {number} FLOAT8E5M2FNUZ=20 FLOAT8E5M2FNUZ value
|
|
*/
|
|
TensorProto.DataType = (function() {
|
|
var valuesById = {}, values = Object.create(valuesById);
|
|
values[valuesById[0] = "UNDEFINED"] = 0;
|
|
values[valuesById[1] = "FLOAT"] = 1;
|
|
values[valuesById[2] = "UINT8"] = 2;
|
|
values[valuesById[3] = "INT8"] = 3;
|
|
values[valuesById[4] = "UINT16"] = 4;
|
|
values[valuesById[5] = "INT16"] = 5;
|
|
values[valuesById[6] = "INT32"] = 6;
|
|
values[valuesById[7] = "INT64"] = 7;
|
|
values[valuesById[8] = "STRING"] = 8;
|
|
values[valuesById[9] = "BOOL"] = 9;
|
|
values[valuesById[10] = "FLOAT16"] = 10;
|
|
values[valuesById[11] = "DOUBLE"] = 11;
|
|
values[valuesById[12] = "UINT32"] = 12;
|
|
values[valuesById[13] = "UINT64"] = 13;
|
|
values[valuesById[14] = "COMPLEX64"] = 14;
|
|
values[valuesById[15] = "COMPLEX128"] = 15;
|
|
values[valuesById[16] = "BFLOAT16"] = 16;
|
|
values[valuesById[17] = "FLOAT8E4M3FN"] = 17;
|
|
values[valuesById[18] = "FLOAT8E4M3FNUZ"] = 18;
|
|
values[valuesById[19] = "FLOAT8E5M2"] = 19;
|
|
values[valuesById[20] = "FLOAT8E5M2FNUZ"] = 20;
|
|
return values;
|
|
})();
|
|
|
|
TensorProto.Segment = (function() {
|
|
|
|
/**
|
|
* Properties of a Segment.
|
|
* @memberof onnx.TensorProto
|
|
* @interface ISegment
|
|
* @property {number|Long|null} [begin] Segment begin
|
|
* @property {number|Long|null} [end] Segment end
|
|
*/
|
|
|
|
/**
|
|
* Constructs a new Segment.
|
|
* @memberof onnx.TensorProto
|
|
* @classdesc Represents a Segment.
|
|
* @implements ISegment
|
|
* @constructor
|
|
* @param {onnx.TensorProto.ISegment=} [properties] Properties to set
|
|
*/
|
|
function Segment(properties) {
|
|
if (properties)
|
|
for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
|
|
if (properties[keys[i]] != null)
|
|
this[keys[i]] = properties[keys[i]];
|
|
}
|
|
|
|
/**
|
|
* Segment begin.
|
|
* @member {number|Long} begin
|
|
* @memberof onnx.TensorProto.Segment
|
|
* @instance
|
|
*/
|
|
Segment.prototype.begin = $util.Long ? $util.Long.fromBits(0,0,false) : 0;
|
|
|
|
/**
|
|
* Segment end.
|
|
* @member {number|Long} end
|
|
* @memberof onnx.TensorProto.Segment
|
|
* @instance
|
|
*/
|
|
Segment.prototype.end = $util.Long ? $util.Long.fromBits(0,0,false) : 0;
|
|
|
|
/**
|
|
* Creates a new Segment instance using the specified properties.
|
|
* @function create
|
|
* @memberof onnx.TensorProto.Segment
|
|
* @static
|
|
* @param {onnx.TensorProto.ISegment=} [properties] Properties to set
|
|
* @returns {onnx.TensorProto.Segment} Segment instance
|
|
*/
|
|
Segment.create = function create(properties) {
|
|
return new Segment(properties);
|
|
};
|
|
|
|
/**
|
|
* Encodes the specified Segment message. Does not implicitly {@link onnx.TensorProto.Segment.verify|verify} messages.
|
|
* @function encode
|
|
* @memberof onnx.TensorProto.Segment
|
|
* @static
|
|
* @param {onnx.TensorProto.ISegment} message Segment message or plain object to encode
|
|
* @param {$protobuf.Writer} [writer] Writer to encode to
|
|
* @returns {$protobuf.Writer} Writer
|
|
*/
|
|
Segment.encode = function encode(message, writer) {
|
|
if (!writer)
|
|
writer = $Writer.create();
|
|
if (message.begin != null && Object.hasOwnProperty.call(message, "begin"))
|
|
writer.uint32(/* id 1, wireType 0 =*/8).int64(message.begin);
|
|
if (message.end != null && Object.hasOwnProperty.call(message, "end"))
|
|
writer.uint32(/* id 2, wireType 0 =*/16).int64(message.end);
|
|
return writer;
|
|
};
|
|
|
|
/**
|
|
* Encodes the specified Segment message, length delimited. Does not implicitly {@link onnx.TensorProto.Segment.verify|verify} messages.
|
|
* @function encodeDelimited
|
|
* @memberof onnx.TensorProto.Segment
|
|
* @static
|
|
* @param {onnx.TensorProto.ISegment} message Segment message or plain object to encode
|
|
* @param {$protobuf.Writer} [writer] Writer to encode to
|
|
* @returns {$protobuf.Writer} Writer
|
|
*/
|
|
Segment.encodeDelimited = function encodeDelimited(message, writer) {
|
|
return this.encode(message, writer).ldelim();
|
|
};
|
|
|
|
/**
|
|
* Decodes a Segment message from the specified reader or buffer.
|
|
* @function decode
|
|
* @memberof onnx.TensorProto.Segment
|
|
* @static
|
|
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
|
|
* @param {number} [length] Message length if known beforehand
|
|
* @returns {onnx.TensorProto.Segment} Segment
|
|
* @throws {Error} If the payload is not a reader or valid buffer
|
|
* @throws {$protobuf.util.ProtocolError} If required fields are missing
|
|
*/
|
|
Segment.decode = function decode(reader, length) {
|
|
if (!(reader instanceof $Reader))
|
|
reader = $Reader.create(reader);
|
|
var end = length === undefined ? reader.len : reader.pos + length, message = new $root.onnx.TensorProto.Segment();
|
|
while (reader.pos < end) {
|
|
var 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;
|
|
};
|
|
|
|
/**
|
|
* Decodes a Segment message from the specified reader or buffer, length delimited.
|
|
* @function decodeDelimited
|
|
* @memberof onnx.TensorProto.Segment
|
|
* @static
|
|
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
|
|
* @returns {onnx.TensorProto.Segment} Segment
|
|
* @throws {Error} If the payload is not a reader or valid buffer
|
|
* @throws {$protobuf.util.ProtocolError} If required fields are missing
|
|
*/
|
|
Segment.decodeDelimited = function decodeDelimited(reader) {
|
|
if (!(reader instanceof $Reader))
|
|
reader = new $Reader(reader);
|
|
return this.decode(reader, reader.uint32());
|
|
};
|
|
|
|
/**
|
|
* Verifies a Segment message.
|
|
* @function verify
|
|
* @memberof onnx.TensorProto.Segment
|
|
* @static
|
|
* @param {Object.<string,*>} message Plain object to verify
|
|
* @returns {string|null} `null` if valid, otherwise the reason why it is not
|
|
*/
|
|
Segment.verify = function verify(message) {
|
|
if (typeof message !== "object" || message === null)
|
|
return "object expected";
|
|
if (message.begin != null && message.hasOwnProperty("begin"))
|
|
if (!$util.isInteger(message.begin) && !(message.begin && $util.isInteger(message.begin.low) && $util.isInteger(message.begin.high)))
|
|
return "begin: integer|Long expected";
|
|
if (message.end != null && message.hasOwnProperty("end"))
|
|
if (!$util.isInteger(message.end) && !(message.end && $util.isInteger(message.end.low) && $util.isInteger(message.end.high)))
|
|
return "end: integer|Long expected";
|
|
return null;
|
|
};
|
|
|
|
/**
|
|
* Creates a Segment message from a plain object. Also converts values to their respective internal types.
|
|
* @function fromObject
|
|
* @memberof onnx.TensorProto.Segment
|
|
* @static
|
|
* @param {Object.<string,*>} object Plain object
|
|
* @returns {onnx.TensorProto.Segment} Segment
|
|
*/
|
|
Segment.fromObject = function fromObject(object) {
|
|
if (object instanceof $root.onnx.TensorProto.Segment)
|
|
return object;
|
|
var message = new $root.onnx.TensorProto.Segment();
|
|
if (object.begin != null)
|
|
if ($util.Long)
|
|
(message.begin = $util.Long.fromValue(object.begin)).unsigned = false;
|
|
else if (typeof object.begin === "string")
|
|
message.begin = parseInt(object.begin, 10);
|
|
else if (typeof object.begin === "number")
|
|
message.begin = object.begin;
|
|
else if (typeof object.begin === "object")
|
|
message.begin = new $util.LongBits(object.begin.low >>> 0, object.begin.high >>> 0).toNumber();
|
|
if (object.end != null)
|
|
if ($util.Long)
|
|
(message.end = $util.Long.fromValue(object.end)).unsigned = false;
|
|
else if (typeof object.end === "string")
|
|
message.end = parseInt(object.end, 10);
|
|
else if (typeof object.end === "number")
|
|
message.end = object.end;
|
|
else if (typeof object.end === "object")
|
|
message.end = new $util.LongBits(object.end.low >>> 0, object.end.high >>> 0).toNumber();
|
|
return message;
|
|
};
|
|
|
|
/**
|
|
* Creates a plain object from a Segment message. Also converts values to other types if specified.
|
|
* @function toObject
|
|
* @memberof onnx.TensorProto.Segment
|
|
* @static
|
|
* @param {onnx.TensorProto.Segment} message Segment
|
|
* @param {$protobuf.IConversionOptions} [options] Conversion options
|
|
* @returns {Object.<string,*>} Plain object
|
|
*/
|
|
Segment.toObject = function toObject(message, options) {
|
|
if (!options)
|
|
options = {};
|
|
var object = {};
|
|
if (options.defaults) {
|
|
if ($util.Long) {
|
|
var long = new $util.Long(0, 0, false);
|
|
object.begin = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
|
|
} else
|
|
object.begin = options.longs === String ? "0" : 0;
|
|
if ($util.Long) {
|
|
var long = new $util.Long(0, 0, false);
|
|
object.end = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
|
|
} else
|
|
object.end = options.longs === String ? "0" : 0;
|
|
}
|
|
if (message.begin != null && message.hasOwnProperty("begin"))
|
|
if (typeof message.begin === "number")
|
|
object.begin = options.longs === String ? String(message.begin) : message.begin;
|
|
else
|
|
object.begin = options.longs === String ? $util.Long.prototype.toString.call(message.begin) : options.longs === Number ? new $util.LongBits(message.begin.low >>> 0, message.begin.high >>> 0).toNumber() : message.begin;
|
|
if (message.end != null && message.hasOwnProperty("end"))
|
|
if (typeof message.end === "number")
|
|
object.end = options.longs === String ? String(message.end) : message.end;
|
|
else
|
|
object.end = options.longs === String ? $util.Long.prototype.toString.call(message.end) : options.longs === Number ? new $util.LongBits(message.end.low >>> 0, message.end.high >>> 0).toNumber() : message.end;
|
|
return object;
|
|
};
|
|
|
|
/**
|
|
* Converts this Segment to JSON.
|
|
* @function toJSON
|
|
* @memberof onnx.TensorProto.Segment
|
|
* @instance
|
|
* @returns {Object.<string,*>} JSON object
|
|
*/
|
|
Segment.prototype.toJSON = function toJSON() {
|
|
return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
|
|
};
|
|
|
|
/**
|
|
* Gets the default type url for Segment
|
|
* @function getTypeUrl
|
|
* @memberof onnx.TensorProto.Segment
|
|
* @static
|
|
* @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
|
|
* @returns {string} The default type url
|
|
*/
|
|
Segment.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
|
|
if (typeUrlPrefix === undefined) {
|
|
typeUrlPrefix = "type.googleapis.com";
|
|
}
|
|
return typeUrlPrefix + "/onnx.TensorProto.Segment";
|
|
};
|
|
|
|
return Segment;
|
|
})();
|
|
|
|
/**
|
|
* DataLocation enum.
|
|
* @name onnx.TensorProto.DataLocation
|
|
* @enum {number}
|
|
* @property {number} DEFAULT=0 DEFAULT value
|
|
* @property {number} EXTERNAL=1 EXTERNAL value
|
|
*/
|
|
TensorProto.DataLocation = (function() {
|
|
var valuesById = {}, values = Object.create(valuesById);
|
|
values[valuesById[0] = "DEFAULT"] = 0;
|
|
values[valuesById[1] = "EXTERNAL"] = 1;
|
|
return values;
|
|
})();
|
|
|
|
return TensorProto;
|
|
})();
|
|
|
|
onnx.SparseTensorProto = (function() {
|
|
|
|
/**
|
|
* Properties of a SparseTensorProto.
|
|
* @memberof onnx
|
|
* @interface ISparseTensorProto
|
|
* @property {onnx.ITensorProto|null} [values] SparseTensorProto values
|
|
* @property {onnx.ITensorProto|null} [indices] SparseTensorProto indices
|
|
* @property {Array.<number|Long>|null} [dims] SparseTensorProto dims
|
|
*/
|
|
|
|
/**
|
|
* Constructs a new SparseTensorProto.
|
|
* @memberof onnx
|
|
* @classdesc Represents a SparseTensorProto.
|
|
* @implements ISparseTensorProto
|
|
* @constructor
|
|
* @param {onnx.ISparseTensorProto=} [properties] Properties to set
|
|
*/
|
|
function SparseTensorProto(properties) {
|
|
this.dims = [];
|
|
if (properties)
|
|
for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
|
|
if (properties[keys[i]] != null)
|
|
this[keys[i]] = properties[keys[i]];
|
|
}
|
|
|
|
/**
|
|
* SparseTensorProto values.
|
|
* @member {onnx.ITensorProto|null|undefined} values
|
|
* @memberof onnx.SparseTensorProto
|
|
* @instance
|
|
*/
|
|
SparseTensorProto.prototype.values = null;
|
|
|
|
/**
|
|
* SparseTensorProto indices.
|
|
* @member {onnx.ITensorProto|null|undefined} indices
|
|
* @memberof onnx.SparseTensorProto
|
|
* @instance
|
|
*/
|
|
SparseTensorProto.prototype.indices = null;
|
|
|
|
/**
|
|
* SparseTensorProto dims.
|
|
* @member {Array.<number|Long>} dims
|
|
* @memberof onnx.SparseTensorProto
|
|
* @instance
|
|
*/
|
|
SparseTensorProto.prototype.dims = $util.emptyArray;
|
|
|
|
/**
|
|
* Creates a new SparseTensorProto instance using the specified properties.
|
|
* @function create
|
|
* @memberof onnx.SparseTensorProto
|
|
* @static
|
|
* @param {onnx.ISparseTensorProto=} [properties] Properties to set
|
|
* @returns {onnx.SparseTensorProto} SparseTensorProto instance
|
|
*/
|
|
SparseTensorProto.create = function create(properties) {
|
|
return new SparseTensorProto(properties);
|
|
};
|
|
|
|
/**
|
|
* Encodes the specified SparseTensorProto message. Does not implicitly {@link onnx.SparseTensorProto.verify|verify} messages.
|
|
* @function encode
|
|
* @memberof onnx.SparseTensorProto
|
|
* @static
|
|
* @param {onnx.ISparseTensorProto} message SparseTensorProto message or plain object to encode
|
|
* @param {$protobuf.Writer} [writer] Writer to encode to
|
|
* @returns {$protobuf.Writer} Writer
|
|
*/
|
|
SparseTensorProto.encode = function encode(message, writer) {
|
|
if (!writer)
|
|
writer = $Writer.create();
|
|
if (message.values != null && Object.hasOwnProperty.call(message, "values"))
|
|
$root.onnx.TensorProto.encode(message.values, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
|
|
if (message.indices != null && Object.hasOwnProperty.call(message, "indices"))
|
|
$root.onnx.TensorProto.encode(message.indices, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();
|
|
if (message.dims != null && message.dims.length) {
|
|
writer.uint32(/* id 3, wireType 2 =*/26).fork();
|
|
for (var i = 0; i < message.dims.length; ++i)
|
|
writer.int64(message.dims[i]);
|
|
writer.ldelim();
|
|
}
|
|
return writer;
|
|
};
|
|
|
|
/**
|
|
* Encodes the specified SparseTensorProto message, length delimited. Does not implicitly {@link onnx.SparseTensorProto.verify|verify} messages.
|
|
* @function encodeDelimited
|
|
* @memberof onnx.SparseTensorProto
|
|
* @static
|
|
* @param {onnx.ISparseTensorProto} message SparseTensorProto message or plain object to encode
|
|
* @param {$protobuf.Writer} [writer] Writer to encode to
|
|
* @returns {$protobuf.Writer} Writer
|
|
*/
|
|
SparseTensorProto.encodeDelimited = function encodeDelimited(message, writer) {
|
|
return this.encode(message, writer).ldelim();
|
|
};
|
|
|
|
/**
|
|
* Decodes a SparseTensorProto message from the specified reader or buffer.
|
|
* @function decode
|
|
* @memberof onnx.SparseTensorProto
|
|
* @static
|
|
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
|
|
* @param {number} [length] Message length if known beforehand
|
|
* @returns {onnx.SparseTensorProto} SparseTensorProto
|
|
* @throws {Error} If the payload is not a reader or valid buffer
|
|
* @throws {$protobuf.util.ProtocolError} If required fields are missing
|
|
*/
|
|
SparseTensorProto.decode = function decode(reader, length) {
|
|
if (!(reader instanceof $Reader))
|
|
reader = $Reader.create(reader);
|
|
var end = length === undefined ? reader.len : reader.pos + length, message = new $root.onnx.SparseTensorProto();
|
|
while (reader.pos < end) {
|
|
var tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1: {
|
|
message.values = $root.onnx.TensorProto.decode(reader, reader.uint32());
|
|
break;
|
|
}
|
|
case 2: {
|
|
message.indices = $root.onnx.TensorProto.decode(reader, reader.uint32());
|
|
break;
|
|
}
|
|
case 3: {
|
|
if (!(message.dims && message.dims.length))
|
|
message.dims = [];
|
|
if ((tag & 7) === 2) {
|
|
var end2 = reader.uint32() + reader.pos;
|
|
while (reader.pos < end2)
|
|
message.dims.push(reader.int64());
|
|
} else
|
|
message.dims.push(reader.int64());
|
|
break;
|
|
}
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
};
|
|
|
|
/**
|
|
* Decodes a SparseTensorProto message from the specified reader or buffer, length delimited.
|
|
* @function decodeDelimited
|
|
* @memberof onnx.SparseTensorProto
|
|
* @static
|
|
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
|
|
* @returns {onnx.SparseTensorProto} SparseTensorProto
|
|
* @throws {Error} If the payload is not a reader or valid buffer
|
|
* @throws {$protobuf.util.ProtocolError} If required fields are missing
|
|
*/
|
|
SparseTensorProto.decodeDelimited = function decodeDelimited(reader) {
|
|
if (!(reader instanceof $Reader))
|
|
reader = new $Reader(reader);
|
|
return this.decode(reader, reader.uint32());
|
|
};
|
|
|
|
/**
|
|
* Verifies a SparseTensorProto message.
|
|
* @function verify
|
|
* @memberof onnx.SparseTensorProto
|
|
* @static
|
|
* @param {Object.<string,*>} message Plain object to verify
|
|
* @returns {string|null} `null` if valid, otherwise the reason why it is not
|
|
*/
|
|
SparseTensorProto.verify = function verify(message) {
|
|
if (typeof message !== "object" || message === null)
|
|
return "object expected";
|
|
if (message.values != null && message.hasOwnProperty("values")) {
|
|
var error = $root.onnx.TensorProto.verify(message.values);
|
|
if (error)
|
|
return "values." + error;
|
|
}
|
|
if (message.indices != null && message.hasOwnProperty("indices")) {
|
|
var error = $root.onnx.TensorProto.verify(message.indices);
|
|
if (error)
|
|
return "indices." + error;
|
|
}
|
|
if (message.dims != null && message.hasOwnProperty("dims")) {
|
|
if (!Array.isArray(message.dims))
|
|
return "dims: array expected";
|
|
for (var i = 0; i < message.dims.length; ++i)
|
|
if (!$util.isInteger(message.dims[i]) && !(message.dims[i] && $util.isInteger(message.dims[i].low) && $util.isInteger(message.dims[i].high)))
|
|
return "dims: integer|Long[] expected";
|
|
}
|
|
return null;
|
|
};
|
|
|
|
/**
|
|
* Creates a SparseTensorProto message from a plain object. Also converts values to their respective internal types.
|
|
* @function fromObject
|
|
* @memberof onnx.SparseTensorProto
|
|
* @static
|
|
* @param {Object.<string,*>} object Plain object
|
|
* @returns {onnx.SparseTensorProto} SparseTensorProto
|
|
*/
|
|
SparseTensorProto.fromObject = function fromObject(object) {
|
|
if (object instanceof $root.onnx.SparseTensorProto)
|
|
return object;
|
|
var message = new $root.onnx.SparseTensorProto();
|
|
if (object.values != null) {
|
|
if (typeof object.values !== "object")
|
|
throw TypeError(".onnx.SparseTensorProto.values: object expected");
|
|
message.values = $root.onnx.TensorProto.fromObject(object.values);
|
|
}
|
|
if (object.indices != null) {
|
|
if (typeof object.indices !== "object")
|
|
throw TypeError(".onnx.SparseTensorProto.indices: object expected");
|
|
message.indices = $root.onnx.TensorProto.fromObject(object.indices);
|
|
}
|
|
if (object.dims) {
|
|
if (!Array.isArray(object.dims))
|
|
throw TypeError(".onnx.SparseTensorProto.dims: array expected");
|
|
message.dims = [];
|
|
for (var i = 0; i < object.dims.length; ++i)
|
|
if ($util.Long)
|
|
(message.dims[i] = $util.Long.fromValue(object.dims[i])).unsigned = false;
|
|
else if (typeof object.dims[i] === "string")
|
|
message.dims[i] = parseInt(object.dims[i], 10);
|
|
else if (typeof object.dims[i] === "number")
|
|
message.dims[i] = object.dims[i];
|
|
else if (typeof object.dims[i] === "object")
|
|
message.dims[i] = new $util.LongBits(object.dims[i].low >>> 0, object.dims[i].high >>> 0).toNumber();
|
|
}
|
|
return message;
|
|
};
|
|
|
|
/**
|
|
* Creates a plain object from a SparseTensorProto message. Also converts values to other types if specified.
|
|
* @function toObject
|
|
* @memberof onnx.SparseTensorProto
|
|
* @static
|
|
* @param {onnx.SparseTensorProto} message SparseTensorProto
|
|
* @param {$protobuf.IConversionOptions} [options] Conversion options
|
|
* @returns {Object.<string,*>} Plain object
|
|
*/
|
|
SparseTensorProto.toObject = function toObject(message, options) {
|
|
if (!options)
|
|
options = {};
|
|
var object = {};
|
|
if (options.arrays || options.defaults)
|
|
object.dims = [];
|
|
if (options.defaults) {
|
|
object.values = null;
|
|
object.indices = null;
|
|
}
|
|
if (message.values != null && message.hasOwnProperty("values"))
|
|
object.values = $root.onnx.TensorProto.toObject(message.values, options);
|
|
if (message.indices != null && message.hasOwnProperty("indices"))
|
|
object.indices = $root.onnx.TensorProto.toObject(message.indices, options);
|
|
if (message.dims && message.dims.length) {
|
|
object.dims = [];
|
|
for (var j = 0; j < message.dims.length; ++j)
|
|
if (typeof message.dims[j] === "number")
|
|
object.dims[j] = options.longs === String ? String(message.dims[j]) : message.dims[j];
|
|
else
|
|
object.dims[j] = options.longs === String ? $util.Long.prototype.toString.call(message.dims[j]) : options.longs === Number ? new $util.LongBits(message.dims[j].low >>> 0, message.dims[j].high >>> 0).toNumber() : message.dims[j];
|
|
}
|
|
return object;
|
|
};
|
|
|
|
/**
|
|
* Converts this SparseTensorProto to JSON.
|
|
* @function toJSON
|
|
* @memberof onnx.SparseTensorProto
|
|
* @instance
|
|
* @returns {Object.<string,*>} JSON object
|
|
*/
|
|
SparseTensorProto.prototype.toJSON = function toJSON() {
|
|
return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
|
|
};
|
|
|
|
/**
|
|
* Gets the default type url for SparseTensorProto
|
|
* @function getTypeUrl
|
|
* @memberof onnx.SparseTensorProto
|
|
* @static
|
|
* @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
|
|
* @returns {string} The default type url
|
|
*/
|
|
SparseTensorProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
|
|
if (typeUrlPrefix === undefined) {
|
|
typeUrlPrefix = "type.googleapis.com";
|
|
}
|
|
return typeUrlPrefix + "/onnx.SparseTensorProto";
|
|
};
|
|
|
|
return SparseTensorProto;
|
|
})();
|
|
|
|
onnx.TensorShapeProto = (function() {
|
|
|
|
/**
|
|
* Properties of a TensorShapeProto.
|
|
* @memberof onnx
|
|
* @interface ITensorShapeProto
|
|
* @property {Array.<onnx.TensorShapeProto.IDimension>|null} [dim] TensorShapeProto dim
|
|
*/
|
|
|
|
/**
|
|
* Constructs a new TensorShapeProto.
|
|
* @memberof onnx
|
|
* @classdesc Represents a TensorShapeProto.
|
|
* @implements ITensorShapeProto
|
|
* @constructor
|
|
* @param {onnx.ITensorShapeProto=} [properties] Properties to set
|
|
*/
|
|
function TensorShapeProto(properties) {
|
|
this.dim = [];
|
|
if (properties)
|
|
for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
|
|
if (properties[keys[i]] != null)
|
|
this[keys[i]] = properties[keys[i]];
|
|
}
|
|
|
|
/**
|
|
* TensorShapeProto dim.
|
|
* @member {Array.<onnx.TensorShapeProto.IDimension>} dim
|
|
* @memberof onnx.TensorShapeProto
|
|
* @instance
|
|
*/
|
|
TensorShapeProto.prototype.dim = $util.emptyArray;
|
|
|
|
/**
|
|
* Creates a new TensorShapeProto instance using the specified properties.
|
|
* @function create
|
|
* @memberof onnx.TensorShapeProto
|
|
* @static
|
|
* @param {onnx.ITensorShapeProto=} [properties] Properties to set
|
|
* @returns {onnx.TensorShapeProto} TensorShapeProto instance
|
|
*/
|
|
TensorShapeProto.create = function create(properties) {
|
|
return new TensorShapeProto(properties);
|
|
};
|
|
|
|
/**
|
|
* Encodes the specified TensorShapeProto message. Does not implicitly {@link onnx.TensorShapeProto.verify|verify} messages.
|
|
* @function encode
|
|
* @memberof onnx.TensorShapeProto
|
|
* @static
|
|
* @param {onnx.ITensorShapeProto} message TensorShapeProto message or plain object to encode
|
|
* @param {$protobuf.Writer} [writer] Writer to encode to
|
|
* @returns {$protobuf.Writer} Writer
|
|
*/
|
|
TensorShapeProto.encode = function encode(message, writer) {
|
|
if (!writer)
|
|
writer = $Writer.create();
|
|
if (message.dim != null && message.dim.length)
|
|
for (var i = 0; i < message.dim.length; ++i)
|
|
$root.onnx.TensorShapeProto.Dimension.encode(message.dim[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
|
|
return writer;
|
|
};
|
|
|
|
/**
|
|
* Encodes the specified TensorShapeProto message, length delimited. Does not implicitly {@link onnx.TensorShapeProto.verify|verify} messages.
|
|
* @function encodeDelimited
|
|
* @memberof onnx.TensorShapeProto
|
|
* @static
|
|
* @param {onnx.ITensorShapeProto} message TensorShapeProto message or plain object to encode
|
|
* @param {$protobuf.Writer} [writer] Writer to encode to
|
|
* @returns {$protobuf.Writer} Writer
|
|
*/
|
|
TensorShapeProto.encodeDelimited = function encodeDelimited(message, writer) {
|
|
return this.encode(message, writer).ldelim();
|
|
};
|
|
|
|
/**
|
|
* Decodes a TensorShapeProto message from the specified reader or buffer.
|
|
* @function decode
|
|
* @memberof onnx.TensorShapeProto
|
|
* @static
|
|
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
|
|
* @param {number} [length] Message length if known beforehand
|
|
* @returns {onnx.TensorShapeProto} TensorShapeProto
|
|
* @throws {Error} If the payload is not a reader or valid buffer
|
|
* @throws {$protobuf.util.ProtocolError} If required fields are missing
|
|
*/
|
|
TensorShapeProto.decode = function decode(reader, length) {
|
|
if (!(reader instanceof $Reader))
|
|
reader = $Reader.create(reader);
|
|
var end = length === undefined ? reader.len : reader.pos + length, message = new $root.onnx.TensorShapeProto();
|
|
while (reader.pos < end) {
|
|
var tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1: {
|
|
if (!(message.dim && message.dim.length))
|
|
message.dim = [];
|
|
message.dim.push($root.onnx.TensorShapeProto.Dimension.decode(reader, reader.uint32()));
|
|
break;
|
|
}
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
};
|
|
|
|
/**
|
|
* Decodes a TensorShapeProto message from the specified reader or buffer, length delimited.
|
|
* @function decodeDelimited
|
|
* @memberof onnx.TensorShapeProto
|
|
* @static
|
|
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
|
|
* @returns {onnx.TensorShapeProto} TensorShapeProto
|
|
* @throws {Error} If the payload is not a reader or valid buffer
|
|
* @throws {$protobuf.util.ProtocolError} If required fields are missing
|
|
*/
|
|
TensorShapeProto.decodeDelimited = function decodeDelimited(reader) {
|
|
if (!(reader instanceof $Reader))
|
|
reader = new $Reader(reader);
|
|
return this.decode(reader, reader.uint32());
|
|
};
|
|
|
|
/**
|
|
* Verifies a TensorShapeProto message.
|
|
* @function verify
|
|
* @memberof onnx.TensorShapeProto
|
|
* @static
|
|
* @param {Object.<string,*>} message Plain object to verify
|
|
* @returns {string|null} `null` if valid, otherwise the reason why it is not
|
|
*/
|
|
TensorShapeProto.verify = function verify(message) {
|
|
if (typeof message !== "object" || message === null)
|
|
return "object expected";
|
|
if (message.dim != null && message.hasOwnProperty("dim")) {
|
|
if (!Array.isArray(message.dim))
|
|
return "dim: array expected";
|
|
for (var i = 0; i < message.dim.length; ++i) {
|
|
var error = $root.onnx.TensorShapeProto.Dimension.verify(message.dim[i]);
|
|
if (error)
|
|
return "dim." + error;
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
|
|
/**
|
|
* Creates a TensorShapeProto message from a plain object. Also converts values to their respective internal types.
|
|
* @function fromObject
|
|
* @memberof onnx.TensorShapeProto
|
|
* @static
|
|
* @param {Object.<string,*>} object Plain object
|
|
* @returns {onnx.TensorShapeProto} TensorShapeProto
|
|
*/
|
|
TensorShapeProto.fromObject = function fromObject(object) {
|
|
if (object instanceof $root.onnx.TensorShapeProto)
|
|
return object;
|
|
var message = new $root.onnx.TensorShapeProto();
|
|
if (object.dim) {
|
|
if (!Array.isArray(object.dim))
|
|
throw TypeError(".onnx.TensorShapeProto.dim: array expected");
|
|
message.dim = [];
|
|
for (var i = 0; i < object.dim.length; ++i) {
|
|
if (typeof object.dim[i] !== "object")
|
|
throw TypeError(".onnx.TensorShapeProto.dim: object expected");
|
|
message.dim[i] = $root.onnx.TensorShapeProto.Dimension.fromObject(object.dim[i]);
|
|
}
|
|
}
|
|
return message;
|
|
};
|
|
|
|
/**
|
|
* Creates a plain object from a TensorShapeProto message. Also converts values to other types if specified.
|
|
* @function toObject
|
|
* @memberof onnx.TensorShapeProto
|
|
* @static
|
|
* @param {onnx.TensorShapeProto} message TensorShapeProto
|
|
* @param {$protobuf.IConversionOptions} [options] Conversion options
|
|
* @returns {Object.<string,*>} Plain object
|
|
*/
|
|
TensorShapeProto.toObject = function toObject(message, options) {
|
|
if (!options)
|
|
options = {};
|
|
var object = {};
|
|
if (options.arrays || options.defaults)
|
|
object.dim = [];
|
|
if (message.dim && message.dim.length) {
|
|
object.dim = [];
|
|
for (var j = 0; j < message.dim.length; ++j)
|
|
object.dim[j] = $root.onnx.TensorShapeProto.Dimension.toObject(message.dim[j], options);
|
|
}
|
|
return object;
|
|
};
|
|
|
|
/**
|
|
* Converts this TensorShapeProto to JSON.
|
|
* @function toJSON
|
|
* @memberof onnx.TensorShapeProto
|
|
* @instance
|
|
* @returns {Object.<string,*>} JSON object
|
|
*/
|
|
TensorShapeProto.prototype.toJSON = function toJSON() {
|
|
return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
|
|
};
|
|
|
|
/**
|
|
* Gets the default type url for TensorShapeProto
|
|
* @function getTypeUrl
|
|
* @memberof onnx.TensorShapeProto
|
|
* @static
|
|
* @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
|
|
* @returns {string} The default type url
|
|
*/
|
|
TensorShapeProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
|
|
if (typeUrlPrefix === undefined) {
|
|
typeUrlPrefix = "type.googleapis.com";
|
|
}
|
|
return typeUrlPrefix + "/onnx.TensorShapeProto";
|
|
};
|
|
|
|
TensorShapeProto.Dimension = (function() {
|
|
|
|
/**
|
|
* Properties of a Dimension.
|
|
* @memberof onnx.TensorShapeProto
|
|
* @interface IDimension
|
|
* @property {number|Long|null} [dimValue] Dimension dimValue
|
|
* @property {string|null} [dimParam] Dimension dimParam
|
|
* @property {string|null} [denotation] Dimension denotation
|
|
*/
|
|
|
|
/**
|
|
* Constructs a new Dimension.
|
|
* @memberof onnx.TensorShapeProto
|
|
* @classdesc Represents a Dimension.
|
|
* @implements IDimension
|
|
* @constructor
|
|
* @param {onnx.TensorShapeProto.IDimension=} [properties] Properties to set
|
|
*/
|
|
function Dimension(properties) {
|
|
if (properties)
|
|
for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
|
|
if (properties[keys[i]] != null)
|
|
this[keys[i]] = properties[keys[i]];
|
|
}
|
|
|
|
/**
|
|
* Dimension dimValue.
|
|
* @member {number|Long|null|undefined} dimValue
|
|
* @memberof onnx.TensorShapeProto.Dimension
|
|
* @instance
|
|
*/
|
|
Dimension.prototype.dimValue = null;
|
|
|
|
/**
|
|
* Dimension dimParam.
|
|
* @member {string|null|undefined} dimParam
|
|
* @memberof onnx.TensorShapeProto.Dimension
|
|
* @instance
|
|
*/
|
|
Dimension.prototype.dimParam = null;
|
|
|
|
/**
|
|
* Dimension denotation.
|
|
* @member {string} denotation
|
|
* @memberof onnx.TensorShapeProto.Dimension
|
|
* @instance
|
|
*/
|
|
Dimension.prototype.denotation = "";
|
|
|
|
// OneOf field names bound to virtual getters and setters
|
|
var $oneOfFields;
|
|
|
|
/**
|
|
* Dimension value.
|
|
* @member {"dimValue"|"dimParam"|undefined} value
|
|
* @memberof onnx.TensorShapeProto.Dimension
|
|
* @instance
|
|
*/
|
|
Object.defineProperty(Dimension.prototype, "value", {
|
|
get: $util.oneOfGetter($oneOfFields = ["dimValue", "dimParam"]),
|
|
set: $util.oneOfSetter($oneOfFields)
|
|
});
|
|
|
|
/**
|
|
* Creates a new Dimension instance using the specified properties.
|
|
* @function create
|
|
* @memberof onnx.TensorShapeProto.Dimension
|
|
* @static
|
|
* @param {onnx.TensorShapeProto.IDimension=} [properties] Properties to set
|
|
* @returns {onnx.TensorShapeProto.Dimension} Dimension instance
|
|
*/
|
|
Dimension.create = function create(properties) {
|
|
return new Dimension(properties);
|
|
};
|
|
|
|
/**
|
|
* Encodes the specified Dimension message. Does not implicitly {@link onnx.TensorShapeProto.Dimension.verify|verify} messages.
|
|
* @function encode
|
|
* @memberof onnx.TensorShapeProto.Dimension
|
|
* @static
|
|
* @param {onnx.TensorShapeProto.IDimension} message Dimension message or plain object to encode
|
|
* @param {$protobuf.Writer} [writer] Writer to encode to
|
|
* @returns {$protobuf.Writer} Writer
|
|
*/
|
|
Dimension.encode = function encode(message, writer) {
|
|
if (!writer)
|
|
writer = $Writer.create();
|
|
if (message.dimValue != null && Object.hasOwnProperty.call(message, "dimValue"))
|
|
writer.uint32(/* id 1, wireType 0 =*/8).int64(message.dimValue);
|
|
if (message.dimParam != null && Object.hasOwnProperty.call(message, "dimParam"))
|
|
writer.uint32(/* id 2, wireType 2 =*/18).string(message.dimParam);
|
|
if (message.denotation != null && Object.hasOwnProperty.call(message, "denotation"))
|
|
writer.uint32(/* id 3, wireType 2 =*/26).string(message.denotation);
|
|
return writer;
|
|
};
|
|
|
|
/**
|
|
* Encodes the specified Dimension message, length delimited. Does not implicitly {@link onnx.TensorShapeProto.Dimension.verify|verify} messages.
|
|
* @function encodeDelimited
|
|
* @memberof onnx.TensorShapeProto.Dimension
|
|
* @static
|
|
* @param {onnx.TensorShapeProto.IDimension} message Dimension message or plain object to encode
|
|
* @param {$protobuf.Writer} [writer] Writer to encode to
|
|
* @returns {$protobuf.Writer} Writer
|
|
*/
|
|
Dimension.encodeDelimited = function encodeDelimited(message, writer) {
|
|
return this.encode(message, writer).ldelim();
|
|
};
|
|
|
|
/**
|
|
* Decodes a Dimension message from the specified reader or buffer.
|
|
* @function decode
|
|
* @memberof onnx.TensorShapeProto.Dimension
|
|
* @static
|
|
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
|
|
* @param {number} [length] Message length if known beforehand
|
|
* @returns {onnx.TensorShapeProto.Dimension} Dimension
|
|
* @throws {Error} If the payload is not a reader or valid buffer
|
|
* @throws {$protobuf.util.ProtocolError} If required fields are missing
|
|
*/
|
|
Dimension.decode = function decode(reader, length) {
|
|
if (!(reader instanceof $Reader))
|
|
reader = $Reader.create(reader);
|
|
var end = length === undefined ? reader.len : reader.pos + length, message = new $root.onnx.TensorShapeProto.Dimension();
|
|
while (reader.pos < end) {
|
|
var tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1: {
|
|
message.dimValue = reader.int64();
|
|
break;
|
|
}
|
|
case 2: {
|
|
message.dimParam = reader.string();
|
|
break;
|
|
}
|
|
case 3: {
|
|
message.denotation = reader.string();
|
|
break;
|
|
}
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
};
|
|
|
|
/**
|
|
* Decodes a Dimension message from the specified reader or buffer, length delimited.
|
|
* @function decodeDelimited
|
|
* @memberof onnx.TensorShapeProto.Dimension
|
|
* @static
|
|
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
|
|
* @returns {onnx.TensorShapeProto.Dimension} Dimension
|
|
* @throws {Error} If the payload is not a reader or valid buffer
|
|
* @throws {$protobuf.util.ProtocolError} If required fields are missing
|
|
*/
|
|
Dimension.decodeDelimited = function decodeDelimited(reader) {
|
|
if (!(reader instanceof $Reader))
|
|
reader = new $Reader(reader);
|
|
return this.decode(reader, reader.uint32());
|
|
};
|
|
|
|
/**
|
|
* Verifies a Dimension message.
|
|
* @function verify
|
|
* @memberof onnx.TensorShapeProto.Dimension
|
|
* @static
|
|
* @param {Object.<string,*>} message Plain object to verify
|
|
* @returns {string|null} `null` if valid, otherwise the reason why it is not
|
|
*/
|
|
Dimension.verify = function verify(message) {
|
|
if (typeof message !== "object" || message === null)
|
|
return "object expected";
|
|
var properties = {};
|
|
if (message.dimValue != null && message.hasOwnProperty("dimValue")) {
|
|
properties.value = 1;
|
|
if (!$util.isInteger(message.dimValue) && !(message.dimValue && $util.isInteger(message.dimValue.low) && $util.isInteger(message.dimValue.high)))
|
|
return "dimValue: integer|Long expected";
|
|
}
|
|
if (message.dimParam != null && message.hasOwnProperty("dimParam")) {
|
|
if (properties.value === 1)
|
|
return "value: multiple values";
|
|
properties.value = 1;
|
|
if (!$util.isString(message.dimParam))
|
|
return "dimParam: string expected";
|
|
}
|
|
if (message.denotation != null && message.hasOwnProperty("denotation"))
|
|
if (!$util.isString(message.denotation))
|
|
return "denotation: string expected";
|
|
return null;
|
|
};
|
|
|
|
/**
|
|
* Creates a Dimension message from a plain object. Also converts values to their respective internal types.
|
|
* @function fromObject
|
|
* @memberof onnx.TensorShapeProto.Dimension
|
|
* @static
|
|
* @param {Object.<string,*>} object Plain object
|
|
* @returns {onnx.TensorShapeProto.Dimension} Dimension
|
|
*/
|
|
Dimension.fromObject = function fromObject(object) {
|
|
if (object instanceof $root.onnx.TensorShapeProto.Dimension)
|
|
return object;
|
|
var message = new $root.onnx.TensorShapeProto.Dimension();
|
|
if (object.dimValue != null)
|
|
if ($util.Long)
|
|
(message.dimValue = $util.Long.fromValue(object.dimValue)).unsigned = false;
|
|
else if (typeof object.dimValue === "string")
|
|
message.dimValue = parseInt(object.dimValue, 10);
|
|
else if (typeof object.dimValue === "number")
|
|
message.dimValue = object.dimValue;
|
|
else if (typeof object.dimValue === "object")
|
|
message.dimValue = new $util.LongBits(object.dimValue.low >>> 0, object.dimValue.high >>> 0).toNumber();
|
|
if (object.dimParam != null)
|
|
message.dimParam = String(object.dimParam);
|
|
if (object.denotation != null)
|
|
message.denotation = String(object.denotation);
|
|
return message;
|
|
};
|
|
|
|
/**
|
|
* Creates a plain object from a Dimension message. Also converts values to other types if specified.
|
|
* @function toObject
|
|
* @memberof onnx.TensorShapeProto.Dimension
|
|
* @static
|
|
* @param {onnx.TensorShapeProto.Dimension} message Dimension
|
|
* @param {$protobuf.IConversionOptions} [options] Conversion options
|
|
* @returns {Object.<string,*>} Plain object
|
|
*/
|
|
Dimension.toObject = function toObject(message, options) {
|
|
if (!options)
|
|
options = {};
|
|
var object = {};
|
|
if (options.defaults)
|
|
object.denotation = "";
|
|
if (message.dimValue != null && message.hasOwnProperty("dimValue")) {
|
|
if (typeof message.dimValue === "number")
|
|
object.dimValue = options.longs === String ? String(message.dimValue) : message.dimValue;
|
|
else
|
|
object.dimValue = options.longs === String ? $util.Long.prototype.toString.call(message.dimValue) : options.longs === Number ? new $util.LongBits(message.dimValue.low >>> 0, message.dimValue.high >>> 0).toNumber() : message.dimValue;
|
|
if (options.oneofs)
|
|
object.value = "dimValue";
|
|
}
|
|
if (message.dimParam != null && message.hasOwnProperty("dimParam")) {
|
|
object.dimParam = message.dimParam;
|
|
if (options.oneofs)
|
|
object.value = "dimParam";
|
|
}
|
|
if (message.denotation != null && message.hasOwnProperty("denotation"))
|
|
object.denotation = message.denotation;
|
|
return object;
|
|
};
|
|
|
|
/**
|
|
* Converts this Dimension to JSON.
|
|
* @function toJSON
|
|
* @memberof onnx.TensorShapeProto.Dimension
|
|
* @instance
|
|
* @returns {Object.<string,*>} JSON object
|
|
*/
|
|
Dimension.prototype.toJSON = function toJSON() {
|
|
return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
|
|
};
|
|
|
|
/**
|
|
* Gets the default type url for Dimension
|
|
* @function getTypeUrl
|
|
* @memberof onnx.TensorShapeProto.Dimension
|
|
* @static
|
|
* @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
|
|
* @returns {string} The default type url
|
|
*/
|
|
Dimension.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
|
|
if (typeUrlPrefix === undefined) {
|
|
typeUrlPrefix = "type.googleapis.com";
|
|
}
|
|
return typeUrlPrefix + "/onnx.TensorShapeProto.Dimension";
|
|
};
|
|
|
|
return Dimension;
|
|
})();
|
|
|
|
return TensorShapeProto;
|
|
})();
|
|
|
|
onnx.TypeProto = (function() {
|
|
|
|
/**
|
|
* Properties of a TypeProto.
|
|
* @memberof onnx
|
|
* @interface ITypeProto
|
|
* @property {onnx.TypeProto.ITensor|null} [tensorType] TypeProto tensorType
|
|
* @property {onnx.TypeProto.ISequence|null} [sequenceType] TypeProto sequenceType
|
|
* @property {onnx.TypeProto.IMap|null} [mapType] TypeProto mapType
|
|
* @property {onnx.TypeProto.IOptional|null} [optionalType] TypeProto optionalType
|
|
* @property {onnx.TypeProto.ISparseTensor|null} [sparseTensorType] TypeProto sparseTensorType
|
|
* @property {string|null} [denotation] TypeProto denotation
|
|
*/
|
|
|
|
/**
|
|
* Constructs a new TypeProto.
|
|
* @memberof onnx
|
|
* @classdesc Represents a TypeProto.
|
|
* @implements ITypeProto
|
|
* @constructor
|
|
* @param {onnx.ITypeProto=} [properties] Properties to set
|
|
*/
|
|
function TypeProto(properties) {
|
|
if (properties)
|
|
for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
|
|
if (properties[keys[i]] != null)
|
|
this[keys[i]] = properties[keys[i]];
|
|
}
|
|
|
|
/**
|
|
* TypeProto tensorType.
|
|
* @member {onnx.TypeProto.ITensor|null|undefined} tensorType
|
|
* @memberof onnx.TypeProto
|
|
* @instance
|
|
*/
|
|
TypeProto.prototype.tensorType = null;
|
|
|
|
/**
|
|
* TypeProto sequenceType.
|
|
* @member {onnx.TypeProto.ISequence|null|undefined} sequenceType
|
|
* @memberof onnx.TypeProto
|
|
* @instance
|
|
*/
|
|
TypeProto.prototype.sequenceType = null;
|
|
|
|
/**
|
|
* TypeProto mapType.
|
|
* @member {onnx.TypeProto.IMap|null|undefined} mapType
|
|
* @memberof onnx.TypeProto
|
|
* @instance
|
|
*/
|
|
TypeProto.prototype.mapType = null;
|
|
|
|
/**
|
|
* TypeProto optionalType.
|
|
* @member {onnx.TypeProto.IOptional|null|undefined} optionalType
|
|
* @memberof onnx.TypeProto
|
|
* @instance
|
|
*/
|
|
TypeProto.prototype.optionalType = null;
|
|
|
|
/**
|
|
* TypeProto sparseTensorType.
|
|
* @member {onnx.TypeProto.ISparseTensor|null|undefined} sparseTensorType
|
|
* @memberof onnx.TypeProto
|
|
* @instance
|
|
*/
|
|
TypeProto.prototype.sparseTensorType = null;
|
|
|
|
/**
|
|
* TypeProto denotation.
|
|
* @member {string} denotation
|
|
* @memberof onnx.TypeProto
|
|
* @instance
|
|
*/
|
|
TypeProto.prototype.denotation = "";
|
|
|
|
// OneOf field names bound to virtual getters and setters
|
|
var $oneOfFields;
|
|
|
|
/**
|
|
* TypeProto value.
|
|
* @member {"tensorType"|"sequenceType"|"mapType"|"optionalType"|"sparseTensorType"|undefined} value
|
|
* @memberof onnx.TypeProto
|
|
* @instance
|
|
*/
|
|
Object.defineProperty(TypeProto.prototype, "value", {
|
|
get: $util.oneOfGetter($oneOfFields = ["tensorType", "sequenceType", "mapType", "optionalType", "sparseTensorType"]),
|
|
set: $util.oneOfSetter($oneOfFields)
|
|
});
|
|
|
|
/**
|
|
* Creates a new TypeProto instance using the specified properties.
|
|
* @function create
|
|
* @memberof onnx.TypeProto
|
|
* @static
|
|
* @param {onnx.ITypeProto=} [properties] Properties to set
|
|
* @returns {onnx.TypeProto} TypeProto instance
|
|
*/
|
|
TypeProto.create = function create(properties) {
|
|
return new TypeProto(properties);
|
|
};
|
|
|
|
/**
|
|
* Encodes the specified TypeProto message. Does not implicitly {@link onnx.TypeProto.verify|verify} messages.
|
|
* @function encode
|
|
* @memberof onnx.TypeProto
|
|
* @static
|
|
* @param {onnx.ITypeProto} message TypeProto message or plain object to encode
|
|
* @param {$protobuf.Writer} [writer] Writer to encode to
|
|
* @returns {$protobuf.Writer} Writer
|
|
*/
|
|
TypeProto.encode = function encode(message, writer) {
|
|
if (!writer)
|
|
writer = $Writer.create();
|
|
if (message.tensorType != null && Object.hasOwnProperty.call(message, "tensorType"))
|
|
$root.onnx.TypeProto.Tensor.encode(message.tensorType, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
|
|
if (message.sequenceType != null && Object.hasOwnProperty.call(message, "sequenceType"))
|
|
$root.onnx.TypeProto.Sequence.encode(message.sequenceType, writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim();
|
|
if (message.mapType != null && Object.hasOwnProperty.call(message, "mapType"))
|
|
$root.onnx.TypeProto.Map.encode(message.mapType, writer.uint32(/* id 5, wireType 2 =*/42).fork()).ldelim();
|
|
if (message.denotation != null && Object.hasOwnProperty.call(message, "denotation"))
|
|
writer.uint32(/* id 6, wireType 2 =*/50).string(message.denotation);
|
|
if (message.sparseTensorType != null && Object.hasOwnProperty.call(message, "sparseTensorType"))
|
|
$root.onnx.TypeProto.SparseTensor.encode(message.sparseTensorType, writer.uint32(/* id 8, wireType 2 =*/66).fork()).ldelim();
|
|
if (message.optionalType != null && Object.hasOwnProperty.call(message, "optionalType"))
|
|
$root.onnx.TypeProto.Optional.encode(message.optionalType, writer.uint32(/* id 9, wireType 2 =*/74).fork()).ldelim();
|
|
return writer;
|
|
};
|
|
|
|
/**
|
|
* Encodes the specified TypeProto message, length delimited. Does not implicitly {@link onnx.TypeProto.verify|verify} messages.
|
|
* @function encodeDelimited
|
|
* @memberof onnx.TypeProto
|
|
* @static
|
|
* @param {onnx.ITypeProto} message TypeProto message or plain object to encode
|
|
* @param {$protobuf.Writer} [writer] Writer to encode to
|
|
* @returns {$protobuf.Writer} Writer
|
|
*/
|
|
TypeProto.encodeDelimited = function encodeDelimited(message, writer) {
|
|
return this.encode(message, writer).ldelim();
|
|
};
|
|
|
|
/**
|
|
* Decodes a TypeProto message from the specified reader or buffer.
|
|
* @function decode
|
|
* @memberof onnx.TypeProto
|
|
* @static
|
|
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
|
|
* @param {number} [length] Message length if known beforehand
|
|
* @returns {onnx.TypeProto} TypeProto
|
|
* @throws {Error} If the payload is not a reader or valid buffer
|
|
* @throws {$protobuf.util.ProtocolError} If required fields are missing
|
|
*/
|
|
TypeProto.decode = function decode(reader, length) {
|
|
if (!(reader instanceof $Reader))
|
|
reader = $Reader.create(reader);
|
|
var end = length === undefined ? reader.len : reader.pos + length, message = new $root.onnx.TypeProto();
|
|
while (reader.pos < end) {
|
|
var tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1: {
|
|
message.tensorType = $root.onnx.TypeProto.Tensor.decode(reader, reader.uint32());
|
|
break;
|
|
}
|
|
case 4: {
|
|
message.sequenceType = $root.onnx.TypeProto.Sequence.decode(reader, reader.uint32());
|
|
break;
|
|
}
|
|
case 5: {
|
|
message.mapType = $root.onnx.TypeProto.Map.decode(reader, reader.uint32());
|
|
break;
|
|
}
|
|
case 9: {
|
|
message.optionalType = $root.onnx.TypeProto.Optional.decode(reader, reader.uint32());
|
|
break;
|
|
}
|
|
case 8: {
|
|
message.sparseTensorType = $root.onnx.TypeProto.SparseTensor.decode(reader, reader.uint32());
|
|
break;
|
|
}
|
|
case 6: {
|
|
message.denotation = reader.string();
|
|
break;
|
|
}
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
};
|
|
|
|
/**
|
|
* Decodes a TypeProto message from the specified reader or buffer, length delimited.
|
|
* @function decodeDelimited
|
|
* @memberof onnx.TypeProto
|
|
* @static
|
|
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
|
|
* @returns {onnx.TypeProto} TypeProto
|
|
* @throws {Error} If the payload is not a reader or valid buffer
|
|
* @throws {$protobuf.util.ProtocolError} If required fields are missing
|
|
*/
|
|
TypeProto.decodeDelimited = function decodeDelimited(reader) {
|
|
if (!(reader instanceof $Reader))
|
|
reader = new $Reader(reader);
|
|
return this.decode(reader, reader.uint32());
|
|
};
|
|
|
|
/**
|
|
* Verifies a TypeProto message.
|
|
* @function verify
|
|
* @memberof onnx.TypeProto
|
|
* @static
|
|
* @param {Object.<string,*>} message Plain object to verify
|
|
* @returns {string|null} `null` if valid, otherwise the reason why it is not
|
|
*/
|
|
TypeProto.verify = function verify(message) {
|
|
if (typeof message !== "object" || message === null)
|
|
return "object expected";
|
|
var properties = {};
|
|
if (message.tensorType != null && message.hasOwnProperty("tensorType")) {
|
|
properties.value = 1;
|
|
{
|
|
var error = $root.onnx.TypeProto.Tensor.verify(message.tensorType);
|
|
if (error)
|
|
return "tensorType." + error;
|
|
}
|
|
}
|
|
if (message.sequenceType != null && message.hasOwnProperty("sequenceType")) {
|
|
if (properties.value === 1)
|
|
return "value: multiple values";
|
|
properties.value = 1;
|
|
{
|
|
var error = $root.onnx.TypeProto.Sequence.verify(message.sequenceType);
|
|
if (error)
|
|
return "sequenceType." + error;
|
|
}
|
|
}
|
|
if (message.mapType != null && message.hasOwnProperty("mapType")) {
|
|
if (properties.value === 1)
|
|
return "value: multiple values";
|
|
properties.value = 1;
|
|
{
|
|
var error = $root.onnx.TypeProto.Map.verify(message.mapType);
|
|
if (error)
|
|
return "mapType." + error;
|
|
}
|
|
}
|
|
if (message.optionalType != null && message.hasOwnProperty("optionalType")) {
|
|
if (properties.value === 1)
|
|
return "value: multiple values";
|
|
properties.value = 1;
|
|
{
|
|
var error = $root.onnx.TypeProto.Optional.verify(message.optionalType);
|
|
if (error)
|
|
return "optionalType." + error;
|
|
}
|
|
}
|
|
if (message.sparseTensorType != null && message.hasOwnProperty("sparseTensorType")) {
|
|
if (properties.value === 1)
|
|
return "value: multiple values";
|
|
properties.value = 1;
|
|
{
|
|
var error = $root.onnx.TypeProto.SparseTensor.verify(message.sparseTensorType);
|
|
if (error)
|
|
return "sparseTensorType." + error;
|
|
}
|
|
}
|
|
if (message.denotation != null && message.hasOwnProperty("denotation"))
|
|
if (!$util.isString(message.denotation))
|
|
return "denotation: string expected";
|
|
return null;
|
|
};
|
|
|
|
/**
|
|
* Creates a TypeProto message from a plain object. Also converts values to their respective internal types.
|
|
* @function fromObject
|
|
* @memberof onnx.TypeProto
|
|
* @static
|
|
* @param {Object.<string,*>} object Plain object
|
|
* @returns {onnx.TypeProto} TypeProto
|
|
*/
|
|
TypeProto.fromObject = function fromObject(object) {
|
|
if (object instanceof $root.onnx.TypeProto)
|
|
return object;
|
|
var message = new $root.onnx.TypeProto();
|
|
if (object.tensorType != null) {
|
|
if (typeof object.tensorType !== "object")
|
|
throw TypeError(".onnx.TypeProto.tensorType: object expected");
|
|
message.tensorType = $root.onnx.TypeProto.Tensor.fromObject(object.tensorType);
|
|
}
|
|
if (object.sequenceType != null) {
|
|
if (typeof object.sequenceType !== "object")
|
|
throw TypeError(".onnx.TypeProto.sequenceType: object expected");
|
|
message.sequenceType = $root.onnx.TypeProto.Sequence.fromObject(object.sequenceType);
|
|
}
|
|
if (object.mapType != null) {
|
|
if (typeof object.mapType !== "object")
|
|
throw TypeError(".onnx.TypeProto.mapType: object expected");
|
|
message.mapType = $root.onnx.TypeProto.Map.fromObject(object.mapType);
|
|
}
|
|
if (object.optionalType != null) {
|
|
if (typeof object.optionalType !== "object")
|
|
throw TypeError(".onnx.TypeProto.optionalType: object expected");
|
|
message.optionalType = $root.onnx.TypeProto.Optional.fromObject(object.optionalType);
|
|
}
|
|
if (object.sparseTensorType != null) {
|
|
if (typeof object.sparseTensorType !== "object")
|
|
throw TypeError(".onnx.TypeProto.sparseTensorType: object expected");
|
|
message.sparseTensorType = $root.onnx.TypeProto.SparseTensor.fromObject(object.sparseTensorType);
|
|
}
|
|
if (object.denotation != null)
|
|
message.denotation = String(object.denotation);
|
|
return message;
|
|
};
|
|
|
|
/**
|
|
* Creates a plain object from a TypeProto message. Also converts values to other types if specified.
|
|
* @function toObject
|
|
* @memberof onnx.TypeProto
|
|
* @static
|
|
* @param {onnx.TypeProto} message TypeProto
|
|
* @param {$protobuf.IConversionOptions} [options] Conversion options
|
|
* @returns {Object.<string,*>} Plain object
|
|
*/
|
|
TypeProto.toObject = function toObject(message, options) {
|
|
if (!options)
|
|
options = {};
|
|
var object = {};
|
|
if (options.defaults)
|
|
object.denotation = "";
|
|
if (message.tensorType != null && message.hasOwnProperty("tensorType")) {
|
|
object.tensorType = $root.onnx.TypeProto.Tensor.toObject(message.tensorType, options);
|
|
if (options.oneofs)
|
|
object.value = "tensorType";
|
|
}
|
|
if (message.sequenceType != null && message.hasOwnProperty("sequenceType")) {
|
|
object.sequenceType = $root.onnx.TypeProto.Sequence.toObject(message.sequenceType, options);
|
|
if (options.oneofs)
|
|
object.value = "sequenceType";
|
|
}
|
|
if (message.mapType != null && message.hasOwnProperty("mapType")) {
|
|
object.mapType = $root.onnx.TypeProto.Map.toObject(message.mapType, options);
|
|
if (options.oneofs)
|
|
object.value = "mapType";
|
|
}
|
|
if (message.denotation != null && message.hasOwnProperty("denotation"))
|
|
object.denotation = message.denotation;
|
|
if (message.sparseTensorType != null && message.hasOwnProperty("sparseTensorType")) {
|
|
object.sparseTensorType = $root.onnx.TypeProto.SparseTensor.toObject(message.sparseTensorType, options);
|
|
if (options.oneofs)
|
|
object.value = "sparseTensorType";
|
|
}
|
|
if (message.optionalType != null && message.hasOwnProperty("optionalType")) {
|
|
object.optionalType = $root.onnx.TypeProto.Optional.toObject(message.optionalType, options);
|
|
if (options.oneofs)
|
|
object.value = "optionalType";
|
|
}
|
|
return object;
|
|
};
|
|
|
|
/**
|
|
* Converts this TypeProto to JSON.
|
|
* @function toJSON
|
|
* @memberof onnx.TypeProto
|
|
* @instance
|
|
* @returns {Object.<string,*>} JSON object
|
|
*/
|
|
TypeProto.prototype.toJSON = function toJSON() {
|
|
return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
|
|
};
|
|
|
|
/**
|
|
* Gets the default type url for TypeProto
|
|
* @function getTypeUrl
|
|
* @memberof onnx.TypeProto
|
|
* @static
|
|
* @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
|
|
* @returns {string} The default type url
|
|
*/
|
|
TypeProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
|
|
if (typeUrlPrefix === undefined) {
|
|
typeUrlPrefix = "type.googleapis.com";
|
|
}
|
|
return typeUrlPrefix + "/onnx.TypeProto";
|
|
};
|
|
|
|
TypeProto.Tensor = (function() {
|
|
|
|
/**
|
|
* Properties of a Tensor.
|
|
* @memberof onnx.TypeProto
|
|
* @interface ITensor
|
|
* @property {number|null} [elemType] Tensor elemType
|
|
* @property {onnx.ITensorShapeProto|null} [shape] Tensor shape
|
|
*/
|
|
|
|
/**
|
|
* Constructs a new Tensor.
|
|
* @memberof onnx.TypeProto
|
|
* @classdesc Represents a Tensor.
|
|
* @implements ITensor
|
|
* @constructor
|
|
* @param {onnx.TypeProto.ITensor=} [properties] Properties to set
|
|
*/
|
|
function Tensor(properties) {
|
|
if (properties)
|
|
for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
|
|
if (properties[keys[i]] != null)
|
|
this[keys[i]] = properties[keys[i]];
|
|
}
|
|
|
|
/**
|
|
* Tensor elemType.
|
|
* @member {number} elemType
|
|
* @memberof onnx.TypeProto.Tensor
|
|
* @instance
|
|
*/
|
|
Tensor.prototype.elemType = 0;
|
|
|
|
/**
|
|
* Tensor shape.
|
|
* @member {onnx.ITensorShapeProto|null|undefined} shape
|
|
* @memberof onnx.TypeProto.Tensor
|
|
* @instance
|
|
*/
|
|
Tensor.prototype.shape = null;
|
|
|
|
/**
|
|
* Creates a new Tensor instance using the specified properties.
|
|
* @function create
|
|
* @memberof onnx.TypeProto.Tensor
|
|
* @static
|
|
* @param {onnx.TypeProto.ITensor=} [properties] Properties to set
|
|
* @returns {onnx.TypeProto.Tensor} Tensor instance
|
|
*/
|
|
Tensor.create = function create(properties) {
|
|
return new Tensor(properties);
|
|
};
|
|
|
|
/**
|
|
* Encodes the specified Tensor message. Does not implicitly {@link onnx.TypeProto.Tensor.verify|verify} messages.
|
|
* @function encode
|
|
* @memberof onnx.TypeProto.Tensor
|
|
* @static
|
|
* @param {onnx.TypeProto.ITensor} message Tensor message or plain object to encode
|
|
* @param {$protobuf.Writer} [writer] Writer to encode to
|
|
* @returns {$protobuf.Writer} Writer
|
|
*/
|
|
Tensor.encode = function encode(message, writer) {
|
|
if (!writer)
|
|
writer = $Writer.create();
|
|
if (message.elemType != null && Object.hasOwnProperty.call(message, "elemType"))
|
|
writer.uint32(/* id 1, wireType 0 =*/8).int32(message.elemType);
|
|
if (message.shape != null && Object.hasOwnProperty.call(message, "shape"))
|
|
$root.onnx.TensorShapeProto.encode(message.shape, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();
|
|
return writer;
|
|
};
|
|
|
|
/**
|
|
* Encodes the specified Tensor message, length delimited. Does not implicitly {@link onnx.TypeProto.Tensor.verify|verify} messages.
|
|
* @function encodeDelimited
|
|
* @memberof onnx.TypeProto.Tensor
|
|
* @static
|
|
* @param {onnx.TypeProto.ITensor} message Tensor message or plain object to encode
|
|
* @param {$protobuf.Writer} [writer] Writer to encode to
|
|
* @returns {$protobuf.Writer} Writer
|
|
*/
|
|
Tensor.encodeDelimited = function encodeDelimited(message, writer) {
|
|
return this.encode(message, writer).ldelim();
|
|
};
|
|
|
|
/**
|
|
* Decodes a Tensor message from the specified reader or buffer.
|
|
* @function decode
|
|
* @memberof onnx.TypeProto.Tensor
|
|
* @static
|
|
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
|
|
* @param {number} [length] Message length if known beforehand
|
|
* @returns {onnx.TypeProto.Tensor} Tensor
|
|
* @throws {Error} If the payload is not a reader or valid buffer
|
|
* @throws {$protobuf.util.ProtocolError} If required fields are missing
|
|
*/
|
|
Tensor.decode = function decode(reader, length) {
|
|
if (!(reader instanceof $Reader))
|
|
reader = $Reader.create(reader);
|
|
var end = length === undefined ? reader.len : reader.pos + length, message = new $root.onnx.TypeProto.Tensor();
|
|
while (reader.pos < end) {
|
|
var tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1: {
|
|
message.elemType = reader.int32();
|
|
break;
|
|
}
|
|
case 2: {
|
|
message.shape = $root.onnx.TensorShapeProto.decode(reader, reader.uint32());
|
|
break;
|
|
}
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
};
|
|
|
|
/**
|
|
* Decodes a Tensor message from the specified reader or buffer, length delimited.
|
|
* @function decodeDelimited
|
|
* @memberof onnx.TypeProto.Tensor
|
|
* @static
|
|
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
|
|
* @returns {onnx.TypeProto.Tensor} Tensor
|
|
* @throws {Error} If the payload is not a reader or valid buffer
|
|
* @throws {$protobuf.util.ProtocolError} If required fields are missing
|
|
*/
|
|
Tensor.decodeDelimited = function decodeDelimited(reader) {
|
|
if (!(reader instanceof $Reader))
|
|
reader = new $Reader(reader);
|
|
return this.decode(reader, reader.uint32());
|
|
};
|
|
|
|
/**
|
|
* Verifies a Tensor message.
|
|
* @function verify
|
|
* @memberof onnx.TypeProto.Tensor
|
|
* @static
|
|
* @param {Object.<string,*>} message Plain object to verify
|
|
* @returns {string|null} `null` if valid, otherwise the reason why it is not
|
|
*/
|
|
Tensor.verify = function verify(message) {
|
|
if (typeof message !== "object" || message === null)
|
|
return "object expected";
|
|
if (message.elemType != null && message.hasOwnProperty("elemType"))
|
|
if (!$util.isInteger(message.elemType))
|
|
return "elemType: integer expected";
|
|
if (message.shape != null && message.hasOwnProperty("shape")) {
|
|
var error = $root.onnx.TensorShapeProto.verify(message.shape);
|
|
if (error)
|
|
return "shape." + error;
|
|
}
|
|
return null;
|
|
};
|
|
|
|
/**
|
|
* Creates a Tensor message from a plain object. Also converts values to their respective internal types.
|
|
* @function fromObject
|
|
* @memberof onnx.TypeProto.Tensor
|
|
* @static
|
|
* @param {Object.<string,*>} object Plain object
|
|
* @returns {onnx.TypeProto.Tensor} Tensor
|
|
*/
|
|
Tensor.fromObject = function fromObject(object) {
|
|
if (object instanceof $root.onnx.TypeProto.Tensor)
|
|
return object;
|
|
var message = new $root.onnx.TypeProto.Tensor();
|
|
if (object.elemType != null)
|
|
message.elemType = object.elemType | 0;
|
|
if (object.shape != null) {
|
|
if (typeof object.shape !== "object")
|
|
throw TypeError(".onnx.TypeProto.Tensor.shape: object expected");
|
|
message.shape = $root.onnx.TensorShapeProto.fromObject(object.shape);
|
|
}
|
|
return message;
|
|
};
|
|
|
|
/**
|
|
* Creates a plain object from a Tensor message. Also converts values to other types if specified.
|
|
* @function toObject
|
|
* @memberof onnx.TypeProto.Tensor
|
|
* @static
|
|
* @param {onnx.TypeProto.Tensor} message Tensor
|
|
* @param {$protobuf.IConversionOptions} [options] Conversion options
|
|
* @returns {Object.<string,*>} Plain object
|
|
*/
|
|
Tensor.toObject = function toObject(message, options) {
|
|
if (!options)
|
|
options = {};
|
|
var object = {};
|
|
if (options.defaults) {
|
|
object.elemType = 0;
|
|
object.shape = null;
|
|
}
|
|
if (message.elemType != null && message.hasOwnProperty("elemType"))
|
|
object.elemType = message.elemType;
|
|
if (message.shape != null && message.hasOwnProperty("shape"))
|
|
object.shape = $root.onnx.TensorShapeProto.toObject(message.shape, options);
|
|
return object;
|
|
};
|
|
|
|
/**
|
|
* Converts this Tensor to JSON.
|
|
* @function toJSON
|
|
* @memberof onnx.TypeProto.Tensor
|
|
* @instance
|
|
* @returns {Object.<string,*>} JSON object
|
|
*/
|
|
Tensor.prototype.toJSON = function toJSON() {
|
|
return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
|
|
};
|
|
|
|
/**
|
|
* Gets the default type url for Tensor
|
|
* @function getTypeUrl
|
|
* @memberof onnx.TypeProto.Tensor
|
|
* @static
|
|
* @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
|
|
* @returns {string} The default type url
|
|
*/
|
|
Tensor.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
|
|
if (typeUrlPrefix === undefined) {
|
|
typeUrlPrefix = "type.googleapis.com";
|
|
}
|
|
return typeUrlPrefix + "/onnx.TypeProto.Tensor";
|
|
};
|
|
|
|
return Tensor;
|
|
})();
|
|
|
|
TypeProto.Sequence = (function() {
|
|
|
|
/**
|
|
* Properties of a Sequence.
|
|
* @memberof onnx.TypeProto
|
|
* @interface ISequence
|
|
* @property {onnx.ITypeProto|null} [elemType] Sequence elemType
|
|
*/
|
|
|
|
/**
|
|
* Constructs a new Sequence.
|
|
* @memberof onnx.TypeProto
|
|
* @classdesc Represents a Sequence.
|
|
* @implements ISequence
|
|
* @constructor
|
|
* @param {onnx.TypeProto.ISequence=} [properties] Properties to set
|
|
*/
|
|
function Sequence(properties) {
|
|
if (properties)
|
|
for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
|
|
if (properties[keys[i]] != null)
|
|
this[keys[i]] = properties[keys[i]];
|
|
}
|
|
|
|
/**
|
|
* Sequence elemType.
|
|
* @member {onnx.ITypeProto|null|undefined} elemType
|
|
* @memberof onnx.TypeProto.Sequence
|
|
* @instance
|
|
*/
|
|
Sequence.prototype.elemType = null;
|
|
|
|
/**
|
|
* Creates a new Sequence instance using the specified properties.
|
|
* @function create
|
|
* @memberof onnx.TypeProto.Sequence
|
|
* @static
|
|
* @param {onnx.TypeProto.ISequence=} [properties] Properties to set
|
|
* @returns {onnx.TypeProto.Sequence} Sequence instance
|
|
*/
|
|
Sequence.create = function create(properties) {
|
|
return new Sequence(properties);
|
|
};
|
|
|
|
/**
|
|
* Encodes the specified Sequence message. Does not implicitly {@link onnx.TypeProto.Sequence.verify|verify} messages.
|
|
* @function encode
|
|
* @memberof onnx.TypeProto.Sequence
|
|
* @static
|
|
* @param {onnx.TypeProto.ISequence} message Sequence message or plain object to encode
|
|
* @param {$protobuf.Writer} [writer] Writer to encode to
|
|
* @returns {$protobuf.Writer} Writer
|
|
*/
|
|
Sequence.encode = function encode(message, writer) {
|
|
if (!writer)
|
|
writer = $Writer.create();
|
|
if (message.elemType != null && Object.hasOwnProperty.call(message, "elemType"))
|
|
$root.onnx.TypeProto.encode(message.elemType, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
|
|
return writer;
|
|
};
|
|
|
|
/**
|
|
* Encodes the specified Sequence message, length delimited. Does not implicitly {@link onnx.TypeProto.Sequence.verify|verify} messages.
|
|
* @function encodeDelimited
|
|
* @memberof onnx.TypeProto.Sequence
|
|
* @static
|
|
* @param {onnx.TypeProto.ISequence} message Sequence message or plain object to encode
|
|
* @param {$protobuf.Writer} [writer] Writer to encode to
|
|
* @returns {$protobuf.Writer} Writer
|
|
*/
|
|
Sequence.encodeDelimited = function encodeDelimited(message, writer) {
|
|
return this.encode(message, writer).ldelim();
|
|
};
|
|
|
|
/**
|
|
* Decodes a Sequence message from the specified reader or buffer.
|
|
* @function decode
|
|
* @memberof onnx.TypeProto.Sequence
|
|
* @static
|
|
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
|
|
* @param {number} [length] Message length if known beforehand
|
|
* @returns {onnx.TypeProto.Sequence} Sequence
|
|
* @throws {Error} If the payload is not a reader or valid buffer
|
|
* @throws {$protobuf.util.ProtocolError} If required fields are missing
|
|
*/
|
|
Sequence.decode = function decode(reader, length) {
|
|
if (!(reader instanceof $Reader))
|
|
reader = $Reader.create(reader);
|
|
var end = length === undefined ? reader.len : reader.pos + length, message = new $root.onnx.TypeProto.Sequence();
|
|
while (reader.pos < end) {
|
|
var tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1: {
|
|
message.elemType = $root.onnx.TypeProto.decode(reader, reader.uint32());
|
|
break;
|
|
}
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
};
|
|
|
|
/**
|
|
* Decodes a Sequence message from the specified reader or buffer, length delimited.
|
|
* @function decodeDelimited
|
|
* @memberof onnx.TypeProto.Sequence
|
|
* @static
|
|
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
|
|
* @returns {onnx.TypeProto.Sequence} Sequence
|
|
* @throws {Error} If the payload is not a reader or valid buffer
|
|
* @throws {$protobuf.util.ProtocolError} If required fields are missing
|
|
*/
|
|
Sequence.decodeDelimited = function decodeDelimited(reader) {
|
|
if (!(reader instanceof $Reader))
|
|
reader = new $Reader(reader);
|
|
return this.decode(reader, reader.uint32());
|
|
};
|
|
|
|
/**
|
|
* Verifies a Sequence message.
|
|
* @function verify
|
|
* @memberof onnx.TypeProto.Sequence
|
|
* @static
|
|
* @param {Object.<string,*>} message Plain object to verify
|
|
* @returns {string|null} `null` if valid, otherwise the reason why it is not
|
|
*/
|
|
Sequence.verify = function verify(message) {
|
|
if (typeof message !== "object" || message === null)
|
|
return "object expected";
|
|
if (message.elemType != null && message.hasOwnProperty("elemType")) {
|
|
var error = $root.onnx.TypeProto.verify(message.elemType);
|
|
if (error)
|
|
return "elemType." + error;
|
|
}
|
|
return null;
|
|
};
|
|
|
|
/**
|
|
* Creates a Sequence message from a plain object. Also converts values to their respective internal types.
|
|
* @function fromObject
|
|
* @memberof onnx.TypeProto.Sequence
|
|
* @static
|
|
* @param {Object.<string,*>} object Plain object
|
|
* @returns {onnx.TypeProto.Sequence} Sequence
|
|
*/
|
|
Sequence.fromObject = function fromObject(object) {
|
|
if (object instanceof $root.onnx.TypeProto.Sequence)
|
|
return object;
|
|
var message = new $root.onnx.TypeProto.Sequence();
|
|
if (object.elemType != null) {
|
|
if (typeof object.elemType !== "object")
|
|
throw TypeError(".onnx.TypeProto.Sequence.elemType: object expected");
|
|
message.elemType = $root.onnx.TypeProto.fromObject(object.elemType);
|
|
}
|
|
return message;
|
|
};
|
|
|
|
/**
|
|
* Creates a plain object from a Sequence message. Also converts values to other types if specified.
|
|
* @function toObject
|
|
* @memberof onnx.TypeProto.Sequence
|
|
* @static
|
|
* @param {onnx.TypeProto.Sequence} message Sequence
|
|
* @param {$protobuf.IConversionOptions} [options] Conversion options
|
|
* @returns {Object.<string,*>} Plain object
|
|
*/
|
|
Sequence.toObject = function toObject(message, options) {
|
|
if (!options)
|
|
options = {};
|
|
var object = {};
|
|
if (options.defaults)
|
|
object.elemType = null;
|
|
if (message.elemType != null && message.hasOwnProperty("elemType"))
|
|
object.elemType = $root.onnx.TypeProto.toObject(message.elemType, options);
|
|
return object;
|
|
};
|
|
|
|
/**
|
|
* Converts this Sequence to JSON.
|
|
* @function toJSON
|
|
* @memberof onnx.TypeProto.Sequence
|
|
* @instance
|
|
* @returns {Object.<string,*>} JSON object
|
|
*/
|
|
Sequence.prototype.toJSON = function toJSON() {
|
|
return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
|
|
};
|
|
|
|
/**
|
|
* Gets the default type url for Sequence
|
|
* @function getTypeUrl
|
|
* @memberof onnx.TypeProto.Sequence
|
|
* @static
|
|
* @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
|
|
* @returns {string} The default type url
|
|
*/
|
|
Sequence.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
|
|
if (typeUrlPrefix === undefined) {
|
|
typeUrlPrefix = "type.googleapis.com";
|
|
}
|
|
return typeUrlPrefix + "/onnx.TypeProto.Sequence";
|
|
};
|
|
|
|
return Sequence;
|
|
})();
|
|
|
|
TypeProto.Map = (function() {
|
|
|
|
/**
|
|
* Properties of a Map.
|
|
* @memberof onnx.TypeProto
|
|
* @interface IMap
|
|
* @property {number|null} [keyType] Map keyType
|
|
* @property {onnx.ITypeProto|null} [valueType] Map valueType
|
|
*/
|
|
|
|
/**
|
|
* Constructs a new Map.
|
|
* @memberof onnx.TypeProto
|
|
* @classdesc Represents a Map.
|
|
* @implements IMap
|
|
* @constructor
|
|
* @param {onnx.TypeProto.IMap=} [properties] Properties to set
|
|
*/
|
|
function Map(properties) {
|
|
if (properties)
|
|
for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
|
|
if (properties[keys[i]] != null)
|
|
this[keys[i]] = properties[keys[i]];
|
|
}
|
|
|
|
/**
|
|
* Map keyType.
|
|
* @member {number} keyType
|
|
* @memberof onnx.TypeProto.Map
|
|
* @instance
|
|
*/
|
|
Map.prototype.keyType = 0;
|
|
|
|
/**
|
|
* Map valueType.
|
|
* @member {onnx.ITypeProto|null|undefined} valueType
|
|
* @memberof onnx.TypeProto.Map
|
|
* @instance
|
|
*/
|
|
Map.prototype.valueType = null;
|
|
|
|
/**
|
|
* Creates a new Map instance using the specified properties.
|
|
* @function create
|
|
* @memberof onnx.TypeProto.Map
|
|
* @static
|
|
* @param {onnx.TypeProto.IMap=} [properties] Properties to set
|
|
* @returns {onnx.TypeProto.Map} Map instance
|
|
*/
|
|
Map.create = function create(properties) {
|
|
return new Map(properties);
|
|
};
|
|
|
|
/**
|
|
* Encodes the specified Map message. Does not implicitly {@link onnx.TypeProto.Map.verify|verify} messages.
|
|
* @function encode
|
|
* @memberof onnx.TypeProto.Map
|
|
* @static
|
|
* @param {onnx.TypeProto.IMap} message Map message or plain object to encode
|
|
* @param {$protobuf.Writer} [writer] Writer to encode to
|
|
* @returns {$protobuf.Writer} Writer
|
|
*/
|
|
Map.encode = function encode(message, writer) {
|
|
if (!writer)
|
|
writer = $Writer.create();
|
|
if (message.keyType != null && Object.hasOwnProperty.call(message, "keyType"))
|
|
writer.uint32(/* id 1, wireType 0 =*/8).int32(message.keyType);
|
|
if (message.valueType != null && Object.hasOwnProperty.call(message, "valueType"))
|
|
$root.onnx.TypeProto.encode(message.valueType, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();
|
|
return writer;
|
|
};
|
|
|
|
/**
|
|
* Encodes the specified Map message, length delimited. Does not implicitly {@link onnx.TypeProto.Map.verify|verify} messages.
|
|
* @function encodeDelimited
|
|
* @memberof onnx.TypeProto.Map
|
|
* @static
|
|
* @param {onnx.TypeProto.IMap} message Map message or plain object to encode
|
|
* @param {$protobuf.Writer} [writer] Writer to encode to
|
|
* @returns {$protobuf.Writer} Writer
|
|
*/
|
|
Map.encodeDelimited = function encodeDelimited(message, writer) {
|
|
return this.encode(message, writer).ldelim();
|
|
};
|
|
|
|
/**
|
|
* Decodes a Map message from the specified reader or buffer.
|
|
* @function decode
|
|
* @memberof onnx.TypeProto.Map
|
|
* @static
|
|
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
|
|
* @param {number} [length] Message length if known beforehand
|
|
* @returns {onnx.TypeProto.Map} Map
|
|
* @throws {Error} If the payload is not a reader or valid buffer
|
|
* @throws {$protobuf.util.ProtocolError} If required fields are missing
|
|
*/
|
|
Map.decode = function decode(reader, length) {
|
|
if (!(reader instanceof $Reader))
|
|
reader = $Reader.create(reader);
|
|
var end = length === undefined ? reader.len : reader.pos + length, message = new $root.onnx.TypeProto.Map();
|
|
while (reader.pos < end) {
|
|
var tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1: {
|
|
message.keyType = reader.int32();
|
|
break;
|
|
}
|
|
case 2: {
|
|
message.valueType = $root.onnx.TypeProto.decode(reader, reader.uint32());
|
|
break;
|
|
}
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
};
|
|
|
|
/**
|
|
* Decodes a Map message from the specified reader or buffer, length delimited.
|
|
* @function decodeDelimited
|
|
* @memberof onnx.TypeProto.Map
|
|
* @static
|
|
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
|
|
* @returns {onnx.TypeProto.Map} Map
|
|
* @throws {Error} If the payload is not a reader or valid buffer
|
|
* @throws {$protobuf.util.ProtocolError} If required fields are missing
|
|
*/
|
|
Map.decodeDelimited = function decodeDelimited(reader) {
|
|
if (!(reader instanceof $Reader))
|
|
reader = new $Reader(reader);
|
|
return this.decode(reader, reader.uint32());
|
|
};
|
|
|
|
/**
|
|
* Verifies a Map message.
|
|
* @function verify
|
|
* @memberof onnx.TypeProto.Map
|
|
* @static
|
|
* @param {Object.<string,*>} message Plain object to verify
|
|
* @returns {string|null} `null` if valid, otherwise the reason why it is not
|
|
*/
|
|
Map.verify = function verify(message) {
|
|
if (typeof message !== "object" || message === null)
|
|
return "object expected";
|
|
if (message.keyType != null && message.hasOwnProperty("keyType"))
|
|
if (!$util.isInteger(message.keyType))
|
|
return "keyType: integer expected";
|
|
if (message.valueType != null && message.hasOwnProperty("valueType")) {
|
|
var error = $root.onnx.TypeProto.verify(message.valueType);
|
|
if (error)
|
|
return "valueType." + error;
|
|
}
|
|
return null;
|
|
};
|
|
|
|
/**
|
|
* Creates a Map message from a plain object. Also converts values to their respective internal types.
|
|
* @function fromObject
|
|
* @memberof onnx.TypeProto.Map
|
|
* @static
|
|
* @param {Object.<string,*>} object Plain object
|
|
* @returns {onnx.TypeProto.Map} Map
|
|
*/
|
|
Map.fromObject = function fromObject(object) {
|
|
if (object instanceof $root.onnx.TypeProto.Map)
|
|
return object;
|
|
var message = new $root.onnx.TypeProto.Map();
|
|
if (object.keyType != null)
|
|
message.keyType = object.keyType | 0;
|
|
if (object.valueType != null) {
|
|
if (typeof object.valueType !== "object")
|
|
throw TypeError(".onnx.TypeProto.Map.valueType: object expected");
|
|
message.valueType = $root.onnx.TypeProto.fromObject(object.valueType);
|
|
}
|
|
return message;
|
|
};
|
|
|
|
/**
|
|
* Creates a plain object from a Map message. Also converts values to other types if specified.
|
|
* @function toObject
|
|
* @memberof onnx.TypeProto.Map
|
|
* @static
|
|
* @param {onnx.TypeProto.Map} message Map
|
|
* @param {$protobuf.IConversionOptions} [options] Conversion options
|
|
* @returns {Object.<string,*>} Plain object
|
|
*/
|
|
Map.toObject = function toObject(message, options) {
|
|
if (!options)
|
|
options = {};
|
|
var object = {};
|
|
if (options.defaults) {
|
|
object.keyType = 0;
|
|
object.valueType = null;
|
|
}
|
|
if (message.keyType != null && message.hasOwnProperty("keyType"))
|
|
object.keyType = message.keyType;
|
|
if (message.valueType != null && message.hasOwnProperty("valueType"))
|
|
object.valueType = $root.onnx.TypeProto.toObject(message.valueType, options);
|
|
return object;
|
|
};
|
|
|
|
/**
|
|
* Converts this Map to JSON.
|
|
* @function toJSON
|
|
* @memberof onnx.TypeProto.Map
|
|
* @instance
|
|
* @returns {Object.<string,*>} JSON object
|
|
*/
|
|
Map.prototype.toJSON = function toJSON() {
|
|
return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
|
|
};
|
|
|
|
/**
|
|
* Gets the default type url for Map
|
|
* @function getTypeUrl
|
|
* @memberof onnx.TypeProto.Map
|
|
* @static
|
|
* @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
|
|
* @returns {string} The default type url
|
|
*/
|
|
Map.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
|
|
if (typeUrlPrefix === undefined) {
|
|
typeUrlPrefix = "type.googleapis.com";
|
|
}
|
|
return typeUrlPrefix + "/onnx.TypeProto.Map";
|
|
};
|
|
|
|
return Map;
|
|
})();
|
|
|
|
TypeProto.Optional = (function() {
|
|
|
|
/**
|
|
* Properties of an Optional.
|
|
* @memberof onnx.TypeProto
|
|
* @interface IOptional
|
|
* @property {onnx.ITypeProto|null} [elemType] Optional elemType
|
|
*/
|
|
|
|
/**
|
|
* Constructs a new Optional.
|
|
* @memberof onnx.TypeProto
|
|
* @classdesc Represents an Optional.
|
|
* @implements IOptional
|
|
* @constructor
|
|
* @param {onnx.TypeProto.IOptional=} [properties] Properties to set
|
|
*/
|
|
function Optional(properties) {
|
|
if (properties)
|
|
for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
|
|
if (properties[keys[i]] != null)
|
|
this[keys[i]] = properties[keys[i]];
|
|
}
|
|
|
|
/**
|
|
* Optional elemType.
|
|
* @member {onnx.ITypeProto|null|undefined} elemType
|
|
* @memberof onnx.TypeProto.Optional
|
|
* @instance
|
|
*/
|
|
Optional.prototype.elemType = null;
|
|
|
|
/**
|
|
* Creates a new Optional instance using the specified properties.
|
|
* @function create
|
|
* @memberof onnx.TypeProto.Optional
|
|
* @static
|
|
* @param {onnx.TypeProto.IOptional=} [properties] Properties to set
|
|
* @returns {onnx.TypeProto.Optional} Optional instance
|
|
*/
|
|
Optional.create = function create(properties) {
|
|
return new Optional(properties);
|
|
};
|
|
|
|
/**
|
|
* Encodes the specified Optional message. Does not implicitly {@link onnx.TypeProto.Optional.verify|verify} messages.
|
|
* @function encode
|
|
* @memberof onnx.TypeProto.Optional
|
|
* @static
|
|
* @param {onnx.TypeProto.IOptional} message Optional message or plain object to encode
|
|
* @param {$protobuf.Writer} [writer] Writer to encode to
|
|
* @returns {$protobuf.Writer} Writer
|
|
*/
|
|
Optional.encode = function encode(message, writer) {
|
|
if (!writer)
|
|
writer = $Writer.create();
|
|
if (message.elemType != null && Object.hasOwnProperty.call(message, "elemType"))
|
|
$root.onnx.TypeProto.encode(message.elemType, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
|
|
return writer;
|
|
};
|
|
|
|
/**
|
|
* Encodes the specified Optional message, length delimited. Does not implicitly {@link onnx.TypeProto.Optional.verify|verify} messages.
|
|
* @function encodeDelimited
|
|
* @memberof onnx.TypeProto.Optional
|
|
* @static
|
|
* @param {onnx.TypeProto.IOptional} message Optional message or plain object to encode
|
|
* @param {$protobuf.Writer} [writer] Writer to encode to
|
|
* @returns {$protobuf.Writer} Writer
|
|
*/
|
|
Optional.encodeDelimited = function encodeDelimited(message, writer) {
|
|
return this.encode(message, writer).ldelim();
|
|
};
|
|
|
|
/**
|
|
* Decodes an Optional message from the specified reader or buffer.
|
|
* @function decode
|
|
* @memberof onnx.TypeProto.Optional
|
|
* @static
|
|
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
|
|
* @param {number} [length] Message length if known beforehand
|
|
* @returns {onnx.TypeProto.Optional} Optional
|
|
* @throws {Error} If the payload is not a reader or valid buffer
|
|
* @throws {$protobuf.util.ProtocolError} If required fields are missing
|
|
*/
|
|
Optional.decode = function decode(reader, length) {
|
|
if (!(reader instanceof $Reader))
|
|
reader = $Reader.create(reader);
|
|
var end = length === undefined ? reader.len : reader.pos + length, message = new $root.onnx.TypeProto.Optional();
|
|
while (reader.pos < end) {
|
|
var tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1: {
|
|
message.elemType = $root.onnx.TypeProto.decode(reader, reader.uint32());
|
|
break;
|
|
}
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
};
|
|
|
|
/**
|
|
* Decodes an Optional message from the specified reader or buffer, length delimited.
|
|
* @function decodeDelimited
|
|
* @memberof onnx.TypeProto.Optional
|
|
* @static
|
|
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
|
|
* @returns {onnx.TypeProto.Optional} Optional
|
|
* @throws {Error} If the payload is not a reader or valid buffer
|
|
* @throws {$protobuf.util.ProtocolError} If required fields are missing
|
|
*/
|
|
Optional.decodeDelimited = function decodeDelimited(reader) {
|
|
if (!(reader instanceof $Reader))
|
|
reader = new $Reader(reader);
|
|
return this.decode(reader, reader.uint32());
|
|
};
|
|
|
|
/**
|
|
* Verifies an Optional message.
|
|
* @function verify
|
|
* @memberof onnx.TypeProto.Optional
|
|
* @static
|
|
* @param {Object.<string,*>} message Plain object to verify
|
|
* @returns {string|null} `null` if valid, otherwise the reason why it is not
|
|
*/
|
|
Optional.verify = function verify(message) {
|
|
if (typeof message !== "object" || message === null)
|
|
return "object expected";
|
|
if (message.elemType != null && message.hasOwnProperty("elemType")) {
|
|
var error = $root.onnx.TypeProto.verify(message.elemType);
|
|
if (error)
|
|
return "elemType." + error;
|
|
}
|
|
return null;
|
|
};
|
|
|
|
/**
|
|
* Creates an Optional message from a plain object. Also converts values to their respective internal types.
|
|
* @function fromObject
|
|
* @memberof onnx.TypeProto.Optional
|
|
* @static
|
|
* @param {Object.<string,*>} object Plain object
|
|
* @returns {onnx.TypeProto.Optional} Optional
|
|
*/
|
|
Optional.fromObject = function fromObject(object) {
|
|
if (object instanceof $root.onnx.TypeProto.Optional)
|
|
return object;
|
|
var message = new $root.onnx.TypeProto.Optional();
|
|
if (object.elemType != null) {
|
|
if (typeof object.elemType !== "object")
|
|
throw TypeError(".onnx.TypeProto.Optional.elemType: object expected");
|
|
message.elemType = $root.onnx.TypeProto.fromObject(object.elemType);
|
|
}
|
|
return message;
|
|
};
|
|
|
|
/**
|
|
* Creates a plain object from an Optional message. Also converts values to other types if specified.
|
|
* @function toObject
|
|
* @memberof onnx.TypeProto.Optional
|
|
* @static
|
|
* @param {onnx.TypeProto.Optional} message Optional
|
|
* @param {$protobuf.IConversionOptions} [options] Conversion options
|
|
* @returns {Object.<string,*>} Plain object
|
|
*/
|
|
Optional.toObject = function toObject(message, options) {
|
|
if (!options)
|
|
options = {};
|
|
var object = {};
|
|
if (options.defaults)
|
|
object.elemType = null;
|
|
if (message.elemType != null && message.hasOwnProperty("elemType"))
|
|
object.elemType = $root.onnx.TypeProto.toObject(message.elemType, options);
|
|
return object;
|
|
};
|
|
|
|
/**
|
|
* Converts this Optional to JSON.
|
|
* @function toJSON
|
|
* @memberof onnx.TypeProto.Optional
|
|
* @instance
|
|
* @returns {Object.<string,*>} JSON object
|
|
*/
|
|
Optional.prototype.toJSON = function toJSON() {
|
|
return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
|
|
};
|
|
|
|
/**
|
|
* Gets the default type url for Optional
|
|
* @function getTypeUrl
|
|
* @memberof onnx.TypeProto.Optional
|
|
* @static
|
|
* @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
|
|
* @returns {string} The default type url
|
|
*/
|
|
Optional.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
|
|
if (typeUrlPrefix === undefined) {
|
|
typeUrlPrefix = "type.googleapis.com";
|
|
}
|
|
return typeUrlPrefix + "/onnx.TypeProto.Optional";
|
|
};
|
|
|
|
return Optional;
|
|
})();
|
|
|
|
TypeProto.SparseTensor = (function() {
|
|
|
|
/**
|
|
* Properties of a SparseTensor.
|
|
* @memberof onnx.TypeProto
|
|
* @interface ISparseTensor
|
|
* @property {number|null} [elemType] SparseTensor elemType
|
|
* @property {onnx.ITensorShapeProto|null} [shape] SparseTensor shape
|
|
*/
|
|
|
|
/**
|
|
* Constructs a new SparseTensor.
|
|
* @memberof onnx.TypeProto
|
|
* @classdesc Represents a SparseTensor.
|
|
* @implements ISparseTensor
|
|
* @constructor
|
|
* @param {onnx.TypeProto.ISparseTensor=} [properties] Properties to set
|
|
*/
|
|
function SparseTensor(properties) {
|
|
if (properties)
|
|
for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
|
|
if (properties[keys[i]] != null)
|
|
this[keys[i]] = properties[keys[i]];
|
|
}
|
|
|
|
/**
|
|
* SparseTensor elemType.
|
|
* @member {number} elemType
|
|
* @memberof onnx.TypeProto.SparseTensor
|
|
* @instance
|
|
*/
|
|
SparseTensor.prototype.elemType = 0;
|
|
|
|
/**
|
|
* SparseTensor shape.
|
|
* @member {onnx.ITensorShapeProto|null|undefined} shape
|
|
* @memberof onnx.TypeProto.SparseTensor
|
|
* @instance
|
|
*/
|
|
SparseTensor.prototype.shape = null;
|
|
|
|
/**
|
|
* Creates a new SparseTensor instance using the specified properties.
|
|
* @function create
|
|
* @memberof onnx.TypeProto.SparseTensor
|
|
* @static
|
|
* @param {onnx.TypeProto.ISparseTensor=} [properties] Properties to set
|
|
* @returns {onnx.TypeProto.SparseTensor} SparseTensor instance
|
|
*/
|
|
SparseTensor.create = function create(properties) {
|
|
return new SparseTensor(properties);
|
|
};
|
|
|
|
/**
|
|
* Encodes the specified SparseTensor message. Does not implicitly {@link onnx.TypeProto.SparseTensor.verify|verify} messages.
|
|
* @function encode
|
|
* @memberof onnx.TypeProto.SparseTensor
|
|
* @static
|
|
* @param {onnx.TypeProto.ISparseTensor} message SparseTensor message or plain object to encode
|
|
* @param {$protobuf.Writer} [writer] Writer to encode to
|
|
* @returns {$protobuf.Writer} Writer
|
|
*/
|
|
SparseTensor.encode = function encode(message, writer) {
|
|
if (!writer)
|
|
writer = $Writer.create();
|
|
if (message.elemType != null && Object.hasOwnProperty.call(message, "elemType"))
|
|
writer.uint32(/* id 1, wireType 0 =*/8).int32(message.elemType);
|
|
if (message.shape != null && Object.hasOwnProperty.call(message, "shape"))
|
|
$root.onnx.TensorShapeProto.encode(message.shape, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();
|
|
return writer;
|
|
};
|
|
|
|
/**
|
|
* Encodes the specified SparseTensor message, length delimited. Does not implicitly {@link onnx.TypeProto.SparseTensor.verify|verify} messages.
|
|
* @function encodeDelimited
|
|
* @memberof onnx.TypeProto.SparseTensor
|
|
* @static
|
|
* @param {onnx.TypeProto.ISparseTensor} message SparseTensor message or plain object to encode
|
|
* @param {$protobuf.Writer} [writer] Writer to encode to
|
|
* @returns {$protobuf.Writer} Writer
|
|
*/
|
|
SparseTensor.encodeDelimited = function encodeDelimited(message, writer) {
|
|
return this.encode(message, writer).ldelim();
|
|
};
|
|
|
|
/**
|
|
* Decodes a SparseTensor message from the specified reader or buffer.
|
|
* @function decode
|
|
* @memberof onnx.TypeProto.SparseTensor
|
|
* @static
|
|
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
|
|
* @param {number} [length] Message length if known beforehand
|
|
* @returns {onnx.TypeProto.SparseTensor} SparseTensor
|
|
* @throws {Error} If the payload is not a reader or valid buffer
|
|
* @throws {$protobuf.util.ProtocolError} If required fields are missing
|
|
*/
|
|
SparseTensor.decode = function decode(reader, length) {
|
|
if (!(reader instanceof $Reader))
|
|
reader = $Reader.create(reader);
|
|
var end = length === undefined ? reader.len : reader.pos + length, message = new $root.onnx.TypeProto.SparseTensor();
|
|
while (reader.pos < end) {
|
|
var tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1: {
|
|
message.elemType = reader.int32();
|
|
break;
|
|
}
|
|
case 2: {
|
|
message.shape = $root.onnx.TensorShapeProto.decode(reader, reader.uint32());
|
|
break;
|
|
}
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
};
|
|
|
|
/**
|
|
* Decodes a SparseTensor message from the specified reader or buffer, length delimited.
|
|
* @function decodeDelimited
|
|
* @memberof onnx.TypeProto.SparseTensor
|
|
* @static
|
|
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
|
|
* @returns {onnx.TypeProto.SparseTensor} SparseTensor
|
|
* @throws {Error} If the payload is not a reader or valid buffer
|
|
* @throws {$protobuf.util.ProtocolError} If required fields are missing
|
|
*/
|
|
SparseTensor.decodeDelimited = function decodeDelimited(reader) {
|
|
if (!(reader instanceof $Reader))
|
|
reader = new $Reader(reader);
|
|
return this.decode(reader, reader.uint32());
|
|
};
|
|
|
|
/**
|
|
* Verifies a SparseTensor message.
|
|
* @function verify
|
|
* @memberof onnx.TypeProto.SparseTensor
|
|
* @static
|
|
* @param {Object.<string,*>} message Plain object to verify
|
|
* @returns {string|null} `null` if valid, otherwise the reason why it is not
|
|
*/
|
|
SparseTensor.verify = function verify(message) {
|
|
if (typeof message !== "object" || message === null)
|
|
return "object expected";
|
|
if (message.elemType != null && message.hasOwnProperty("elemType"))
|
|
if (!$util.isInteger(message.elemType))
|
|
return "elemType: integer expected";
|
|
if (message.shape != null && message.hasOwnProperty("shape")) {
|
|
var error = $root.onnx.TensorShapeProto.verify(message.shape);
|
|
if (error)
|
|
return "shape." + error;
|
|
}
|
|
return null;
|
|
};
|
|
|
|
/**
|
|
* Creates a SparseTensor message from a plain object. Also converts values to their respective internal types.
|
|
* @function fromObject
|
|
* @memberof onnx.TypeProto.SparseTensor
|
|
* @static
|
|
* @param {Object.<string,*>} object Plain object
|
|
* @returns {onnx.TypeProto.SparseTensor} SparseTensor
|
|
*/
|
|
SparseTensor.fromObject = function fromObject(object) {
|
|
if (object instanceof $root.onnx.TypeProto.SparseTensor)
|
|
return object;
|
|
var message = new $root.onnx.TypeProto.SparseTensor();
|
|
if (object.elemType != null)
|
|
message.elemType = object.elemType | 0;
|
|
if (object.shape != null) {
|
|
if (typeof object.shape !== "object")
|
|
throw TypeError(".onnx.TypeProto.SparseTensor.shape: object expected");
|
|
message.shape = $root.onnx.TensorShapeProto.fromObject(object.shape);
|
|
}
|
|
return message;
|
|
};
|
|
|
|
/**
|
|
* Creates a plain object from a SparseTensor message. Also converts values to other types if specified.
|
|
* @function toObject
|
|
* @memberof onnx.TypeProto.SparseTensor
|
|
* @static
|
|
* @param {onnx.TypeProto.SparseTensor} message SparseTensor
|
|
* @param {$protobuf.IConversionOptions} [options] Conversion options
|
|
* @returns {Object.<string,*>} Plain object
|
|
*/
|
|
SparseTensor.toObject = function toObject(message, options) {
|
|
if (!options)
|
|
options = {};
|
|
var object = {};
|
|
if (options.defaults) {
|
|
object.elemType = 0;
|
|
object.shape = null;
|
|
}
|
|
if (message.elemType != null && message.hasOwnProperty("elemType"))
|
|
object.elemType = message.elemType;
|
|
if (message.shape != null && message.hasOwnProperty("shape"))
|
|
object.shape = $root.onnx.TensorShapeProto.toObject(message.shape, options);
|
|
return object;
|
|
};
|
|
|
|
/**
|
|
* Converts this SparseTensor to JSON.
|
|
* @function toJSON
|
|
* @memberof onnx.TypeProto.SparseTensor
|
|
* @instance
|
|
* @returns {Object.<string,*>} JSON object
|
|
*/
|
|
SparseTensor.prototype.toJSON = function toJSON() {
|
|
return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
|
|
};
|
|
|
|
/**
|
|
* Gets the default type url for SparseTensor
|
|
* @function getTypeUrl
|
|
* @memberof onnx.TypeProto.SparseTensor
|
|
* @static
|
|
* @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
|
|
* @returns {string} The default type url
|
|
*/
|
|
SparseTensor.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
|
|
if (typeUrlPrefix === undefined) {
|
|
typeUrlPrefix = "type.googleapis.com";
|
|
}
|
|
return typeUrlPrefix + "/onnx.TypeProto.SparseTensor";
|
|
};
|
|
|
|
return SparseTensor;
|
|
})();
|
|
|
|
return TypeProto;
|
|
})();
|
|
|
|
onnx.OperatorSetIdProto = (function() {
|
|
|
|
/**
|
|
* Properties of an OperatorSetIdProto.
|
|
* @memberof onnx
|
|
* @interface IOperatorSetIdProto
|
|
* @property {string|null} [domain] OperatorSetIdProto domain
|
|
* @property {number|Long|null} [version] OperatorSetIdProto version
|
|
*/
|
|
|
|
/**
|
|
* Constructs a new OperatorSetIdProto.
|
|
* @memberof onnx
|
|
* @classdesc Represents an OperatorSetIdProto.
|
|
* @implements IOperatorSetIdProto
|
|
* @constructor
|
|
* @param {onnx.IOperatorSetIdProto=} [properties] Properties to set
|
|
*/
|
|
function OperatorSetIdProto(properties) {
|
|
if (properties)
|
|
for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
|
|
if (properties[keys[i]] != null)
|
|
this[keys[i]] = properties[keys[i]];
|
|
}
|
|
|
|
/**
|
|
* OperatorSetIdProto domain.
|
|
* @member {string} domain
|
|
* @memberof onnx.OperatorSetIdProto
|
|
* @instance
|
|
*/
|
|
OperatorSetIdProto.prototype.domain = "";
|
|
|
|
/**
|
|
* OperatorSetIdProto version.
|
|
* @member {number|Long} version
|
|
* @memberof onnx.OperatorSetIdProto
|
|
* @instance
|
|
*/
|
|
OperatorSetIdProto.prototype.version = $util.Long ? $util.Long.fromBits(0,0,false) : 0;
|
|
|
|
/**
|
|
* Creates a new OperatorSetIdProto instance using the specified properties.
|
|
* @function create
|
|
* @memberof onnx.OperatorSetIdProto
|
|
* @static
|
|
* @param {onnx.IOperatorSetIdProto=} [properties] Properties to set
|
|
* @returns {onnx.OperatorSetIdProto} OperatorSetIdProto instance
|
|
*/
|
|
OperatorSetIdProto.create = function create(properties) {
|
|
return new OperatorSetIdProto(properties);
|
|
};
|
|
|
|
/**
|
|
* Encodes the specified OperatorSetIdProto message. Does not implicitly {@link onnx.OperatorSetIdProto.verify|verify} messages.
|
|
* @function encode
|
|
* @memberof onnx.OperatorSetIdProto
|
|
* @static
|
|
* @param {onnx.IOperatorSetIdProto} message OperatorSetIdProto message or plain object to encode
|
|
* @param {$protobuf.Writer} [writer] Writer to encode to
|
|
* @returns {$protobuf.Writer} Writer
|
|
*/
|
|
OperatorSetIdProto.encode = function encode(message, writer) {
|
|
if (!writer)
|
|
writer = $Writer.create();
|
|
if (message.domain != null && Object.hasOwnProperty.call(message, "domain"))
|
|
writer.uint32(/* id 1, wireType 2 =*/10).string(message.domain);
|
|
if (message.version != null && Object.hasOwnProperty.call(message, "version"))
|
|
writer.uint32(/* id 2, wireType 0 =*/16).int64(message.version);
|
|
return writer;
|
|
};
|
|
|
|
/**
|
|
* Encodes the specified OperatorSetIdProto message, length delimited. Does not implicitly {@link onnx.OperatorSetIdProto.verify|verify} messages.
|
|
* @function encodeDelimited
|
|
* @memberof onnx.OperatorSetIdProto
|
|
* @static
|
|
* @param {onnx.IOperatorSetIdProto} message OperatorSetIdProto message or plain object to encode
|
|
* @param {$protobuf.Writer} [writer] Writer to encode to
|
|
* @returns {$protobuf.Writer} Writer
|
|
*/
|
|
OperatorSetIdProto.encodeDelimited = function encodeDelimited(message, writer) {
|
|
return this.encode(message, writer).ldelim();
|
|
};
|
|
|
|
/**
|
|
* Decodes an OperatorSetIdProto message from the specified reader or buffer.
|
|
* @function decode
|
|
* @memberof onnx.OperatorSetIdProto
|
|
* @static
|
|
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
|
|
* @param {number} [length] Message length if known beforehand
|
|
* @returns {onnx.OperatorSetIdProto} OperatorSetIdProto
|
|
* @throws {Error} If the payload is not a reader or valid buffer
|
|
* @throws {$protobuf.util.ProtocolError} If required fields are missing
|
|
*/
|
|
OperatorSetIdProto.decode = function decode(reader, length) {
|
|
if (!(reader instanceof $Reader))
|
|
reader = $Reader.create(reader);
|
|
var end = length === undefined ? reader.len : reader.pos + length, message = new $root.onnx.OperatorSetIdProto();
|
|
while (reader.pos < end) {
|
|
var 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;
|
|
};
|
|
|
|
/**
|
|
* Decodes an OperatorSetIdProto message from the specified reader or buffer, length delimited.
|
|
* @function decodeDelimited
|
|
* @memberof onnx.OperatorSetIdProto
|
|
* @static
|
|
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
|
|
* @returns {onnx.OperatorSetIdProto} OperatorSetIdProto
|
|
* @throws {Error} If the payload is not a reader or valid buffer
|
|
* @throws {$protobuf.util.ProtocolError} If required fields are missing
|
|
*/
|
|
OperatorSetIdProto.decodeDelimited = function decodeDelimited(reader) {
|
|
if (!(reader instanceof $Reader))
|
|
reader = new $Reader(reader);
|
|
return this.decode(reader, reader.uint32());
|
|
};
|
|
|
|
/**
|
|
* Verifies an OperatorSetIdProto message.
|
|
* @function verify
|
|
* @memberof onnx.OperatorSetIdProto
|
|
* @static
|
|
* @param {Object.<string,*>} message Plain object to verify
|
|
* @returns {string|null} `null` if valid, otherwise the reason why it is not
|
|
*/
|
|
OperatorSetIdProto.verify = function verify(message) {
|
|
if (typeof message !== "object" || message === null)
|
|
return "object expected";
|
|
if (message.domain != null && message.hasOwnProperty("domain"))
|
|
if (!$util.isString(message.domain))
|
|
return "domain: string expected";
|
|
if (message.version != null && message.hasOwnProperty("version"))
|
|
if (!$util.isInteger(message.version) && !(message.version && $util.isInteger(message.version.low) && $util.isInteger(message.version.high)))
|
|
return "version: integer|Long expected";
|
|
return null;
|
|
};
|
|
|
|
/**
|
|
* Creates an OperatorSetIdProto message from a plain object. Also converts values to their respective internal types.
|
|
* @function fromObject
|
|
* @memberof onnx.OperatorSetIdProto
|
|
* @static
|
|
* @param {Object.<string,*>} object Plain object
|
|
* @returns {onnx.OperatorSetIdProto} OperatorSetIdProto
|
|
*/
|
|
OperatorSetIdProto.fromObject = function fromObject(object) {
|
|
if (object instanceof $root.onnx.OperatorSetIdProto)
|
|
return object;
|
|
var message = new $root.onnx.OperatorSetIdProto();
|
|
if (object.domain != null)
|
|
message.domain = String(object.domain);
|
|
if (object.version != null)
|
|
if ($util.Long)
|
|
(message.version = $util.Long.fromValue(object.version)).unsigned = false;
|
|
else if (typeof object.version === "string")
|
|
message.version = parseInt(object.version, 10);
|
|
else if (typeof object.version === "number")
|
|
message.version = object.version;
|
|
else if (typeof object.version === "object")
|
|
message.version = new $util.LongBits(object.version.low >>> 0, object.version.high >>> 0).toNumber();
|
|
return message;
|
|
};
|
|
|
|
/**
|
|
* Creates a plain object from an OperatorSetIdProto message. Also converts values to other types if specified.
|
|
* @function toObject
|
|
* @memberof onnx.OperatorSetIdProto
|
|
* @static
|
|
* @param {onnx.OperatorSetIdProto} message OperatorSetIdProto
|
|
* @param {$protobuf.IConversionOptions} [options] Conversion options
|
|
* @returns {Object.<string,*>} Plain object
|
|
*/
|
|
OperatorSetIdProto.toObject = function toObject(message, options) {
|
|
if (!options)
|
|
options = {};
|
|
var object = {};
|
|
if (options.defaults) {
|
|
object.domain = "";
|
|
if ($util.Long) {
|
|
var long = new $util.Long(0, 0, false);
|
|
object.version = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
|
|
} else
|
|
object.version = options.longs === String ? "0" : 0;
|
|
}
|
|
if (message.domain != null && message.hasOwnProperty("domain"))
|
|
object.domain = message.domain;
|
|
if (message.version != null && message.hasOwnProperty("version"))
|
|
if (typeof message.version === "number")
|
|
object.version = options.longs === String ? String(message.version) : message.version;
|
|
else
|
|
object.version = options.longs === String ? $util.Long.prototype.toString.call(message.version) : options.longs === Number ? new $util.LongBits(message.version.low >>> 0, message.version.high >>> 0).toNumber() : message.version;
|
|
return object;
|
|
};
|
|
|
|
/**
|
|
* Converts this OperatorSetIdProto to JSON.
|
|
* @function toJSON
|
|
* @memberof onnx.OperatorSetIdProto
|
|
* @instance
|
|
* @returns {Object.<string,*>} JSON object
|
|
*/
|
|
OperatorSetIdProto.prototype.toJSON = function toJSON() {
|
|
return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
|
|
};
|
|
|
|
/**
|
|
* Gets the default type url for OperatorSetIdProto
|
|
* @function getTypeUrl
|
|
* @memberof onnx.OperatorSetIdProto
|
|
* @static
|
|
* @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
|
|
* @returns {string} The default type url
|
|
*/
|
|
OperatorSetIdProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
|
|
if (typeUrlPrefix === undefined) {
|
|
typeUrlPrefix = "type.googleapis.com";
|
|
}
|
|
return typeUrlPrefix + "/onnx.OperatorSetIdProto";
|
|
};
|
|
|
|
return OperatorSetIdProto;
|
|
})();
|
|
|
|
/**
|
|
* OperatorStatus enum.
|
|
* @name onnx.OperatorStatus
|
|
* @enum {number}
|
|
* @property {number} EXPERIMENTAL=0 EXPERIMENTAL value
|
|
* @property {number} STABLE=1 STABLE value
|
|
*/
|
|
onnx.OperatorStatus = (function() {
|
|
var valuesById = {}, values = Object.create(valuesById);
|
|
values[valuesById[0] = "EXPERIMENTAL"] = 0;
|
|
values[valuesById[1] = "STABLE"] = 1;
|
|
return values;
|
|
})();
|
|
|
|
onnx.FunctionProto = (function() {
|
|
|
|
/**
|
|
* Properties of a FunctionProto.
|
|
* @memberof onnx
|
|
* @interface IFunctionProto
|
|
* @property {string|null} [name] FunctionProto name
|
|
* @property {Array.<string>|null} [input] FunctionProto input
|
|
* @property {Array.<string>|null} [output] FunctionProto output
|
|
* @property {Array.<string>|null} [attribute] FunctionProto attribute
|
|
* @property {Array.<onnx.IAttributeProto>|null} [attributeProto] FunctionProto attributeProto
|
|
* @property {Array.<onnx.INodeProto>|null} [node] FunctionProto node
|
|
* @property {string|null} [docString] FunctionProto docString
|
|
* @property {Array.<onnx.IOperatorSetIdProto>|null} [opsetImport] FunctionProto opsetImport
|
|
* @property {string|null} [domain] FunctionProto domain
|
|
*/
|
|
|
|
/**
|
|
* Constructs a new FunctionProto.
|
|
* @memberof onnx
|
|
* @classdesc Represents a FunctionProto.
|
|
* @implements IFunctionProto
|
|
* @constructor
|
|
* @param {onnx.IFunctionProto=} [properties] Properties to set
|
|
*/
|
|
function FunctionProto(properties) {
|
|
this.input = [];
|
|
this.output = [];
|
|
this.attribute = [];
|
|
this.attributeProto = [];
|
|
this.node = [];
|
|
this.opsetImport = [];
|
|
if (properties)
|
|
for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
|
|
if (properties[keys[i]] != null)
|
|
this[keys[i]] = properties[keys[i]];
|
|
}
|
|
|
|
/**
|
|
* FunctionProto name.
|
|
* @member {string} name
|
|
* @memberof onnx.FunctionProto
|
|
* @instance
|
|
*/
|
|
FunctionProto.prototype.name = "";
|
|
|
|
/**
|
|
* FunctionProto input.
|
|
* @member {Array.<string>} input
|
|
* @memberof onnx.FunctionProto
|
|
* @instance
|
|
*/
|
|
FunctionProto.prototype.input = $util.emptyArray;
|
|
|
|
/**
|
|
* FunctionProto output.
|
|
* @member {Array.<string>} output
|
|
* @memberof onnx.FunctionProto
|
|
* @instance
|
|
*/
|
|
FunctionProto.prototype.output = $util.emptyArray;
|
|
|
|
/**
|
|
* FunctionProto attribute.
|
|
* @member {Array.<string>} attribute
|
|
* @memberof onnx.FunctionProto
|
|
* @instance
|
|
*/
|
|
FunctionProto.prototype.attribute = $util.emptyArray;
|
|
|
|
/**
|
|
* FunctionProto attributeProto.
|
|
* @member {Array.<onnx.IAttributeProto>} attributeProto
|
|
* @memberof onnx.FunctionProto
|
|
* @instance
|
|
*/
|
|
FunctionProto.prototype.attributeProto = $util.emptyArray;
|
|
|
|
/**
|
|
* FunctionProto node.
|
|
* @member {Array.<onnx.INodeProto>} node
|
|
* @memberof onnx.FunctionProto
|
|
* @instance
|
|
*/
|
|
FunctionProto.prototype.node = $util.emptyArray;
|
|
|
|
/**
|
|
* FunctionProto docString.
|
|
* @member {string} docString
|
|
* @memberof onnx.FunctionProto
|
|
* @instance
|
|
*/
|
|
FunctionProto.prototype.docString = "";
|
|
|
|
/**
|
|
* FunctionProto opsetImport.
|
|
* @member {Array.<onnx.IOperatorSetIdProto>} opsetImport
|
|
* @memberof onnx.FunctionProto
|
|
* @instance
|
|
*/
|
|
FunctionProto.prototype.opsetImport = $util.emptyArray;
|
|
|
|
/**
|
|
* FunctionProto domain.
|
|
* @member {string} domain
|
|
* @memberof onnx.FunctionProto
|
|
* @instance
|
|
*/
|
|
FunctionProto.prototype.domain = "";
|
|
|
|
/**
|
|
* Creates a new FunctionProto instance using the specified properties.
|
|
* @function create
|
|
* @memberof onnx.FunctionProto
|
|
* @static
|
|
* @param {onnx.IFunctionProto=} [properties] Properties to set
|
|
* @returns {onnx.FunctionProto} FunctionProto instance
|
|
*/
|
|
FunctionProto.create = function create(properties) {
|
|
return new FunctionProto(properties);
|
|
};
|
|
|
|
/**
|
|
* Encodes the specified FunctionProto message. Does not implicitly {@link onnx.FunctionProto.verify|verify} messages.
|
|
* @function encode
|
|
* @memberof onnx.FunctionProto
|
|
* @static
|
|
* @param {onnx.IFunctionProto} message FunctionProto message or plain object to encode
|
|
* @param {$protobuf.Writer} [writer] Writer to encode to
|
|
* @returns {$protobuf.Writer} Writer
|
|
*/
|
|
FunctionProto.encode = function encode(message, writer) {
|
|
if (!writer)
|
|
writer = $Writer.create();
|
|
if (message.name != null && Object.hasOwnProperty.call(message, "name"))
|
|
writer.uint32(/* id 1, wireType 2 =*/10).string(message.name);
|
|
if (message.input != null && message.input.length)
|
|
for (var i = 0; i < message.input.length; ++i)
|
|
writer.uint32(/* id 4, wireType 2 =*/34).string(message.input[i]);
|
|
if (message.output != null && message.output.length)
|
|
for (var i = 0; i < message.output.length; ++i)
|
|
writer.uint32(/* id 5, wireType 2 =*/42).string(message.output[i]);
|
|
if (message.attribute != null && message.attribute.length)
|
|
for (var i = 0; i < message.attribute.length; ++i)
|
|
writer.uint32(/* id 6, wireType 2 =*/50).string(message.attribute[i]);
|
|
if (message.node != null && message.node.length)
|
|
for (var i = 0; i < message.node.length; ++i)
|
|
$root.onnx.NodeProto.encode(message.node[i], writer.uint32(/* id 7, wireType 2 =*/58).fork()).ldelim();
|
|
if (message.docString != null && Object.hasOwnProperty.call(message, "docString"))
|
|
writer.uint32(/* id 8, wireType 2 =*/66).string(message.docString);
|
|
if (message.opsetImport != null && message.opsetImport.length)
|
|
for (var i = 0; i < message.opsetImport.length; ++i)
|
|
$root.onnx.OperatorSetIdProto.encode(message.opsetImport[i], writer.uint32(/* id 9, wireType 2 =*/74).fork()).ldelim();
|
|
if (message.domain != null && Object.hasOwnProperty.call(message, "domain"))
|
|
writer.uint32(/* id 10, wireType 2 =*/82).string(message.domain);
|
|
if (message.attributeProto != null && message.attributeProto.length)
|
|
for (var i = 0; i < message.attributeProto.length; ++i)
|
|
$root.onnx.AttributeProto.encode(message.attributeProto[i], writer.uint32(/* id 11, wireType 2 =*/90).fork()).ldelim();
|
|
return writer;
|
|
};
|
|
|
|
/**
|
|
* Encodes the specified FunctionProto message, length delimited. Does not implicitly {@link onnx.FunctionProto.verify|verify} messages.
|
|
* @function encodeDelimited
|
|
* @memberof onnx.FunctionProto
|
|
* @static
|
|
* @param {onnx.IFunctionProto} message FunctionProto message or plain object to encode
|
|
* @param {$protobuf.Writer} [writer] Writer to encode to
|
|
* @returns {$protobuf.Writer} Writer
|
|
*/
|
|
FunctionProto.encodeDelimited = function encodeDelimited(message, writer) {
|
|
return this.encode(message, writer).ldelim();
|
|
};
|
|
|
|
/**
|
|
* Decodes a FunctionProto message from the specified reader or buffer.
|
|
* @function decode
|
|
* @memberof onnx.FunctionProto
|
|
* @static
|
|
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
|
|
* @param {number} [length] Message length if known beforehand
|
|
* @returns {onnx.FunctionProto} FunctionProto
|
|
* @throws {Error} If the payload is not a reader or valid buffer
|
|
* @throws {$protobuf.util.ProtocolError} If required fields are missing
|
|
*/
|
|
FunctionProto.decode = function decode(reader, length) {
|
|
if (!(reader instanceof $Reader))
|
|
reader = $Reader.create(reader);
|
|
var end = length === undefined ? reader.len : reader.pos + length, message = new $root.onnx.FunctionProto();
|
|
while (reader.pos < end) {
|
|
var tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1: {
|
|
message.name = reader.string();
|
|
break;
|
|
}
|
|
case 4: {
|
|
if (!(message.input && message.input.length))
|
|
message.input = [];
|
|
message.input.push(reader.string());
|
|
break;
|
|
}
|
|
case 5: {
|
|
if (!(message.output && message.output.length))
|
|
message.output = [];
|
|
message.output.push(reader.string());
|
|
break;
|
|
}
|
|
case 6: {
|
|
if (!(message.attribute && message.attribute.length))
|
|
message.attribute = [];
|
|
message.attribute.push(reader.string());
|
|
break;
|
|
}
|
|
case 11: {
|
|
if (!(message.attributeProto && message.attributeProto.length))
|
|
message.attributeProto = [];
|
|
message.attributeProto.push($root.onnx.AttributeProto.decode(reader, reader.uint32()));
|
|
break;
|
|
}
|
|
case 7: {
|
|
if (!(message.node && message.node.length))
|
|
message.node = [];
|
|
message.node.push($root.onnx.NodeProto.decode(reader, reader.uint32()));
|
|
break;
|
|
}
|
|
case 8: {
|
|
message.docString = reader.string();
|
|
break;
|
|
}
|
|
case 9: {
|
|
if (!(message.opsetImport && message.opsetImport.length))
|
|
message.opsetImport = [];
|
|
message.opsetImport.push($root.onnx.OperatorSetIdProto.decode(reader, reader.uint32()));
|
|
break;
|
|
}
|
|
case 10: {
|
|
message.domain = reader.string();
|
|
break;
|
|
}
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
};
|
|
|
|
/**
|
|
* Decodes a FunctionProto message from the specified reader or buffer, length delimited.
|
|
* @function decodeDelimited
|
|
* @memberof onnx.FunctionProto
|
|
* @static
|
|
* @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
|
|
* @returns {onnx.FunctionProto} FunctionProto
|
|
* @throws {Error} If the payload is not a reader or valid buffer
|
|
* @throws {$protobuf.util.ProtocolError} If required fields are missing
|
|
*/
|
|
FunctionProto.decodeDelimited = function decodeDelimited(reader) {
|
|
if (!(reader instanceof $Reader))
|
|
reader = new $Reader(reader);
|
|
return this.decode(reader, reader.uint32());
|
|
};
|
|
|
|
/**
|
|
* Verifies a FunctionProto message.
|
|
* @function verify
|
|
* @memberof onnx.FunctionProto
|
|
* @static
|
|
* @param {Object.<string,*>} message Plain object to verify
|
|
* @returns {string|null} `null` if valid, otherwise the reason why it is not
|
|
*/
|
|
FunctionProto.verify = function verify(message) {
|
|
if (typeof message !== "object" || message === null)
|
|
return "object expected";
|
|
if (message.name != null && message.hasOwnProperty("name"))
|
|
if (!$util.isString(message.name))
|
|
return "name: string expected";
|
|
if (message.input != null && message.hasOwnProperty("input")) {
|
|
if (!Array.isArray(message.input))
|
|
return "input: array expected";
|
|
for (var i = 0; i < message.input.length; ++i)
|
|
if (!$util.isString(message.input[i]))
|
|
return "input: string[] expected";
|
|
}
|
|
if (message.output != null && message.hasOwnProperty("output")) {
|
|
if (!Array.isArray(message.output))
|
|
return "output: array expected";
|
|
for (var i = 0; i < message.output.length; ++i)
|
|
if (!$util.isString(message.output[i]))
|
|
return "output: string[] expected";
|
|
}
|
|
if (message.attribute != null && message.hasOwnProperty("attribute")) {
|
|
if (!Array.isArray(message.attribute))
|
|
return "attribute: array expected";
|
|
for (var i = 0; i < message.attribute.length; ++i)
|
|
if (!$util.isString(message.attribute[i]))
|
|
return "attribute: string[] expected";
|
|
}
|
|
if (message.attributeProto != null && message.hasOwnProperty("attributeProto")) {
|
|
if (!Array.isArray(message.attributeProto))
|
|
return "attributeProto: array expected";
|
|
for (var i = 0; i < message.attributeProto.length; ++i) {
|
|
var error = $root.onnx.AttributeProto.verify(message.attributeProto[i]);
|
|
if (error)
|
|
return "attributeProto." + error;
|
|
}
|
|
}
|
|
if (message.node != null && message.hasOwnProperty("node")) {
|
|
if (!Array.isArray(message.node))
|
|
return "node: array expected";
|
|
for (var i = 0; i < message.node.length; ++i) {
|
|
var error = $root.onnx.NodeProto.verify(message.node[i]);
|
|
if (error)
|
|
return "node." + error;
|
|
}
|
|
}
|
|
if (message.docString != null && message.hasOwnProperty("docString"))
|
|
if (!$util.isString(message.docString))
|
|
return "docString: string expected";
|
|
if (message.opsetImport != null && message.hasOwnProperty("opsetImport")) {
|
|
if (!Array.isArray(message.opsetImport))
|
|
return "opsetImport: array expected";
|
|
for (var i = 0; i < message.opsetImport.length; ++i) {
|
|
var error = $root.onnx.OperatorSetIdProto.verify(message.opsetImport[i]);
|
|
if (error)
|
|
return "opsetImport." + error;
|
|
}
|
|
}
|
|
if (message.domain != null && message.hasOwnProperty("domain"))
|
|
if (!$util.isString(message.domain))
|
|
return "domain: string expected";
|
|
return null;
|
|
};
|
|
|
|
/**
|
|
* Creates a FunctionProto message from a plain object. Also converts values to their respective internal types.
|
|
* @function fromObject
|
|
* @memberof onnx.FunctionProto
|
|
* @static
|
|
* @param {Object.<string,*>} object Plain object
|
|
* @returns {onnx.FunctionProto} FunctionProto
|
|
*/
|
|
FunctionProto.fromObject = function fromObject(object) {
|
|
if (object instanceof $root.onnx.FunctionProto)
|
|
return object;
|
|
var message = new $root.onnx.FunctionProto();
|
|
if (object.name != null)
|
|
message.name = String(object.name);
|
|
if (object.input) {
|
|
if (!Array.isArray(object.input))
|
|
throw TypeError(".onnx.FunctionProto.input: array expected");
|
|
message.input = [];
|
|
for (var i = 0; i < object.input.length; ++i)
|
|
message.input[i] = String(object.input[i]);
|
|
}
|
|
if (object.output) {
|
|
if (!Array.isArray(object.output))
|
|
throw TypeError(".onnx.FunctionProto.output: array expected");
|
|
message.output = [];
|
|
for (var i = 0; i < object.output.length; ++i)
|
|
message.output[i] = String(object.output[i]);
|
|
}
|
|
if (object.attribute) {
|
|
if (!Array.isArray(object.attribute))
|
|
throw TypeError(".onnx.FunctionProto.attribute: array expected");
|
|
message.attribute = [];
|
|
for (var i = 0; i < object.attribute.length; ++i)
|
|
message.attribute[i] = String(object.attribute[i]);
|
|
}
|
|
if (object.attributeProto) {
|
|
if (!Array.isArray(object.attributeProto))
|
|
throw TypeError(".onnx.FunctionProto.attributeProto: array expected");
|
|
message.attributeProto = [];
|
|
for (var i = 0; i < object.attributeProto.length; ++i) {
|
|
if (typeof object.attributeProto[i] !== "object")
|
|
throw TypeError(".onnx.FunctionProto.attributeProto: object expected");
|
|
message.attributeProto[i] = $root.onnx.AttributeProto.fromObject(object.attributeProto[i]);
|
|
}
|
|
}
|
|
if (object.node) {
|
|
if (!Array.isArray(object.node))
|
|
throw TypeError(".onnx.FunctionProto.node: array expected");
|
|
message.node = [];
|
|
for (var i = 0; i < object.node.length; ++i) {
|
|
if (typeof object.node[i] !== "object")
|
|
throw TypeError(".onnx.FunctionProto.node: object expected");
|
|
message.node[i] = $root.onnx.NodeProto.fromObject(object.node[i]);
|
|
}
|
|
}
|
|
if (object.docString != null)
|
|
message.docString = String(object.docString);
|
|
if (object.opsetImport) {
|
|
if (!Array.isArray(object.opsetImport))
|
|
throw TypeError(".onnx.FunctionProto.opsetImport: array expected");
|
|
message.opsetImport = [];
|
|
for (var i = 0; i < object.opsetImport.length; ++i) {
|
|
if (typeof object.opsetImport[i] !== "object")
|
|
throw TypeError(".onnx.FunctionProto.opsetImport: object expected");
|
|
message.opsetImport[i] = $root.onnx.OperatorSetIdProto.fromObject(object.opsetImport[i]);
|
|
}
|
|
}
|
|
if (object.domain != null)
|
|
message.domain = String(object.domain);
|
|
return message;
|
|
};
|
|
|
|
/**
|
|
* Creates a plain object from a FunctionProto message. Also converts values to other types if specified.
|
|
* @function toObject
|
|
* @memberof onnx.FunctionProto
|
|
* @static
|
|
* @param {onnx.FunctionProto} message FunctionProto
|
|
* @param {$protobuf.IConversionOptions} [options] Conversion options
|
|
* @returns {Object.<string,*>} Plain object
|
|
*/
|
|
FunctionProto.toObject = function toObject(message, options) {
|
|
if (!options)
|
|
options = {};
|
|
var object = {};
|
|
if (options.arrays || options.defaults) {
|
|
object.input = [];
|
|
object.output = [];
|
|
object.attribute = [];
|
|
object.node = [];
|
|
object.opsetImport = [];
|
|
object.attributeProto = [];
|
|
}
|
|
if (options.defaults) {
|
|
object.name = "";
|
|
object.docString = "";
|
|
object.domain = "";
|
|
}
|
|
if (message.name != null && message.hasOwnProperty("name"))
|
|
object.name = message.name;
|
|
if (message.input && message.input.length) {
|
|
object.input = [];
|
|
for (var j = 0; j < message.input.length; ++j)
|
|
object.input[j] = message.input[j];
|
|
}
|
|
if (message.output && message.output.length) {
|
|
object.output = [];
|
|
for (var j = 0; j < message.output.length; ++j)
|
|
object.output[j] = message.output[j];
|
|
}
|
|
if (message.attribute && message.attribute.length) {
|
|
object.attribute = [];
|
|
for (var j = 0; j < message.attribute.length; ++j)
|
|
object.attribute[j] = message.attribute[j];
|
|
}
|
|
if (message.node && message.node.length) {
|
|
object.node = [];
|
|
for (var j = 0; j < message.node.length; ++j)
|
|
object.node[j] = $root.onnx.NodeProto.toObject(message.node[j], options);
|
|
}
|
|
if (message.docString != null && message.hasOwnProperty("docString"))
|
|
object.docString = message.docString;
|
|
if (message.opsetImport && message.opsetImport.length) {
|
|
object.opsetImport = [];
|
|
for (var j = 0; j < message.opsetImport.length; ++j)
|
|
object.opsetImport[j] = $root.onnx.OperatorSetIdProto.toObject(message.opsetImport[j], options);
|
|
}
|
|
if (message.domain != null && message.hasOwnProperty("domain"))
|
|
object.domain = message.domain;
|
|
if (message.attributeProto && message.attributeProto.length) {
|
|
object.attributeProto = [];
|
|
for (var j = 0; j < message.attributeProto.length; ++j)
|
|
object.attributeProto[j] = $root.onnx.AttributeProto.toObject(message.attributeProto[j], options);
|
|
}
|
|
return object;
|
|
};
|
|
|
|
/**
|
|
* Converts this FunctionProto to JSON.
|
|
* @function toJSON
|
|
* @memberof onnx.FunctionProto
|
|
* @instance
|
|
* @returns {Object.<string,*>} JSON object
|
|
*/
|
|
FunctionProto.prototype.toJSON = function toJSON() {
|
|
return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
|
|
};
|
|
|
|
/**
|
|
* Gets the default type url for FunctionProto
|
|
* @function getTypeUrl
|
|
* @memberof onnx.FunctionProto
|
|
* @static
|
|
* @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
|
|
* @returns {string} The default type url
|
|
*/
|
|
FunctionProto.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
|
|
if (typeUrlPrefix === undefined) {
|
|
typeUrlPrefix = "type.googleapis.com";
|
|
}
|
|
return typeUrlPrefix + "/onnx.FunctionProto";
|
|
};
|
|
|
|
return FunctionProto;
|
|
})();
|
|
|
|
return onnx;
|
|
})();
|
|
|
|
module.exports = $root;
|