wehub-resource-sync
7254f7b4d1
Build / Build (macos-latest) (push) Has been cancelled
Build / Build (ubuntu-latest) (push) Has been cancelled
Build / Build (windows-latest) (push) Has been cancelled
Build / Analyze (javascript) (push) Has been cancelled
Build / Analyze (python) (push) Has been cancelled
1466 lines
50 KiB
JavaScript
1466 lines
50 KiB
JavaScript
|
|
export const mind_ir = {};
|
|
|
|
mind_ir.Version = {
|
|
"IR_VERSION_START": 0,
|
|
"IR_VERSION": 1,
|
|
"IR_VERSION_WITH_PRIM_FUNCTION": 2
|
|
};
|
|
|
|
mind_ir.AttributeProto = class AttributeProto {
|
|
|
|
constructor() {
|
|
this.floats = [];
|
|
this.doubles = [];
|
|
this.ints = [];
|
|
this.strings = [];
|
|
this.tensors = [];
|
|
this.graphs = [];
|
|
this.values = [];
|
|
}
|
|
|
|
static decode(reader, length) {
|
|
const message = new mind_ir.AttributeProto();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.name = reader.string();
|
|
break;
|
|
case 2:
|
|
message.f = reader.float();
|
|
break;
|
|
case 3:
|
|
message.i = reader.int64();
|
|
break;
|
|
case 4:
|
|
message.d = reader.double();
|
|
break;
|
|
case 5:
|
|
message.s = reader.bytes();
|
|
break;
|
|
case 6:
|
|
message.t = mind_ir.TensorProto.decode(reader, reader.uint32());
|
|
break;
|
|
case 7:
|
|
message.g = mind_ir.GraphProto.decode(reader, reader.uint32());
|
|
break;
|
|
case 8:
|
|
message.floats = reader.floats(message.floats, tag);
|
|
break;
|
|
case 9:
|
|
message.doubles = reader.doubles(message.doubles, tag);
|
|
break;
|
|
case 10:
|
|
message.ints = reader.array(message.ints, () => reader.int64(), tag);
|
|
break;
|
|
case 11:
|
|
message.strings.push(reader.bytes());
|
|
break;
|
|
case 12:
|
|
message.tensors.push(mind_ir.TensorProto.decode(reader, reader.uint32()));
|
|
break;
|
|
case 13:
|
|
message.graphs.push(mind_ir.GraphProto.decode(reader, reader.uint32()));
|
|
break;
|
|
case 14:
|
|
message.doc_string = reader.string();
|
|
break;
|
|
case 15:
|
|
message.ref_attr_name = reader.string();
|
|
break;
|
|
case 16:
|
|
message.type = reader.int32();
|
|
break;
|
|
case 17:
|
|
message.values.push(mind_ir.AttributeProto.decode(reader, reader.uint32()));
|
|
break;
|
|
case 18:
|
|
message.seq_info = mind_ir.AttributeProto.SeqInfoProto.decode(reader, reader.uint32());
|
|
break;
|
|
case 19:
|
|
message.functor = mind_ir.FunctorProto.decode(reader, reader.uint32());
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new mind_ir.AttributeProto();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "name":
|
|
message.name = reader.string();
|
|
break;
|
|
case "f":
|
|
message.f = reader.float();
|
|
break;
|
|
case "i":
|
|
message.i = reader.int64();
|
|
break;
|
|
case "d":
|
|
message.d = reader.double();
|
|
break;
|
|
case "s":
|
|
message.s = reader.bytes();
|
|
break;
|
|
case "t":
|
|
message.t = mind_ir.TensorProto.decodeText(reader);
|
|
break;
|
|
case "g":
|
|
message.g = mind_ir.GraphProto.decodeText(reader);
|
|
break;
|
|
case "floats":
|
|
reader.array(message.floats, () => reader.float());
|
|
break;
|
|
case "doubles":
|
|
reader.array(message.doubles, () => reader.double());
|
|
break;
|
|
case "ints":
|
|
reader.array(message.ints, () => reader.int64());
|
|
break;
|
|
case "strings":
|
|
reader.array(message.strings, () => reader.bytes());
|
|
break;
|
|
case "tensors":
|
|
message.tensors.push(mind_ir.TensorProto.decodeText(reader));
|
|
break;
|
|
case "graphs":
|
|
message.graphs.push(mind_ir.GraphProto.decodeText(reader));
|
|
break;
|
|
case "doc_string":
|
|
message.doc_string = reader.string();
|
|
break;
|
|
case "ref_attr_name":
|
|
message.ref_attr_name = reader.string();
|
|
break;
|
|
case "type":
|
|
message.type = reader.enum(mind_ir.AttributeProto.AttributeType);
|
|
break;
|
|
case "values":
|
|
message.values.push(mind_ir.AttributeProto.decodeText(reader));
|
|
break;
|
|
case "seq_info":
|
|
message.seq_info = mind_ir.AttributeProto.SeqInfoProto.decodeText(reader);
|
|
break;
|
|
case "functor":
|
|
message.functor = mind_ir.FunctorProto.decodeText(reader);
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
mind_ir.AttributeProto.prototype.name = "";
|
|
mind_ir.AttributeProto.prototype.f = 0;
|
|
mind_ir.AttributeProto.prototype.i = 0n;
|
|
mind_ir.AttributeProto.prototype.d = 0;
|
|
mind_ir.AttributeProto.prototype.s = new Uint8Array([]);
|
|
mind_ir.AttributeProto.prototype.t = null;
|
|
mind_ir.AttributeProto.prototype.g = null;
|
|
mind_ir.AttributeProto.prototype.doc_string = "";
|
|
mind_ir.AttributeProto.prototype.ref_attr_name = "";
|
|
mind_ir.AttributeProto.prototype.type = 0;
|
|
mind_ir.AttributeProto.prototype.seq_info = null;
|
|
mind_ir.AttributeProto.prototype.functor = null;
|
|
|
|
mind_ir.AttributeProto.AttributeType = {
|
|
"UNDEFINED": 0,
|
|
"FLOAT": 1,
|
|
"UINT8": 2,
|
|
"INT8": 3,
|
|
"UINT16": 4,
|
|
"INT16": 5,
|
|
"INT32": 6,
|
|
"INT64": 7,
|
|
"STRING": 8,
|
|
"BOOL": 9,
|
|
"FLOAT16": 10,
|
|
"DOUBLE": 11,
|
|
"UINT32": 12,
|
|
"UINT64": 13,
|
|
"COMPLEX64": 14,
|
|
"COMPLEX128": 15,
|
|
"BFLOAT16": 16,
|
|
"TENSOR": 17,
|
|
"GRAPH": 18,
|
|
"TENSORS": 19,
|
|
"TUPLE": 20,
|
|
"LIST": 21,
|
|
"DICT": 22,
|
|
"UMONAD": 23,
|
|
"IOMONAD": 24,
|
|
"NONE": 25,
|
|
"PRIMITIVECLOSURE": 26,
|
|
"FUNCGRAPHCLOSURE": 27,
|
|
"PARTIALCLOSURE": 28,
|
|
"UNIONFUNCCLOSURE": 29,
|
|
"CSR_TENSOR": 30,
|
|
"COO_TENSOR": 31,
|
|
"ROW_TENSOR": 32,
|
|
"CLASS_TYPE": 33,
|
|
"NAME_SPACE": 34,
|
|
"SYMBOL": 35,
|
|
"TYPE_NULL": 36,
|
|
"MAP_TENSOR": 37,
|
|
"FUNCTOR": 38,
|
|
"SCALAR": 39
|
|
};
|
|
|
|
mind_ir.AttributeProto.SeqInfoProto = class SeqInfoProto {
|
|
|
|
static decode(reader, length) {
|
|
const message = new mind_ir.AttributeProto.SeqInfoProto();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.is_dyn_len = reader.bool();
|
|
break;
|
|
case 2:
|
|
message.tuple_elem_item = mind_ir.AttributeProto.decode(reader, reader.uint32());
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new mind_ir.AttributeProto.SeqInfoProto();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "is_dyn_len":
|
|
message.is_dyn_len = reader.bool();
|
|
break;
|
|
case "tuple_elem_item":
|
|
message.tuple_elem_item = mind_ir.AttributeProto.decodeText(reader);
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
mind_ir.AttributeProto.SeqInfoProto.prototype.is_dyn_len = false;
|
|
mind_ir.AttributeProto.SeqInfoProto.prototype.tuple_elem_item = null;
|
|
|
|
mind_ir.FunctorProto = class FunctorProto {
|
|
|
|
constructor() {
|
|
this.values = [];
|
|
}
|
|
|
|
static decode(reader, length) {
|
|
const message = new mind_ir.FunctorProto();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.type = reader.int32();
|
|
break;
|
|
case 2:
|
|
message.name = reader.string();
|
|
break;
|
|
case 3:
|
|
message.values.push(mind_ir.AttributeProto.decode(reader, reader.uint32()));
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new mind_ir.FunctorProto();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "type":
|
|
message.type = reader.enum(mind_ir.FunctorProto.FunctorType);
|
|
break;
|
|
case "name":
|
|
message.name = reader.string();
|
|
break;
|
|
case "values":
|
|
message.values.push(mind_ir.AttributeProto.decodeText(reader));
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
mind_ir.FunctorProto.prototype.type = 1;
|
|
mind_ir.FunctorProto.prototype.name = "";
|
|
|
|
mind_ir.FunctorProto.FunctorType = {
|
|
"SHAPE_CALC_FUNCTOR": 1
|
|
};
|
|
|
|
mind_ir.ValueInfoProto = class ValueInfoProto {
|
|
|
|
constructor() {
|
|
this.tensor = [];
|
|
}
|
|
|
|
static decode(reader, length) {
|
|
const message = new mind_ir.ValueInfoProto();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.name = reader.string();
|
|
break;
|
|
case 2:
|
|
message.tensor.push(mind_ir.TensorProto.decode(reader, reader.uint32()));
|
|
break;
|
|
case 3:
|
|
message.doc_string = reader.string();
|
|
break;
|
|
case 4:
|
|
message.denotation = reader.string();
|
|
break;
|
|
case 5:
|
|
message.attr_info = mind_ir.AttributeProto.decode(reader, reader.uint32());
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new mind_ir.ValueInfoProto();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "name":
|
|
message.name = reader.string();
|
|
break;
|
|
case "tensor":
|
|
message.tensor.push(mind_ir.TensorProto.decodeText(reader));
|
|
break;
|
|
case "doc_string":
|
|
message.doc_string = reader.string();
|
|
break;
|
|
case "denotation":
|
|
message.denotation = reader.string();
|
|
break;
|
|
case "attr_info":
|
|
message.attr_info = mind_ir.AttributeProto.decodeText(reader);
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
mind_ir.ValueInfoProto.prototype.name = "";
|
|
mind_ir.ValueInfoProto.prototype.doc_string = "";
|
|
mind_ir.ValueInfoProto.prototype.denotation = "";
|
|
mind_ir.ValueInfoProto.prototype.attr_info = null;
|
|
|
|
mind_ir.NodeProto = class NodeProto {
|
|
|
|
constructor() {
|
|
this.input = [];
|
|
this.output = [];
|
|
this.attribute = [];
|
|
this.node_attr = [];
|
|
this.primal_attr = [];
|
|
}
|
|
|
|
static decode(reader, length) {
|
|
const message = new mind_ir.NodeProto();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.input.push(reader.string());
|
|
break;
|
|
case 2:
|
|
message.output.push(reader.string());
|
|
break;
|
|
case 3:
|
|
message.name = reader.string();
|
|
break;
|
|
case 4:
|
|
message.op_type = reader.string();
|
|
break;
|
|
case 5:
|
|
message.attribute.push(mind_ir.AttributeProto.decode(reader, reader.uint32()));
|
|
break;
|
|
case 6:
|
|
message.doc_string = reader.string();
|
|
break;
|
|
case 7:
|
|
message.domain = reader.string();
|
|
break;
|
|
case 8:
|
|
message.node_attr.push(mind_ir.AttributeProto.decode(reader, reader.uint32()));
|
|
break;
|
|
case 9:
|
|
message.primal_attr.push(mind_ir.AttributeProto.decode(reader, reader.uint32()));
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new mind_ir.NodeProto();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "input":
|
|
reader.array(message.input, () => reader.string());
|
|
break;
|
|
case "output":
|
|
reader.array(message.output, () => reader.string());
|
|
break;
|
|
case "name":
|
|
message.name = reader.string();
|
|
break;
|
|
case "op_type":
|
|
message.op_type = reader.string();
|
|
break;
|
|
case "attribute":
|
|
message.attribute.push(mind_ir.AttributeProto.decodeText(reader));
|
|
break;
|
|
case "doc_string":
|
|
message.doc_string = reader.string();
|
|
break;
|
|
case "domain":
|
|
message.domain = reader.string();
|
|
break;
|
|
case "node_attr":
|
|
message.node_attr.push(mind_ir.AttributeProto.decodeText(reader));
|
|
break;
|
|
case "primal_attr":
|
|
message.primal_attr.push(mind_ir.AttributeProto.decodeText(reader));
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
mind_ir.NodeProto.prototype.name = "";
|
|
mind_ir.NodeProto.prototype.op_type = "";
|
|
mind_ir.NodeProto.prototype.doc_string = "";
|
|
mind_ir.NodeProto.prototype.domain = "";
|
|
|
|
mind_ir.ModelProto = class ModelProto {
|
|
|
|
constructor() {
|
|
this.functions = [];
|
|
this.primitives = [];
|
|
this.user_info = {};
|
|
}
|
|
|
|
static decode(reader, length) {
|
|
const message = new mind_ir.ModelProto();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.ir_version = reader.string();
|
|
break;
|
|
case 2:
|
|
message.producer_name = reader.string();
|
|
break;
|
|
case 3:
|
|
message.producer_version = reader.string();
|
|
break;
|
|
case 4:
|
|
message.domain = reader.string();
|
|
break;
|
|
case 5:
|
|
message.model_version = reader.string();
|
|
break;
|
|
case 6:
|
|
message.doc_string = reader.string();
|
|
break;
|
|
case 7:
|
|
message.graph = mind_ir.GraphProto.decode(reader, reader.uint32());
|
|
break;
|
|
case 8:
|
|
message.functions.push(mind_ir.GraphProto.decode(reader, reader.uint32()));
|
|
break;
|
|
case 9:
|
|
message.preprocessor = mind_ir.PreprocessorProto.decode(reader, reader.uint32());
|
|
break;
|
|
case 10:
|
|
message.little_endian = reader.bool();
|
|
break;
|
|
case 11:
|
|
message.parallel = mind_ir.ParallelProto.decode(reader, reader.uint32());
|
|
break;
|
|
case 12:
|
|
message.primitives.push(mind_ir.PrimitiveProto.decode(reader, reader.uint32()));
|
|
break;
|
|
case 13:
|
|
message.mind_ir_version = reader.int64();
|
|
break;
|
|
case 14:
|
|
reader.entry(message.user_info, () => reader.string(), () => reader.string());
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new mind_ir.ModelProto();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "ir_version":
|
|
message.ir_version = reader.string();
|
|
break;
|
|
case "producer_name":
|
|
message.producer_name = reader.string();
|
|
break;
|
|
case "producer_version":
|
|
message.producer_version = reader.string();
|
|
break;
|
|
case "domain":
|
|
message.domain = reader.string();
|
|
break;
|
|
case "model_version":
|
|
message.model_version = reader.string();
|
|
break;
|
|
case "doc_string":
|
|
message.doc_string = reader.string();
|
|
break;
|
|
case "graph":
|
|
message.graph = mind_ir.GraphProto.decodeText(reader);
|
|
break;
|
|
case "functions":
|
|
message.functions.push(mind_ir.GraphProto.decodeText(reader));
|
|
break;
|
|
case "preprocessor":
|
|
message.preprocessor = mind_ir.PreprocessorProto.decodeText(reader);
|
|
break;
|
|
case "little_endian":
|
|
message.little_endian = reader.bool();
|
|
break;
|
|
case "parallel":
|
|
message.parallel = mind_ir.ParallelProto.decodeText(reader);
|
|
break;
|
|
case "primitives":
|
|
message.primitives.push(mind_ir.PrimitiveProto.decodeText(reader));
|
|
break;
|
|
case "mind_ir_version":
|
|
message.mind_ir_version = reader.int64();
|
|
break;
|
|
case "user_info":
|
|
reader.entry(message.user_info, () => reader.string(), () => reader.string());
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
mind_ir.ModelProto.prototype.ir_version = "";
|
|
mind_ir.ModelProto.prototype.producer_name = "";
|
|
mind_ir.ModelProto.prototype.producer_version = "";
|
|
mind_ir.ModelProto.prototype.domain = "";
|
|
mind_ir.ModelProto.prototype.model_version = "";
|
|
mind_ir.ModelProto.prototype.doc_string = "";
|
|
mind_ir.ModelProto.prototype.graph = null;
|
|
mind_ir.ModelProto.prototype.preprocessor = null;
|
|
mind_ir.ModelProto.prototype.little_endian = false;
|
|
mind_ir.ModelProto.prototype.parallel = null;
|
|
mind_ir.ModelProto.prototype.mind_ir_version = 0n;
|
|
|
|
mind_ir.PreprocessorProto = class PreprocessorProto {
|
|
|
|
constructor() {
|
|
this.op = [];
|
|
}
|
|
|
|
static decode(reader, length) {
|
|
const message = new mind_ir.PreprocessorProto();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.op.push(mind_ir.PreprocessOpProto.decode(reader, reader.uint32()));
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new mind_ir.PreprocessorProto();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "op":
|
|
message.op.push(mind_ir.PreprocessOpProto.decodeText(reader));
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
mind_ir.PreprocessOpProto = class PreprocessOpProto {
|
|
|
|
static decode(reader, length) {
|
|
const message = new mind_ir.PreprocessOpProto();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.input_columns = reader.string();
|
|
break;
|
|
case 2:
|
|
message.output_columns = reader.string();
|
|
break;
|
|
case 3:
|
|
message.project_columns = reader.string();
|
|
break;
|
|
case 4:
|
|
message.op_type = reader.string();
|
|
break;
|
|
case 5:
|
|
message.operations = reader.string();
|
|
break;
|
|
case 6:
|
|
message.offload = reader.bool();
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new mind_ir.PreprocessOpProto();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "input_columns":
|
|
message.input_columns = reader.string();
|
|
break;
|
|
case "output_columns":
|
|
message.output_columns = reader.string();
|
|
break;
|
|
case "project_columns":
|
|
message.project_columns = reader.string();
|
|
break;
|
|
case "op_type":
|
|
message.op_type = reader.string();
|
|
break;
|
|
case "operations":
|
|
message.operations = reader.string();
|
|
break;
|
|
case "offload":
|
|
message.offload = reader.bool();
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
mind_ir.PreprocessOpProto.prototype.input_columns = "";
|
|
mind_ir.PreprocessOpProto.prototype.output_columns = "";
|
|
mind_ir.PreprocessOpProto.prototype.project_columns = "";
|
|
mind_ir.PreprocessOpProto.prototype.op_type = "";
|
|
mind_ir.PreprocessOpProto.prototype.operations = "";
|
|
mind_ir.PreprocessOpProto.prototype.offload = false;
|
|
|
|
mind_ir.GraphProto = class GraphProto {
|
|
|
|
constructor() {
|
|
this.node = [];
|
|
this.parameter = [];
|
|
this.input = [];
|
|
this.output = [];
|
|
this.attribute = [];
|
|
this.map_parameter = [];
|
|
}
|
|
|
|
static decode(reader, length) {
|
|
const message = new mind_ir.GraphProto();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.node.push(mind_ir.NodeProto.decode(reader, reader.uint32()));
|
|
break;
|
|
case 2:
|
|
message.name = reader.string();
|
|
break;
|
|
case 3:
|
|
message.parameter.push(mind_ir.TensorProto.decode(reader, reader.uint32()));
|
|
break;
|
|
case 4:
|
|
message.doc_string = reader.string();
|
|
break;
|
|
case 5:
|
|
message.input.push(mind_ir.ValueInfoProto.decode(reader, reader.uint32()));
|
|
break;
|
|
case 6:
|
|
message.output.push(mind_ir.ValueInfoProto.decode(reader, reader.uint32()));
|
|
break;
|
|
case 7:
|
|
message.bprop_hash = reader.string();
|
|
break;
|
|
case 8:
|
|
message.attribute.push(mind_ir.AttributeProto.decode(reader, reader.uint32()));
|
|
break;
|
|
case 9:
|
|
message.bprop_filepath = reader.string();
|
|
break;
|
|
case 10:
|
|
message.map_parameter.push(mind_ir.MapTensorProto.decode(reader, reader.uint32()));
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new mind_ir.GraphProto();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "node":
|
|
message.node.push(mind_ir.NodeProto.decodeText(reader));
|
|
break;
|
|
case "name":
|
|
message.name = reader.string();
|
|
break;
|
|
case "parameter":
|
|
message.parameter.push(mind_ir.TensorProto.decodeText(reader));
|
|
break;
|
|
case "doc_string":
|
|
message.doc_string = reader.string();
|
|
break;
|
|
case "input":
|
|
message.input.push(mind_ir.ValueInfoProto.decodeText(reader));
|
|
break;
|
|
case "output":
|
|
message.output.push(mind_ir.ValueInfoProto.decodeText(reader));
|
|
break;
|
|
case "bprop_hash":
|
|
message.bprop_hash = reader.string();
|
|
break;
|
|
case "attribute":
|
|
message.attribute.push(mind_ir.AttributeProto.decodeText(reader));
|
|
break;
|
|
case "bprop_filepath":
|
|
message.bprop_filepath = reader.string();
|
|
break;
|
|
case "map_parameter":
|
|
message.map_parameter.push(mind_ir.MapTensorProto.decodeText(reader));
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
mind_ir.GraphProto.prototype.name = "";
|
|
mind_ir.GraphProto.prototype.doc_string = "";
|
|
mind_ir.GraphProto.prototype.bprop_hash = "";
|
|
mind_ir.GraphProto.prototype.bprop_filepath = "";
|
|
|
|
mind_ir.TensorProto = class TensorProto {
|
|
|
|
constructor() {
|
|
this.dims = [];
|
|
this.float_data = [];
|
|
this.int32_data = [];
|
|
this.string_data = [];
|
|
this.int64_data = [];
|
|
this.double_data = [];
|
|
this.uint64_data = [];
|
|
this.min_dims = [];
|
|
this.max_dims = [];
|
|
this.quant_params = [];
|
|
}
|
|
|
|
static decode(reader, length) {
|
|
const message = new mind_ir.TensorProto();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.dims = reader.array(message.dims, () => reader.int64(), tag);
|
|
break;
|
|
case 2:
|
|
message.data_type = reader.int32();
|
|
break;
|
|
case 3:
|
|
message.float_data = reader.floats(message.float_data, tag);
|
|
break;
|
|
case 4:
|
|
message.int32_data = reader.array(message.int32_data, () => reader.int32(), tag);
|
|
break;
|
|
case 5:
|
|
message.string_data.push(reader.bytes());
|
|
break;
|
|
case 6:
|
|
message.int64_data = reader.array(message.int64_data, () => reader.int64(), tag);
|
|
break;
|
|
case 7:
|
|
message.name = reader.string();
|
|
break;
|
|
case 8:
|
|
message.doc_string = reader.string();
|
|
break;
|
|
case 9:
|
|
message.raw_data = reader.bytes();
|
|
break;
|
|
case 10:
|
|
message.double_data = reader.doubles(message.double_data, tag);
|
|
break;
|
|
case 11:
|
|
message.uint64_data = reader.array(message.uint64_data, () => reader.uint64(), tag);
|
|
break;
|
|
case 12:
|
|
message.external_data = mind_ir.TensorProto.ExternalDataProto.decode(reader, reader.uint32());
|
|
break;
|
|
case 13:
|
|
message.ref_key = reader.string();
|
|
break;
|
|
case 14:
|
|
message.min_dims = reader.array(message.min_dims, () => reader.int64(), tag);
|
|
break;
|
|
case 15:
|
|
message.max_dims = reader.array(message.max_dims, () => reader.int64(), tag);
|
|
break;
|
|
case 16:
|
|
message.compression_type = reader.int32();
|
|
break;
|
|
case 17:
|
|
message.quant_params.push(mind_ir.TensorProto.QuantParamProto.decode(reader, reader.uint32()));
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new mind_ir.TensorProto();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "dims":
|
|
reader.array(message.dims, () => reader.int64());
|
|
break;
|
|
case "data_type":
|
|
message.data_type = reader.int32();
|
|
break;
|
|
case "float_data":
|
|
reader.array(message.float_data, () => reader.float());
|
|
break;
|
|
case "int32_data":
|
|
reader.array(message.int32_data, () => reader.int32());
|
|
break;
|
|
case "string_data":
|
|
reader.array(message.string_data, () => reader.bytes());
|
|
break;
|
|
case "int64_data":
|
|
reader.array(message.int64_data, () => reader.int64());
|
|
break;
|
|
case "name":
|
|
message.name = reader.string();
|
|
break;
|
|
case "doc_string":
|
|
message.doc_string = reader.string();
|
|
break;
|
|
case "raw_data":
|
|
message.raw_data = reader.bytes();
|
|
break;
|
|
case "double_data":
|
|
reader.array(message.double_data, () => reader.double());
|
|
break;
|
|
case "uint64_data":
|
|
reader.array(message.uint64_data, () => reader.uint64());
|
|
break;
|
|
case "external_data":
|
|
message.external_data = mind_ir.TensorProto.ExternalDataProto.decodeText(reader);
|
|
break;
|
|
case "ref_key":
|
|
message.ref_key = reader.string();
|
|
break;
|
|
case "min_dims":
|
|
reader.array(message.min_dims, () => reader.int64());
|
|
break;
|
|
case "max_dims":
|
|
reader.array(message.max_dims, () => reader.int64());
|
|
break;
|
|
case "compression_type":
|
|
message.compression_type = reader.enum(mind_ir.TensorProto.CompressionType);
|
|
break;
|
|
case "quant_params":
|
|
message.quant_params.push(mind_ir.TensorProto.QuantParamProto.decodeText(reader));
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
mind_ir.TensorProto.prototype.data_type = 0;
|
|
mind_ir.TensorProto.prototype.name = "";
|
|
mind_ir.TensorProto.prototype.doc_string = "";
|
|
mind_ir.TensorProto.prototype.raw_data = new Uint8Array([]);
|
|
mind_ir.TensorProto.prototype.external_data = null;
|
|
mind_ir.TensorProto.prototype.ref_key = "";
|
|
mind_ir.TensorProto.prototype.compression_type = 0;
|
|
|
|
mind_ir.TensorProto.DataType = {
|
|
"UNDEFINED": 0,
|
|
"FLOAT": 1,
|
|
"UINT8": 2,
|
|
"INT8": 3,
|
|
"UINT16": 4,
|
|
"INT16": 5,
|
|
"INT32": 6,
|
|
"INT64": 7,
|
|
"STRING": 8,
|
|
"BOOL": 9,
|
|
"FLOAT16": 10,
|
|
"DOUBLE": 11,
|
|
"UINT32": 12,
|
|
"UINT64": 13,
|
|
"COMPLEX64": 14,
|
|
"COMPLEX128": 15,
|
|
"BFLOAT16": 16,
|
|
"FLOAT64": 17,
|
|
"QINT4X2": 18
|
|
};
|
|
|
|
mind_ir.TensorProto.CompressionType = {
|
|
"NO_COMPRESSION": 0,
|
|
"INDEXING": 1,
|
|
"SPARSE": 2,
|
|
"FSE": 3,
|
|
"BIT_PACKING": 4,
|
|
"FSE_INT": 5,
|
|
"FSE_INFER": 6
|
|
};
|
|
|
|
mind_ir.TensorProto.ExternalDataProto = class ExternalDataProto {
|
|
|
|
static decode(reader, length) {
|
|
const message = new mind_ir.TensorProto.ExternalDataProto();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.location = reader.string();
|
|
break;
|
|
case 2:
|
|
message.offset = reader.int64();
|
|
break;
|
|
case 3:
|
|
message.length = reader.int64();
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new mind_ir.TensorProto.ExternalDataProto();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "location":
|
|
message.location = reader.string();
|
|
break;
|
|
case "offset":
|
|
message.offset = reader.int64();
|
|
break;
|
|
case "length":
|
|
message.length = reader.int64();
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
mind_ir.TensorProto.ExternalDataProto.prototype.location = "";
|
|
mind_ir.TensorProto.ExternalDataProto.prototype.offset = 0n;
|
|
mind_ir.TensorProto.ExternalDataProto.prototype.length = 0n;
|
|
|
|
mind_ir.TensorProto.QuantParamProto = class QuantParamProto {
|
|
|
|
constructor() {
|
|
this.attribute = [];
|
|
}
|
|
|
|
static decode(reader, length) {
|
|
const message = new mind_ir.TensorProto.QuantParamProto();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.quant_algo_name = reader.string();
|
|
break;
|
|
case 2:
|
|
message.attribute.push(mind_ir.AttributeProto.decode(reader, reader.uint32()));
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
if (!Object.prototype.hasOwnProperty.call(message, 'quant_algo_name')) {
|
|
throw new Error("Expected 'quant_algo_name'.");
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new mind_ir.TensorProto.QuantParamProto();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "quant_algo_name":
|
|
message.quant_algo_name = reader.string();
|
|
break;
|
|
case "attribute":
|
|
message.attribute.push(mind_ir.AttributeProto.decodeText(reader));
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
if (!Object.prototype.hasOwnProperty.call(message, "quant_algo_name")) {
|
|
throw new Error("Expected 'quant_algo_name'.");
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
mind_ir.TensorProto.QuantParamProto.prototype.quant_algo_name = "";
|
|
|
|
mind_ir.MapTensorProto = class MapTensorProto {
|
|
|
|
static decode(reader, length) {
|
|
const message = new mind_ir.MapTensorProto();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.name = reader.string();
|
|
break;
|
|
case 2:
|
|
message.default_value = mind_ir.AttributeProto.decode(reader, reader.uint32());
|
|
break;
|
|
case 3:
|
|
message.key_tensor = mind_ir.TensorProto.decode(reader, reader.uint32());
|
|
break;
|
|
case 4:
|
|
message.value_tensor = mind_ir.TensorProto.decode(reader, reader.uint32());
|
|
break;
|
|
case 5:
|
|
message.status_tensor = mind_ir.TensorProto.decode(reader, reader.uint32());
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
if (!Object.prototype.hasOwnProperty.call(message, 'name')) {
|
|
throw new Error("Expected 'name'.");
|
|
}
|
|
if (!Object.prototype.hasOwnProperty.call(message, 'default_value')) {
|
|
throw new Error("Expected 'default_value'.");
|
|
}
|
|
if (!Object.prototype.hasOwnProperty.call(message, 'key_tensor')) {
|
|
throw new Error("Expected 'key_tensor'.");
|
|
}
|
|
if (!Object.prototype.hasOwnProperty.call(message, 'value_tensor')) {
|
|
throw new Error("Expected 'value_tensor'.");
|
|
}
|
|
if (!Object.prototype.hasOwnProperty.call(message, 'status_tensor')) {
|
|
throw new Error("Expected 'status_tensor'.");
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new mind_ir.MapTensorProto();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "name":
|
|
message.name = reader.string();
|
|
break;
|
|
case "default_value":
|
|
message.default_value = mind_ir.AttributeProto.decodeText(reader);
|
|
break;
|
|
case "key_tensor":
|
|
message.key_tensor = mind_ir.TensorProto.decodeText(reader);
|
|
break;
|
|
case "value_tensor":
|
|
message.value_tensor = mind_ir.TensorProto.decodeText(reader);
|
|
break;
|
|
case "status_tensor":
|
|
message.status_tensor = mind_ir.TensorProto.decodeText(reader);
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
if (!Object.prototype.hasOwnProperty.call(message, "name")) {
|
|
throw new Error("Expected 'name'.");
|
|
}
|
|
if (!Object.prototype.hasOwnProperty.call(message, "default_value")) {
|
|
throw new Error("Expected 'default_value'.");
|
|
}
|
|
if (!Object.prototype.hasOwnProperty.call(message, "key_tensor")) {
|
|
throw new Error("Expected 'key_tensor'.");
|
|
}
|
|
if (!Object.prototype.hasOwnProperty.call(message, "value_tensor")) {
|
|
throw new Error("Expected 'value_tensor'.");
|
|
}
|
|
if (!Object.prototype.hasOwnProperty.call(message, "status_tensor")) {
|
|
throw new Error("Expected 'status_tensor'.");
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
mind_ir.MapTensorProto.prototype.name = "";
|
|
mind_ir.MapTensorProto.prototype.default_value = null;
|
|
mind_ir.MapTensorProto.prototype.key_tensor = null;
|
|
mind_ir.MapTensorProto.prototype.value_tensor = null;
|
|
mind_ir.MapTensorProto.prototype.status_tensor = null;
|
|
|
|
mind_ir.ParallelProto = class ParallelProto {
|
|
|
|
constructor() {
|
|
this.layout = [];
|
|
}
|
|
|
|
static decode(reader, length) {
|
|
const message = new mind_ir.ParallelProto();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.layout.push(mind_ir.LayoutProto.decode(reader, reader.uint32()));
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new mind_ir.ParallelProto();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "layout":
|
|
message.layout.push(mind_ir.LayoutProto.decodeText(reader));
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
mind_ir.LayoutProto = class LayoutProto {
|
|
|
|
constructor() {
|
|
this.device_arrangement_int = [];
|
|
this.tensor_map_int = [];
|
|
this.slice_shape_int = [];
|
|
}
|
|
|
|
static decode(reader, length) {
|
|
const message = new mind_ir.LayoutProto();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.name = reader.string();
|
|
break;
|
|
case 2:
|
|
message.device_arrangement_int = reader.array(message.device_arrangement_int, () => reader.int64(), tag);
|
|
break;
|
|
case 3:
|
|
message.tensor_map_int = reader.array(message.tensor_map_int, () => reader.int64(), tag);
|
|
break;
|
|
case 4:
|
|
message.slice_shape_int = reader.array(message.slice_shape_int, () => reader.int64(), tag);
|
|
break;
|
|
case 5:
|
|
message.field_size = reader.int64();
|
|
break;
|
|
case 6:
|
|
message.uniform_split = reader.bool();
|
|
break;
|
|
case 7:
|
|
message.opt_shard_group = reader.string();
|
|
break;
|
|
case 8:
|
|
message.pipeline_shared = reader.bool();
|
|
break;
|
|
case 9:
|
|
message.is_send = reader.bool();
|
|
break;
|
|
case 10:
|
|
message.peer_rank = reader.int64();
|
|
break;
|
|
case 11:
|
|
message.sr_tag = reader.int64();
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new mind_ir.LayoutProto();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "name":
|
|
message.name = reader.string();
|
|
break;
|
|
case "device_arrangement_int":
|
|
reader.array(message.device_arrangement_int, () => reader.int64());
|
|
break;
|
|
case "tensor_map_int":
|
|
reader.array(message.tensor_map_int, () => reader.int64());
|
|
break;
|
|
case "slice_shape_int":
|
|
reader.array(message.slice_shape_int, () => reader.int64());
|
|
break;
|
|
case "field_size":
|
|
message.field_size = reader.int64();
|
|
break;
|
|
case "uniform_split":
|
|
message.uniform_split = reader.bool();
|
|
break;
|
|
case "opt_shard_group":
|
|
message.opt_shard_group = reader.string();
|
|
break;
|
|
case "pipeline_shared":
|
|
message.pipeline_shared = reader.bool();
|
|
break;
|
|
case "is_send":
|
|
message.is_send = reader.bool();
|
|
break;
|
|
case "peer_rank":
|
|
message.peer_rank = reader.int64();
|
|
break;
|
|
case "sr_tag":
|
|
message.sr_tag = reader.int64();
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
mind_ir.LayoutProto.prototype.name = "";
|
|
mind_ir.LayoutProto.prototype.field_size = 0n;
|
|
mind_ir.LayoutProto.prototype.uniform_split = false;
|
|
mind_ir.LayoutProto.prototype.opt_shard_group = "";
|
|
mind_ir.LayoutProto.prototype.pipeline_shared = false;
|
|
mind_ir.LayoutProto.prototype.is_send = false;
|
|
mind_ir.LayoutProto.prototype.peer_rank = 0n;
|
|
mind_ir.LayoutProto.prototype.sr_tag = 0n;
|
|
|
|
mind_ir.PrimitiveProto = class PrimitiveProto {
|
|
|
|
constructor() {
|
|
this.attribute = [];
|
|
}
|
|
|
|
static decode(reader, length) {
|
|
const message = new mind_ir.PrimitiveProto();
|
|
const end = length === undefined ? reader.length : reader.position + length;
|
|
while (reader.position < end) {
|
|
const tag = reader.uint32();
|
|
switch (tag >>> 3) {
|
|
case 1:
|
|
message.name = reader.string();
|
|
break;
|
|
case 2:
|
|
message.op_type = reader.string();
|
|
break;
|
|
case 3:
|
|
message.attribute.push(mind_ir.AttributeProto.decode(reader, reader.uint32()));
|
|
break;
|
|
case 4:
|
|
message.instance_name = reader.string();
|
|
break;
|
|
case 5:
|
|
message.prim_type = reader.int32();
|
|
break;
|
|
default:
|
|
reader.skipType(tag & 7);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
|
|
static decodeText(reader) {
|
|
const message = new mind_ir.PrimitiveProto();
|
|
reader.start();
|
|
while (!reader.end()) {
|
|
const tag = reader.tag();
|
|
switch (tag) {
|
|
case "name":
|
|
message.name = reader.string();
|
|
break;
|
|
case "op_type":
|
|
message.op_type = reader.string();
|
|
break;
|
|
case "attribute":
|
|
message.attribute.push(mind_ir.AttributeProto.decodeText(reader));
|
|
break;
|
|
case "instance_name":
|
|
message.instance_name = reader.string();
|
|
break;
|
|
case "prim_type":
|
|
message.prim_type = reader.enum(mind_ir.PrimitiveProto.PrimType);
|
|
break;
|
|
default:
|
|
reader.field(tag, message);
|
|
break;
|
|
}
|
|
}
|
|
return message;
|
|
}
|
|
};
|
|
|
|
mind_ir.PrimitiveProto.prototype.name = "";
|
|
mind_ir.PrimitiveProto.prototype.op_type = "";
|
|
mind_ir.PrimitiveProto.prototype.instance_name = "";
|
|
mind_ir.PrimitiveProto.prototype.prim_type = 1;
|
|
|
|
mind_ir.PrimitiveProto.PrimType = {
|
|
"PRIMITIVE": 1,
|
|
"PRIMITIVE_FUNCTION": 2
|
|
};
|