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
1130 lines
41 KiB
JavaScript
1130 lines
41 KiB
JavaScript
|
|
const cntk = {};
|
|
|
|
cntk.ModelFactory = class {
|
|
|
|
async match(context) {
|
|
const stream = context.stream;
|
|
// CNTK v1
|
|
const signature = [0x42, 0x00, 0x43, 0x00, 0x4e, 0x00, 0x00, 0x00];
|
|
if (stream && signature.length <= stream.length && stream.peek(signature.length).every((value, index) => value === signature[index])) {
|
|
return context.set('cntk.v1');
|
|
}
|
|
// CNTK v2
|
|
const tags = await context.tags('pb');
|
|
if (tags.get(1) === 0 && tags.get(2) === 2) {
|
|
return context.set('cntk.v2');
|
|
}
|
|
return null;
|
|
}
|
|
|
|
async open(context) {
|
|
const metadata = await context.metadata('cntk-metadata.json');
|
|
switch (context.type) {
|
|
case 'cntk.v1': {
|
|
let obj = null;
|
|
try {
|
|
const reader = await context.read('binary');
|
|
obj = new cntk.ComputationNetwork(reader);
|
|
} catch (error) {
|
|
const message = error && error.message ? error.message : error.toString();
|
|
throw new cntk.Error(`File format is not CNTK v1 (${message.replace(/\.$/, '')}).`);
|
|
}
|
|
return new cntk.Model(metadata, 1, obj);
|
|
}
|
|
case 'cntk.v2': {
|
|
cntk.proto = await context.require('./cntk-proto');
|
|
cntk.proto = cntk.proto.CNTK.proto;
|
|
cntk.proto.PoolingType = { 0: 'Max', 1: 'Average' };
|
|
let obj = null;
|
|
try {
|
|
const reader = await context.read('protobuf.binary');
|
|
const dictionary = cntk.proto.Dictionary.decode(reader);
|
|
obj = cntk.ModelFactory._convertDictionary(dictionary);
|
|
} catch (error) {
|
|
const message = error && error.message ? error.message : error.toString();
|
|
throw new cntk.Error(`File format is not cntk.Dictionary (${message.replace(/\.$/, '')}).`);
|
|
}
|
|
return new cntk.Model(metadata, 2, obj);
|
|
}
|
|
default: {
|
|
throw new cntk.Error(`Unsupported CNTK format '${context.type}'.`);
|
|
}
|
|
}
|
|
}
|
|
|
|
static _convertDictionary(dictionary) {
|
|
const target = {};
|
|
for (const key of Object.keys(dictionary.data).filter((key) => key !== 'version')) {
|
|
target[key] = cntk.ModelFactory._convertDictionaryValue(dictionary.data[key]);
|
|
}
|
|
return target;
|
|
}
|
|
|
|
static _convertDictionaryValue(dictionaryValue) {
|
|
switch (dictionaryValue.value_type) {
|
|
case cntk.proto.DictionaryValue.Type.Bool:
|
|
return dictionaryValue.bool_value;
|
|
case cntk.proto.DictionaryValue.Type.Int:
|
|
return dictionaryValue.int_value;
|
|
case cntk.proto.DictionaryValue.Type.SizeT:
|
|
return dictionaryValue.size_t_value;
|
|
case cntk.proto.DictionaryValue.Type.Float:
|
|
return dictionaryValue.float_value;
|
|
case cntk.proto.DictionaryValue.Type.Double:
|
|
return dictionaryValue.double_value;
|
|
case cntk.proto.DictionaryValue.Type.String:
|
|
return dictionaryValue.string_value;
|
|
case cntk.proto.DictionaryValue.Type.Vector:
|
|
return cntk.ModelFactory._convertVectorValue(dictionaryValue.vector_value);
|
|
case cntk.proto.DictionaryValue.Type.NDShape:
|
|
return dictionaryValue.nd_shape_value;
|
|
case cntk.proto.DictionaryValue.Type.Axis:
|
|
return dictionaryValue.axis_value;
|
|
case cntk.proto.DictionaryValue.Type.Dictionary:
|
|
return cntk.ModelFactory._convertDictionary(dictionaryValue.dictionary_value);
|
|
case cntk.proto.DictionaryValue.Type.NDArrayView:
|
|
return dictionaryValue.nd_array_view_value;
|
|
default:
|
|
throw new cntk.Error(`Unsupported dictionary value type '${dictionaryValue.value_type}'.`);
|
|
}
|
|
}
|
|
|
|
static _convertVectorValue(vectorValue) {
|
|
return vectorValue.value.map((item) => {
|
|
return cntk.ModelFactory._convertDictionaryValue(item);
|
|
});
|
|
}
|
|
};
|
|
|
|
cntk.Model = class {
|
|
|
|
constructor(metadata, version, obj) {
|
|
switch (version) {
|
|
case 1:
|
|
this.format = `CNTK v1${obj.version ? (`.${obj.version}`) : ''}`;
|
|
break;
|
|
case 2:
|
|
this.format = 'CNTK v2';
|
|
break;
|
|
default:
|
|
throw new cntk.Error(`Unsupported CNTK version '${version}'.`);
|
|
}
|
|
this.modules = [new cntk.Graph(metadata, version, obj)];
|
|
}
|
|
};
|
|
|
|
cntk.Graph = class {
|
|
|
|
constructor(metadata, version, obj) {
|
|
metadata = new cntk.GraphMetadata(metadata);
|
|
this.inputs = [];
|
|
this.outputs = [];
|
|
this.nodes = [];
|
|
const values = new Map();
|
|
values.map = (name, version, obj) => {
|
|
if (obj && values.has(name)) {
|
|
throw new cntk.Error(`Duplicate value '${name}'.`);
|
|
}
|
|
if (!values.has(name)) {
|
|
switch (version) {
|
|
case 1:
|
|
values.set(name, new cntk.Value(version, obj ? obj : { name }));
|
|
break;
|
|
case 2:
|
|
values.set(name, new cntk.Value(version, obj ? obj : { uid: name }));
|
|
break;
|
|
default:
|
|
throw new cntk.Error(`Unsupported CNTK version '${version}'.`);
|
|
}
|
|
}
|
|
return values.get(name);
|
|
};
|
|
switch (version) {
|
|
case 1: {
|
|
for (const name of Object.keys(obj.nodes)) {
|
|
const node = obj.nodes[name];
|
|
switch (node.__type__) {
|
|
case 'InputValue': {
|
|
const argument = new cntk.Argument(node.name, [values.map(node.name, version, node)]);
|
|
this.inputs.push(argument);
|
|
break;
|
|
}
|
|
case 'LearnableParameter': {
|
|
values.map(node.name, version, node);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
for (const name of Object.keys(obj.nodes)) {
|
|
const node = obj.nodes[name];
|
|
if (node.__type__ !== 'InputValue' && node.__type__ !== 'LearnableParameter') {
|
|
this.nodes.push(new cntk.Node(metadata, version, node, values));
|
|
}
|
|
}
|
|
if (obj.output) {
|
|
for (const output of obj.output) {
|
|
const argument = new cntk.Argument(output, [values.map(output, version)]);
|
|
this.outputs.push(argument);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case 2: {
|
|
const map = new Map(obj.primitive_functions.map((node) => [node.uid, node]));
|
|
for (const input of obj.inputs) {
|
|
const value = values.map(input.uid, version, input);
|
|
// VariableKind { 0: 'input', 1: 'output', 2: 'parameter', 3: 'constant', 4: 'placeholder' }
|
|
if (input.kind === 0n) {
|
|
const inputName = input.name || input.uid;
|
|
this.inputs.push(new cntk.Argument(inputName, [value]));
|
|
}
|
|
}
|
|
for (const block of obj.primitive_functions) {
|
|
if (block.op === 57n && block.block_function_composite) {
|
|
const list = [block.block_function_composite.root];
|
|
const output = map.get(block.block_function_composite.root);
|
|
const keys = block.block_function_composite_arguments_map_keys;
|
|
const args = block.block_function_composite_arguments_map_values;
|
|
block.inputs = args;
|
|
if (!Array.isArray(keys) || !Array.isArray(args) || keys.length !== args.length) {
|
|
throw new cntk.Error('Invalid block function composite arguments.');
|
|
}
|
|
const inputs = keys.map((key) => new cntk.Argument(key, [values.map(key, version)]));
|
|
const outputs = [new cntk.Argument('output', [values.map(`${output.uid}_Output_0`, version)])];
|
|
const nodes = [];
|
|
while (list.length > 0) {
|
|
const name = list.shift();
|
|
if (map.has(name)) {
|
|
const node = map.get(name);
|
|
nodes.push(new cntk.Node(metadata, version, node, values));
|
|
map.delete(name);
|
|
for (let i = 0; i < node.inputs.length; i++) {
|
|
const parts = node.inputs[i].split('_');
|
|
if (parts.length >= 3) {
|
|
parts.pop();
|
|
if (parts.pop() === 'Output') {
|
|
list.push(parts.join('_'));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const func = new cntk.Function(block.block_function_op_name, nodes, inputs, outputs);
|
|
metadata.add(block.uid, func);
|
|
}
|
|
}
|
|
for (const node of map.values()) {
|
|
this.nodes.push(new cntk.Node(metadata, version, node, values));
|
|
}
|
|
break;
|
|
}
|
|
default: {
|
|
throw new cntk.Error(`Unsupported graph version '${version}'.`);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
cntk.Argument = class {
|
|
|
|
constructor(name, value, type = null, visible = true) {
|
|
this.name = name;
|
|
this.value = value;
|
|
this.type = type;
|
|
this.visible = visible;
|
|
}
|
|
};
|
|
|
|
cntk.Value = class {
|
|
|
|
constructor(version, obj) {
|
|
switch (version) {
|
|
case 1:
|
|
switch (obj.__type__) {
|
|
case 'InputValue':
|
|
this.name = obj.name;
|
|
this.type = new cntk.TensorType(version, obj.precision, obj.sampleLayout);
|
|
this.initializer = null;
|
|
break;
|
|
case 'LearnableParameter':
|
|
this.name = obj.name;
|
|
this.initializer = new cntk.Tensor(version, obj);
|
|
this.type = this.initializer.type;
|
|
break;
|
|
default:
|
|
this.name = obj.name;
|
|
this.type = null;
|
|
this.initializer = null;
|
|
break;
|
|
}
|
|
break;
|
|
case 2:
|
|
if (obj.value) {
|
|
this.name = obj.name || obj.uid;
|
|
this.initializer = new cntk.Tensor(version, obj);
|
|
this.type = this.initializer.type;
|
|
} else {
|
|
this.name = obj.uid;
|
|
if (obj.data_type && obj.shape) {
|
|
this.type = new cntk.TensorType(version, obj.data_type, obj.shape);
|
|
}
|
|
this.initializer = null;
|
|
}
|
|
break;
|
|
default:
|
|
throw new cntk.Error(`Unsupported CNTK version '${version}'.`);
|
|
}
|
|
}
|
|
};
|
|
|
|
cntk.Node = class {
|
|
|
|
constructor(metadata, version, obj, values) {
|
|
this.attributes = [];
|
|
this.inputs = [];
|
|
this.outputs = [];
|
|
let inputs = [];
|
|
let outputs = [];
|
|
const attributes = [];
|
|
switch (version) {
|
|
case 1: {
|
|
const type = obj.__type__;
|
|
this.type = { name: type, ...metadata.type(type) };
|
|
delete this.type.identifier;
|
|
this.name = obj.name;
|
|
for (const [name, value] of Object.entries(obj)) {
|
|
if (name !== '__type__' && name !== 'name' && name !== 'inputs' && name !== 'precision') {
|
|
const schema = metadata.attribute(type, name);
|
|
attributes.push([schema, name, value]);
|
|
}
|
|
}
|
|
inputs = obj.inputs.map((input) => values.map(input, version));
|
|
outputs = [values.map(this.name, version)];
|
|
break;
|
|
}
|
|
case 2: {
|
|
this.name = obj.name || obj.uid || null;
|
|
const output = obj.uid;
|
|
if (obj.op === 57n) {
|
|
this.type = { name: obj.uid, ...metadata.type(obj.uid) };
|
|
delete this.type.identifier;
|
|
} else if (Object.prototype.hasOwnProperty.call(obj, 'op')) {
|
|
// cntk/Source/CNTKv2LibraryDll/API/Internals/PrimitiveOpType.h
|
|
const op = obj.op.toNumber();
|
|
this.type = { ...metadata.type(op) };
|
|
delete this.type.identifier;
|
|
} else {
|
|
const type = obj.type;
|
|
this.type = { name: type, ...metadata.type(type) };
|
|
delete this.type.identifier;
|
|
if (obj.user_defined_state) {
|
|
for (const [name, value] of Object.entries(obj.user_defined_state)) {
|
|
const schema = metadata.attribute(type, name);
|
|
attributes.push([schema, name, value]);
|
|
}
|
|
}
|
|
}
|
|
if (obj.attributes) {
|
|
for (const [name, value] of Object.entries(obj.attributes)) {
|
|
const schema = metadata.attribute(this.type, name);
|
|
attributes.push([schema, name, value]);
|
|
}
|
|
}
|
|
inputs = obj.inputs.map((input) => values.map(input, version));
|
|
outputs.push(values.map(`${output}_Output_0`, version));
|
|
break;
|
|
}
|
|
default: {
|
|
throw new cntk.Error(`Unsupported CNTK version '${version}'.`);
|
|
}
|
|
}
|
|
let inputIndex = 0;
|
|
if (this.type && this.type.inputs) {
|
|
for (const schema of this.type.inputs) {
|
|
if (inputIndex < inputs.length || schema.option !== 'optional') {
|
|
const count = schema.type === 'Tensor[]' ? (inputs.length - inputIndex) : 1;
|
|
const values = [];
|
|
for (const value of inputs.slice(inputIndex, inputIndex + count)) {
|
|
if (value.name !== '' || schema.option !== 'optional') {
|
|
values.push(value);
|
|
}
|
|
}
|
|
const argument = new cntk.Argument(schema.name, values);
|
|
this.inputs.push(argument);
|
|
inputIndex += count;
|
|
}
|
|
}
|
|
}
|
|
this.inputs.push(...inputs.slice(inputIndex).map((argument, index) => {
|
|
return new cntk.Argument((inputIndex + index).toString(), [argument]);
|
|
}));
|
|
let outputIndex = 0;
|
|
if (this.type && this.type.outputs) {
|
|
for (const schema of this.type.outputs) {
|
|
if (outputIndex < outputs.length || !schema.optional) {
|
|
const count = schema.type === 'Tensor[]' ? (outputs.length - outputIndex) : 1;
|
|
const values = outputs.slice(outputIndex, outputIndex + count);
|
|
const argument = new cntk.Argument(schema.name, values);
|
|
this.outputs.push(argument);
|
|
outputIndex += count;
|
|
}
|
|
}
|
|
}
|
|
this.outputs.push(...outputs.slice(outputIndex).map((argument) => {
|
|
return new cntk.Argument(outputIndex.toString(), [argument]);
|
|
}));
|
|
this.attributes = attributes.map(([metadata, name, value]) => {
|
|
let type = null;
|
|
let visible = true;
|
|
if (value && value.__type__ === 'shape') {
|
|
value = new cntk.TensorShape(1, value);
|
|
type = 'shape';
|
|
}
|
|
if (cntk.proto && value instanceof cntk.proto.NDShape) {
|
|
value = new cntk.TensorShape(2, value);
|
|
type = 'shape';
|
|
}
|
|
if (cntk.proto && value instanceof cntk.proto.Axis) {
|
|
const axis = { __type__: 'Axis' };
|
|
for (const key of Object.keys(value).filter((key) => key !== 'name')) {
|
|
axis[key] = value[key];
|
|
}
|
|
value = axis;
|
|
}
|
|
if (metadata) {
|
|
if (metadata.type) {
|
|
type = metadata.type;
|
|
const table = cntk[type] || cntk.proto[type];
|
|
if (table && table[value]) {
|
|
value = table[value];
|
|
}
|
|
}
|
|
if (metadata.visible === false) {
|
|
visible = false;
|
|
} else if (metadata.default !== undefined) {
|
|
const defaultValue = metadata.default;
|
|
if (typeof value === 'function') {
|
|
value = value();
|
|
}
|
|
if (type === 'shape') {
|
|
value = value.dimensions;
|
|
}
|
|
if (value === defaultValue) {
|
|
visible = false;
|
|
} else if (Array.isArray(value) && Array.isArray(defaultValue)) {
|
|
const repeat = defaultValue.length > 1 && defaultValue[defaultValue.length - 1] === null;
|
|
if (value.every((item, index) => item === (repeat && index >= defaultValue.length - 1 ? defaultValue[defaultValue.length - 2] : defaultValue[index]))) {
|
|
visible = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return new cntk.Argument(name, value, type, visible);
|
|
});
|
|
}
|
|
};
|
|
|
|
cntk.Tensor = class {
|
|
|
|
constructor(version, tensor) {
|
|
this.encoding = '|';
|
|
this.values = null;
|
|
switch (version) {
|
|
case 1: {
|
|
if (tensor.__type__ === 'LearnableParameter') {
|
|
this.name = tensor.name || null;
|
|
this.type = new cntk.TensorType(version, tensor.precision, tensor.sampleLayout);
|
|
}
|
|
break;
|
|
}
|
|
case 2: {
|
|
this.name = tensor.name || tensor.uid || null;
|
|
this.type = new cntk.TensorType(version, tensor.data_type, tensor.shape);
|
|
const value = tensor.value;
|
|
if (this.type.dataType === 'float32' && value && value.float_values && value.float_values.value && value.float_values.value.length > 0) {
|
|
this.values = value.float_values.value;
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
throw new cntk.Error(`Unsupported CNTK version '${version}'.`);
|
|
}
|
|
}
|
|
};
|
|
|
|
cntk.TensorType = class {
|
|
|
|
constructor(version, dataType, shape) {
|
|
this.dataType = '?';
|
|
switch (version) {
|
|
case 1:
|
|
switch (dataType) {
|
|
case 'float': this.dataType = 'float32'; break;
|
|
case 'double': this.dataType = 'float64'; break;
|
|
case 'half': this.dataType = 'float16'; break;
|
|
case '': this.dataType = 'float32'; break;
|
|
default: throw new cntk.Error(`Unsupported tensor data type '${dataType}'.`);
|
|
}
|
|
this.shape = new cntk.TensorShape(version, shape);
|
|
break;
|
|
case 2:
|
|
switch (dataType) {
|
|
case 1n: this.dataType = 'float32'; break;
|
|
default: throw new cntk.Error(`Unsupported tensor data type '${dataType}'.`);
|
|
}
|
|
this.shape = new cntk.TensorShape(version, shape);
|
|
break;
|
|
default:
|
|
throw new cntk.Error(`Unsupported CNTK version '${version}'.`);
|
|
}
|
|
}
|
|
|
|
toString() {
|
|
return this.dataType + this.shape.toString();
|
|
}
|
|
};
|
|
|
|
cntk.TensorShape = class {
|
|
|
|
constructor(version, shape) {
|
|
switch (version) {
|
|
case 1:
|
|
this.dimensions = shape.dims;
|
|
break;
|
|
case 2:
|
|
this.dimensions = shape.shape_dim.map((dimension) => dimension.toNumber());
|
|
break;
|
|
default:
|
|
throw new cntk.Error(`Unsupported CNTK version '${version}'.`);
|
|
}
|
|
}
|
|
|
|
toString() {
|
|
return (this.dimensions && this.dimensions.length) ? (`[${this.dimensions.join(',')}]`) : '';
|
|
}
|
|
};
|
|
|
|
cntk.Function = class {
|
|
|
|
constructor(name, nodes, inputs, outputs) {
|
|
this.type = 'function';
|
|
this.name = name;
|
|
this.inputs = inputs;
|
|
this.outputs = outputs;
|
|
this.nodes = nodes;
|
|
switch (this.name) {
|
|
case 'PReLU':
|
|
case 'Softmax':
|
|
this.category = 'Activation';
|
|
break;
|
|
case 'Dropout':
|
|
this.category = 'Dropout';
|
|
break;
|
|
case 'Convolution':
|
|
case 'ConvolutionTranspose':
|
|
case 'Dense':
|
|
case 'linear':
|
|
case 'LSTM':
|
|
this.category = 'Layer';
|
|
break;
|
|
case 'BatchNormalization':
|
|
case 'lrn':
|
|
this.category = 'Normalization';
|
|
break;
|
|
case 'AveragePooling':
|
|
case 'MaxPooling':
|
|
this.category = 'Pool';
|
|
break;
|
|
default:
|
|
this.category = null;
|
|
break;
|
|
}
|
|
}
|
|
};
|
|
|
|
cntk.GraphMetadata = class {
|
|
|
|
constructor(metadata) {
|
|
this._metadata = metadata;
|
|
this._functions = new Map();
|
|
this._attributes = new Map();
|
|
}
|
|
|
|
add(name, func) {
|
|
if (this._functions.has(name)) {
|
|
throw new cntk.Error(`Duplicate function identifier '${func.name}'.`);
|
|
}
|
|
this._functions.set(name, func);
|
|
}
|
|
|
|
name(code) {
|
|
// cntk/Source/CNTKv2LibraryDll/API/Internals/PrimitiveOpType.h
|
|
return this._metadata.name(code);
|
|
}
|
|
|
|
type(name) {
|
|
if (this._functions.has(name)) {
|
|
return this._functions.get(name);
|
|
}
|
|
return this._metadata.type(name);
|
|
}
|
|
|
|
attribute(type, name) {
|
|
const key = `${type}:${name}`;
|
|
if (!this._attributes.has(key)) {
|
|
const metadata = this.type(type);
|
|
if (metadata && metadata.attributes && metadata.attributes.length > 0) {
|
|
for (const attribute of metadata.attributes) {
|
|
this._attributes.set(`${type}:${attribute.name}`, attribute);
|
|
}
|
|
}
|
|
if (!this._attributes.has(key)) {
|
|
this._attributes.set(key, null);
|
|
}
|
|
}
|
|
return this._attributes.get(key);
|
|
}
|
|
};
|
|
|
|
cntk.ComputationNetwork = class {
|
|
|
|
constructor(reader) {
|
|
reader = new cntk.BinaryReader(reader);
|
|
const shape = (dims) => {
|
|
return { __type__: 'shape', dims };
|
|
};
|
|
reader.assert('BCN');
|
|
reader.assert('BVersion');
|
|
this.version = reader.uint64().toNumber();
|
|
reader.assert('EVersion');
|
|
const numNodes = reader.uint64().toNumber();
|
|
reader.assert('BNodeList');
|
|
const op = {};
|
|
op.Minus = function() {};
|
|
op.Plus = function() {};
|
|
op.GreaterEqual = function() {};
|
|
op.Equal = function() {};
|
|
op.NotEqual = function() {};
|
|
op.GreaterEqual = function() {};
|
|
op.Exp = function() {};
|
|
op.Log = function() {};
|
|
op.Reciprocal = function() {};
|
|
op.ElementTimes = function() {};
|
|
op.ClassificationError = function() {};
|
|
op.RectifiedLinear = function() {};
|
|
op.InputValue = function(reader, version) {
|
|
this.rows = reader.uint64().toNumber();
|
|
this.cols = reader.uint64().toNumber();
|
|
this.sampleLayout = reader.shape(true);
|
|
this.dynamicAxisNodeName = '';
|
|
if (version >= 8) {
|
|
const nrAxes = reader.uint32();
|
|
if (nrAxes === 1) {
|
|
this.dynamicAxisNodeName = reader.string();
|
|
}
|
|
}
|
|
this.learningRateMultiplier = 0;
|
|
if (version >= 10) {
|
|
this.learningRateMultiplier = reader.float32();
|
|
}
|
|
};
|
|
op.LearnableParameter = function(reader, version) {
|
|
if (version >= 3) {
|
|
this.learningRateMultiplier = reader.float32();
|
|
this.sampleLayout = reader.shape(false);
|
|
} else {
|
|
throw new cntk.Error('LeanableParameter reader implemented.');
|
|
}
|
|
this.value = reader.matrix();
|
|
};
|
|
op.CrossEntropyWithSoftmax = function(reader) {
|
|
this.evalMode = reader.uint32();
|
|
if (this.evalMode > 2) {
|
|
this.evalMode = 0;
|
|
reader.skip(-4);
|
|
}
|
|
};
|
|
op.Times = function(reader, version) {
|
|
this.outputRank = (version >= 3) ? reader.uint64().toNumber() : 1;
|
|
this.inferInputRankToMap = (version >= 12) ? reader.int32() : -1;
|
|
};
|
|
op.Dropout = function(reader, version) {
|
|
if (version >= 16) {
|
|
this.rngSeed = (version === 16) ? reader.uint32() : reader.uint64().toNumber();
|
|
this.rngOffset = reader.uint64().toNumber();
|
|
}
|
|
};
|
|
op.ConvolutionBase = function(reader, version) {
|
|
if (version >= 5) {
|
|
this.kernelShape = reader.shape(false);
|
|
this.mapCount = reader.shape(false);
|
|
this.strides = reader.shape(false);
|
|
this.sharing = reader.booleans();
|
|
this.autoPadding = reader.booleans();
|
|
this.lowerPad = reader.shape(false);
|
|
this.upperPad = reader.shape(false);
|
|
this.poolKind = reader.int32();
|
|
this.imageLayoutKind = reader.int32();
|
|
this.maxTempMemSizeInSamples = reader.uint64().toNumber();
|
|
}
|
|
if (version >= 9) {
|
|
this.transpose = reader.boolean();
|
|
}
|
|
if (version >= 20) {
|
|
this.outputShape = reader.shape(false);
|
|
}
|
|
if (version >= 21) {
|
|
this.ceilOutDim = reader.boolean();
|
|
}
|
|
if (version >= 23) {
|
|
this.includePad = reader.boolean();
|
|
}
|
|
};
|
|
op.Convolution = function(reader, version) {
|
|
op.ConvolutionBase.apply(this, [reader, version]);
|
|
if (version < 5) {
|
|
this.kernelShape = shape([reader.uint64().toNumber(), reader.uint64().toNumber(), 1]);
|
|
this.strides = shape([reader.uint64().toNumber(), reader.uint64().toNumber(), 1]);
|
|
this.mapCount = shape([reader.uint32()]);
|
|
this.imageLayoutKind = reader.int32();
|
|
this.autoPadding = [reader.boolean()];
|
|
this.maxTempMemSizeInSamples = reader.uint64().toNumber();
|
|
this.poolKind = 'None';
|
|
this.convolution2D = true;
|
|
this.sharing = [true];
|
|
this.lowerPad = shape([0]);
|
|
this.upperPad = shape([0]);
|
|
} else {
|
|
this.convolution2D = reader.boolean();
|
|
if (version >= 18) {
|
|
this.dilation = reader.shape();
|
|
} else {
|
|
this.dilation = shape([1]);
|
|
}
|
|
}
|
|
};
|
|
op.Pooling = function(reader, version) {
|
|
op.ConvolutionBase.apply(this, [reader, version]);
|
|
};
|
|
op.PoolingBase = function(reader) {
|
|
this.imageLayoutKind = reader.int32();
|
|
this.windowWidth = reader.uint32();
|
|
this.windowHeight = reader.uint64().toNumber();
|
|
this.horizontalSubsample = reader.uint64().toNumber();
|
|
this.verticalSubsample = reader.uint64().toNumber();
|
|
};
|
|
op.MaxPooling = function(reader, version) {
|
|
op.PoolingBase.apply(this, [reader, version]);
|
|
};
|
|
op.ROIPooling = function(reader, version) {
|
|
this.roiOutputShape = reader.shape(false);
|
|
this.poolKind = (version < 26) ? 'Max' : reader.int32();
|
|
this.spatialScale = (version < 26) ? 0.0625 : reader.float64();
|
|
};
|
|
op.Reshape = function(reader) {
|
|
this.beginDimParameter = reader.uint32();
|
|
this.endDimParameter = reader.uint32();
|
|
this.replacementSampleLayout = reader.shape(false);
|
|
};
|
|
op.ReduceElements = function(reader, version) {
|
|
let num_axes = 1;
|
|
if (version >= 27) {
|
|
num_axes = reader.uint32();
|
|
}
|
|
this.axes = [];
|
|
for (let i = 0; i < num_axes; i++) {
|
|
this.axes.push(reader.uint32());
|
|
}
|
|
this.operation = reader.string();
|
|
if (version >= 24) {
|
|
this.keepDimensions = reader.boolean();
|
|
}
|
|
};
|
|
op.BatchNormalization = function(reader, version) {
|
|
let mbCount = 0;
|
|
if (version >= 6) {
|
|
this.spatial = reader.boolean();
|
|
this.normalizationTimeConstant = reader.float64();
|
|
this.blendTimeConstant = reader.float64();
|
|
this.imageLayoutKind = reader.int32();
|
|
if (version >= 13) {
|
|
if (version === 19) {
|
|
this.runCountUntied = reader.boolean() ? 0 : 'SIZE_MAX';
|
|
} else {
|
|
this.runCountUntied = reader.uint64().toNumber();
|
|
}
|
|
} else {
|
|
mbCount = reader.uint64().toNumber();
|
|
}
|
|
this.epsilon = reader.float64();
|
|
this.useCntkEngine = reader.boolean();
|
|
} else {
|
|
const verWritten = reader.int32();
|
|
const verReadable = reader.int32();
|
|
if (verReadable > verWritten || verWritten < 0x00010001 || verReadable > 0x00010004) {
|
|
throw new cntk.Error('BatchNormalization version not supported.');
|
|
}
|
|
this.eval = reader.boolean();
|
|
this.spatial = reader.boolean();
|
|
if (verWritten >= 0x00010004) {
|
|
this.normalizationTimeConstant = reader.float64();
|
|
} else {
|
|
reader.float64(); // expAvgFactor
|
|
}
|
|
if (verWritten >= 0x00010002) {
|
|
this.imageLayoutKind = reader.int32();
|
|
mbCount = reader.uint64().toNumber();
|
|
}
|
|
if (verWritten >= 0x00010003) {
|
|
this.epsilon = reader.float64();
|
|
this.useCntkEngine = reader.boolean();
|
|
}
|
|
}
|
|
if (version < 13) {
|
|
this.runCountUntied = 16 * mbCount;
|
|
this.convertRunningVariancePending = true;
|
|
}
|
|
};
|
|
op.Tanh = function() {};
|
|
op.Sigmoid = function() {};
|
|
op.Logistic = function() {};
|
|
op.SquareError = function() {};
|
|
op.ErrorPrediction = function() {};
|
|
op.RowStack = function(reader, version) {
|
|
this.spliceDim = (version >= 3) ? reader.int32() : 1;
|
|
};
|
|
op.Slice = function(reader, version) {
|
|
let num = 1;
|
|
if (version >= 22) {
|
|
num = reader.int32();
|
|
}
|
|
this.index = [];
|
|
this.axis = [];
|
|
this.strideMultiplier = [];
|
|
for (let i = 0; i < num; i++) {
|
|
this.index.push([[reader.uint64().toNumber(), reader.uint64().toNumber()]]);
|
|
if (version >= 3) {
|
|
this.axis.push(reader.int32());
|
|
}
|
|
if (version >= 27) {
|
|
this.strideMultiplier.push(reader.int32());
|
|
}
|
|
}
|
|
};
|
|
op.PastValue = function(reader, version) {
|
|
this.timeStep = reader.int32();
|
|
if (version > 3) {
|
|
this.sampleLayout = reader.shape(false);
|
|
} else {
|
|
const rows = reader.uint64().toNumber();
|
|
reader.uint64();
|
|
this.sampleLayout = shape([rows], true);
|
|
}
|
|
if (version >= 2) {
|
|
this.initialStateValue = reader.int32();
|
|
}
|
|
};
|
|
op.FutureValue = function(reader, version) {
|
|
this.timeStep = reader.int32();
|
|
if (version > 3) {
|
|
this.sampleLayout = reader.shape(false);
|
|
} else {
|
|
const rows = reader.uint64().toNumber();
|
|
reader.uint64();
|
|
this.sampleLayout = shape([rows], true);
|
|
}
|
|
if (version >= 2) {
|
|
this.initialStateValue = reader.int32();
|
|
}
|
|
};
|
|
op.TransposeDimensions = function(reader, version) {
|
|
if (version >= 3) {
|
|
this.axis1 = reader.int32();
|
|
this.axis2 = reader.int32();
|
|
if (version >= 25 && this.axis1 === 0 && this.axis2 === 0) {
|
|
const size = reader.uint64().toNumber();
|
|
this.perm = [];
|
|
for (let i = 0; i < size; i++) {
|
|
this.perm.push(reader.uint64().toNumber());
|
|
}
|
|
}
|
|
} else {
|
|
this.axis1 = 1;
|
|
this.axis2 = 2;
|
|
}
|
|
};
|
|
op.AveragePooling = function(reader, version) {
|
|
op.PoolingBase.apply(this, [reader, version]);
|
|
};
|
|
op.InvStdDev = function(reader) {
|
|
this.hasComputed = reader.boolean();
|
|
this.value = reader.matrix();
|
|
};
|
|
op.Mean = function(reader) {
|
|
this.hasComputed = reader.boolean();
|
|
this.value = reader.matrix();
|
|
};
|
|
op.PerDimMeanVarNormalization = function() {};
|
|
op.Softmax = function() {};
|
|
op.DynamicAxis = function() {};
|
|
|
|
const nodes = [];
|
|
this.nodes = {};
|
|
for (let i = 0; i < numNodes; i++) {
|
|
const precision = this.version >= 7 ? reader.string() : '';
|
|
if (precision !== 'float' && precision !== 'double' && precision !== 'half' && precision !== '') {
|
|
throw new cntk.Error(`Invalid precision format '${precision}'.`);
|
|
}
|
|
const obj = { __type__: reader.string() };
|
|
obj.name = reader.string();
|
|
obj.precision = precision;
|
|
const constructor = op[obj.__type__];
|
|
if (!constructor) {
|
|
throw new cntk.Error(`Unsupported node type '${obj.__type__}'.`);
|
|
}
|
|
constructor.apply(obj, [reader, this.version]);
|
|
nodes.push(obj);
|
|
this.nodes[obj.name] = obj;
|
|
}
|
|
reader.assert('ENodeList');
|
|
reader.assert('BRelation');
|
|
for (let j = 0; j < numNodes; j++) {
|
|
const nodeName = reader.string();
|
|
const node = this.nodes[nodeName];
|
|
const numChildren = reader.uint64().toNumber();
|
|
const children = [];
|
|
for (let k = 0; k < numChildren; k++) {
|
|
children.push(reader.string());
|
|
}
|
|
if (this.version < 19 && node.__type__ === 'BatchNormalization') {
|
|
const runSampleCount = {
|
|
__type__: 'LearnableParameter',
|
|
name: `${nodeName}.run_sample_count`,
|
|
precision: node.precision,
|
|
sampleLayout: shape([1]),
|
|
learningRateMultiplier: 0
|
|
};
|
|
nodes.push(runSampleCount);
|
|
this.nodes[runSampleCount.name] = runSampleCount;
|
|
children.push(runSampleCount.name);
|
|
}
|
|
if (node.__type__ === 'Convolution' && children.length > 1) {
|
|
children.splice(0, 0, children.pop());
|
|
}
|
|
node.inputs = children;
|
|
}
|
|
reader.assert('ERelation');
|
|
reader.assert('BRootNodes');
|
|
if (reader.match('BFeatureNodes')) {
|
|
this.feature = reader.strings();
|
|
reader.assert('EFeatureNodes');
|
|
}
|
|
if (reader.match('BLabelNodes')) {
|
|
this.label = reader.strings();
|
|
reader.assert('ELabelNodes');
|
|
}
|
|
if (reader.match('BCriterionNodes')) {
|
|
this.criterion = reader.strings();
|
|
reader.assert('ECriterionNodes');
|
|
}
|
|
if (this.criterion.length === 0) {
|
|
if (reader.match('BCriteriaNodes')) {
|
|
this.criterion = reader.strings();
|
|
reader.assert('ECriteriaNodes');
|
|
}
|
|
}
|
|
if (reader.match('BNodesReqMultiSeqHandling')) {
|
|
reader.strings();
|
|
reader.assert('ENodesReqMultiSeqHandling');
|
|
}
|
|
if (reader.match('BEvalNodes')) {
|
|
this.eval = reader.strings();
|
|
reader.assert('EEvalNodes');
|
|
}
|
|
if (reader.match('BOutputNodes')) {
|
|
this.output = reader.strings();
|
|
reader.assert('EOutputNodes');
|
|
}
|
|
if (reader.match('BPairNodes')) {
|
|
this.pair = reader.strings();
|
|
reader.assert('EPairNodes');
|
|
}
|
|
reader.assert('ERootNodes');
|
|
reader.assert('ECN');
|
|
}
|
|
};
|
|
|
|
cntk.BinaryReader = class {
|
|
|
|
constructor(reader) {
|
|
this._reader = reader;
|
|
}
|
|
|
|
get position() {
|
|
return this._reader.position;
|
|
}
|
|
|
|
seek(offset) {
|
|
this._reader.seek(offset);
|
|
}
|
|
|
|
skip(offset) {
|
|
this._reader.skip(offset);
|
|
}
|
|
|
|
read(length) {
|
|
return this._reader.read(length);
|
|
}
|
|
|
|
boolean() {
|
|
return this._reader.boolean();
|
|
}
|
|
|
|
byte() {
|
|
return this._reader.byte();
|
|
}
|
|
|
|
int32() {
|
|
return this._reader.int32();
|
|
}
|
|
|
|
uint16() {
|
|
return this._reader.uint16();
|
|
}
|
|
|
|
uint32() {
|
|
return this._reader.uint32();
|
|
}
|
|
|
|
uint64() {
|
|
return this._reader.uint64();
|
|
}
|
|
|
|
float32() {
|
|
return this._reader.float32();
|
|
}
|
|
|
|
float64() {
|
|
return this._reader.float64();
|
|
}
|
|
|
|
match(text) {
|
|
const position = this.position;
|
|
for (let i = 0; i < text.length; i++) {
|
|
if (this.uint16() !== text.charCodeAt(i)) {
|
|
this.seek(position);
|
|
return false;
|
|
}
|
|
}
|
|
if (this.uint16() !== 0) {
|
|
this.seek(position);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
assert(text) {
|
|
if (!this.match(text)) {
|
|
throw new cntk.Error(`Invalid '${text}' signature.`);
|
|
}
|
|
}
|
|
|
|
string() {
|
|
const content = [];
|
|
let c = this.uint16();
|
|
while (c !== 0) {
|
|
content.push(String.fromCharCode(c));
|
|
c = this.uint16();
|
|
}
|
|
return content.join('');
|
|
}
|
|
|
|
strings() {
|
|
const size = this.uint64().toNumber();
|
|
const array = new Array(size);
|
|
for (let i = 0; i < size; i++) {
|
|
array[i] = this.string();
|
|
}
|
|
return array;
|
|
}
|
|
|
|
booleans() {
|
|
const size = this.uint64().toNumber();
|
|
const array = new Array(size);
|
|
for (let i = 0; i < size; i++) {
|
|
array[i] = this.boolean();
|
|
}
|
|
return array;
|
|
}
|
|
|
|
matrix() {
|
|
const type = this.byte();
|
|
switch (type) {
|
|
case 100: {
|
|
// dense
|
|
this.assert('BMAT');
|
|
const elsize = this.uint64().toNumber();
|
|
const value = {};
|
|
value.name = this.string();
|
|
value.format = this.uint32();
|
|
value.rows = this.uint64().toNumber();
|
|
value.columns = this.uint64().toNumber();
|
|
this.read(elsize * value.rows * value.columns);
|
|
this.assert('EMAT');
|
|
return value;
|
|
}
|
|
case 115: // sparse
|
|
throw new cntk.Error('Matrix sparse type not implemented.');
|
|
default:
|
|
throw new cntk.Error(`Matrix type '${type}' not implemented.`);
|
|
}
|
|
}
|
|
|
|
shape(acceptLegacyFormat) {
|
|
const dims = [];
|
|
const rank = this.uint32();
|
|
let dim0 = 0;
|
|
if (rank > 0) {
|
|
dim0 = this.uint32();
|
|
}
|
|
if (!acceptLegacyFormat || dim0 !== 0) {
|
|
if (rank > 0) {
|
|
dims.push(dim0);
|
|
}
|
|
for (let i = 1; i < rank; i++) {
|
|
dims.push(this.uint32());
|
|
}
|
|
} else {
|
|
const dim = this.uint32();
|
|
dims.push(this.uint32());
|
|
dims.push(rank);
|
|
dims.push(dim);
|
|
}
|
|
return { __type__: 'shape', dims };
|
|
}
|
|
};
|
|
|
|
cntk.ImageLayoutKind = {
|
|
0: 'CHW',
|
|
1: 'HWC'
|
|
};
|
|
|
|
cntk.PoolKind = {
|
|
0: 'None',
|
|
1: 'Max',
|
|
2: 'Average'
|
|
};
|
|
|
|
cntk.Error = class extends Error {
|
|
|
|
constructor(message) {
|
|
super(message);
|
|
this.name = 'Error loading CNTK model.';
|
|
}
|
|
};
|
|
|
|
export const ModelFactory = cntk.ModelFactory;
|