Replace type strings with tensor types (#71)

lutzroeder · lutzroeder · commit badd7e6f85b0 · 2018-08-19T15:29:11.000-07:00
diff --git a/src/caffe-model.js b/src/caffe-model.js
@@ -118,7 +118,7 @@ class CaffeGraph {
                 this._inputs.push({
                     id: input,
                     name: input,
-                    type: 'T'
+                    type: null
                 });
             });
         }
@@ -155,15 +155,15 @@ class CaffeGraph {
                 this._outputs.push({
                     id: keys[0],
                     name: keys[0],
-                    type: 'T'
+                    type: null
                 });
             }
             else if (outputs.length == 1) {
                 outputs[0]._outputs = [ 'output' ];
                 this._outputs.push({
                     id: 'output',
                     name: 'output',
-                    type: 'T'
+                    type: null
                 });
             }
         }
@@ -294,7 +294,7 @@ class CaffeNode {
             input.connections.forEach((connection) => {
                 if (connection.id instanceof CaffeTensor) {
                     connection.initializer = connection.id;
-                    connection.type = connection.initializer.type.toString();
+                    connection.type = connection.initializer.type;
                     connection.id = '';
                 }
             });
diff --git a/src/caffe2-model.js b/src/caffe2-model.js
@@ -117,7 +117,7 @@ class Caffe2Graph {
                 this._inputs.push({
                     id: input,
                     name: input,
-                    type: 'T'
+                    type: null
                 });
             }
         });
@@ -127,7 +127,7 @@ class Caffe2Graph {
             this._outputs.push({ 
                 id: output,
                 name: output,
-                type: 'T'
+                type: null
             });
         });
     }
@@ -214,7 +214,7 @@ class Caffe2Node {
                 var initializer = this._initializers[connection.id];
                 if (initializer) {
                     connection.initializer = initializer;
-                    connection.type = initializer.type.toString();
+                    connection.type = initializer.type;
                 }
             });
         });
diff --git a/src/coreml-model.js b/src/coreml-model.js
@@ -378,13 +378,13 @@ class CoreMLGraph {
                 result = 'image(' + CoreMLGraph.formatColorSpace(type.imageType.colorSpace) + ',' + type.imageType.width.toString() + 'x' + type.imageType.height.toString() + ')';
                 break;
             case 'dictionaryType':
-                result = 'map<' + type.dictionaryType.KeyType.replace('KeyType', '') + ',double>';
+                result = 'map<' + type.dictionaryType.KeyType.replace('KeyType', '') + ',float64>';
                 break;
             case 'stringType':
                 result = 'string';
                 break;
             case 'doubleType':
-                result = 'double';
+                result = 'float64';
                 break;
             case 'int64Type':
                 result = 'int64';
@@ -477,7 +477,7 @@ class CoreMLNode {
                 name: initializer.name,
                 connections: [ { 
                     id: '',
-                    type: initializer.type.toString(),
+                    type: initializer.type,
                     initializer: initializer, } ]
             };
             if (!CoreMLOperatorMetadata.operatorMetadata.getInputVisible(this._operator, initializer.name)) {
diff --git a/src/keras-model.js b/src/keras-model.js
@@ -281,7 +281,7 @@ class KerasGraph {
                 if (addGraphOutput) {
                     this._outputs.push({
                         id: inputName,
-                        type: 'T',
+                        type: null,
                         name: inputName
                     });
                 }
@@ -340,7 +340,7 @@ class KerasGraph {
         if (connection) {
             this._outputs.push({ 
                 id: connection,
-                type: 'T',
+                type: null,
                 name: connection
             });
         }
@@ -363,19 +363,20 @@ class KerasGraph {
     }
 
     _loadInput(layer, input) {
-        input.type = '';
+        input.type = null;
         if (layer && layer.config) {
+            var dataType = '?';
+            var shape = [];
             var config = layer.config;
             if (config.dtype) {
-                input.type = config.dtype;
+                dataType = config.dtype;
                 delete config.dtype;
             }
             if (config.batch_input_shape) {
-                var shape = config.batch_input_shape;
-                shape = shape.map(s => s == null ? '?' : s).join(',');
-                input.type = input.type + '[' + shape + ']';
+                shape = config.batch_input_shape.map(s => s == null ? '?' : s);
                 delete config.batch_input_shape;
             }
+            input.type = new KerasTensorType(dataType, shape);
         }
     }
 }
@@ -471,7 +472,7 @@ class KerasNode {
             input.connections.forEach((connection) => {
                 var initializer = this._initializers[connection.id];
                 if (initializer) {
-                    connection.type = initializer.type.toString();
+                    connection.type = initializer.type;
                     connection.initializer = initializer;
                 }
             });
diff --git a/src/mxnet-model.js b/src/mxnet-model.js
@@ -293,10 +293,10 @@ class MXNetGraph {
             var output = {};
             output.id = MXNetGraph._updateOutput(nodes, head);
             output.name = nodes[output.id[0]] ? nodes[output.id[0]].name : ('output' + ((index == 0) ? '' : (index + 1).toString()));
-            output.type = 'T';
+            output.type = null;
             var outputSignature = outputs[output.name];
             if (outputSignature && outputSignature.data_shape) {
-                output.type = '?' + '[' + outputSignature.data_shape.toString() + ']';
+                output.type = new MXNetTensorType(null, outputSignature.data_shape);
             }
             this._outputs.push(output);
         });
@@ -315,10 +315,10 @@ class MXNetGraph {
                 var input = {};
                 input.id = argument.outputs[0];
                 input.name = argument.name;
-                input.type = 'T';
+                input.type = null;
                 var inputSignature = inputs[input.name];
                 if (inputSignature && inputSignature.data_shape) {
-                    input.type = '?' + '[' + inputSignature.data_shape.toString() + ']';
+                    input.type = new MXNetTensorType(null, inputSignature.data_shape);
                 }
                 this._inputs.push(input);
             }
@@ -464,7 +464,7 @@ class MXNetNode {
                 var initializer = this._initializers[connection.id];
                 if (initializer) {
                     connection.id = initializer.name || connection.id;
-                    connection.type = initializer.type.toString();
+                    connection.type = initializer.type;
                     connection.initializer = initializer;
                 }
             });
@@ -674,7 +674,7 @@ class MXNetTensorType {
     }
 
     toString() {
-        return this.dataType + (this._shape ? ('[' + this._shape.map((dimension) => dimension.toString()).join(',') + ']') : '');
+        return (this.dataType || '?') + (this._shape ? ('[' + this._shape.map((dimension) => dimension.toString()).join(',') + ']') : '');
     }
 }
 
diff --git a/src/onnx-model.js b/src/onnx-model.js
@@ -252,7 +252,7 @@ class OnnxGraph {
                             var initializer = this._initializerMap[connection.id];
                             if (initializer) {
                                 connection.initializer = initializer;
-                                connection.type = connection.type || initializer.type.toString();
+                                connection.type = connection.type || initializer.type;
                             }
                             return connection;
                         });
@@ -499,6 +499,7 @@ class OnnxTensor {
         this._tensor = tensor;
         this._id = id;
         this._kind = kind || null;
+        this._type = new OnnxTensorType(this._tensor.dataType, this._tensor.dims.map((dim) => dim), null);
     }
 
     get id() {
@@ -514,7 +515,7 @@ class OnnxTensor {
     }
 
     get type() {
-        return new OnnxTensorType(this._tensor);
+        return this._type;
     }
 
     get value() {
@@ -744,37 +745,8 @@ class OnnxTensor {
 
     static _formatType(type, imageFormat) {
         if (!type) {
-            return { value: '?' };
+            return null;
         }
-        var value = {};
-        switch (type.value) {
-            case 'tensorType':
-                var tensorType = type.tensorType;
-                var text = OnnxTensor._formatElementType(tensorType.elemType); 
-                if (tensorType.shape && tensorType.shape.dim) {
-                    text += '[' + tensorType.shape.dim.map((dimension) => {
-                        if (dimension.dimParam) {
-                            return dimension.dimParam;
-                        }
-                        return dimension.dimValue.toString();
-                    }).join(',') + ']';
-                }
-                value = text;
-                break;
-            case 'mapType':
-                var keyType = OnnxTensor._formatElementType(type.mapType.keyType);
-                var valueType = OnnxTensor._formatType(type.mapType.valueType);
-                value = 'map<' + keyType + ',' + valueType.value + '>';
-                break;
-            case 'sequenceType':
-                var elemType = OnnxTensor._formatType(type.sequenceType.elemType);
-                value = 'sequence<' + elemType.value + '>';
-                break;
-            default:
-                // debugger
-                value = '?';
-                break;
-            }
         var denotation = '';
         switch (type.denotation) {
             case 'TENSOR':
@@ -790,21 +762,30 @@ class OnnxTensor {
                 denotation = 'Text';
                 break;
         }
-        return { value: value, denotation: denotation };
+        switch (type.value) {
+            case 'tensorType':
+                var shape = [];
+                if (type.tensorType.shape && type.tensorType.shape.dim) {
+                    shape = type.tensorType.shape.dim.map((dim) => {
+                        return dim.dimParam ? dim.dimParam : dim.dimValue;
+                    });
+                }                
+                return new OnnxTensorType(type.tensorType.elemType, shape, denotation);
+            case 'mapType':
+                return new OnnxMapType(type.mapType.keyType, OnnxTensor._formatType(type.mapType.valueType, imageFormat), denotation);
+            case 'sequenceType':
+                return new OnnxSequenceType(OnnxTensor._formatType(type.sequenceType.elemType, imageFormat), denotation);
+        }
+        return null;
     }
 }
 
 class OnnxTensorType {
 
-    constructor(tensor) {
-        this._dataType = '?';
-        if (tensor.hasOwnProperty('dataType')) {
-            this._dataType = OnnxTensor._formatElementType(tensor.dataType);
-        }
-        this._shape = [];
-        if (tensor.hasOwnProperty('dims')) { 
-            this._shape = tensor.dims.map((dimension) => dimension);
-        }
+    constructor(dataType, shape, denotation) {
+        this._dataType = OnnxTensor._formatElementType(dataType);
+        this._shape = shape;
+        this._denotation = denotation || null;
     }
 
     get dataType() {
@@ -815,10 +796,58 @@ class OnnxTensorType {
         return this._shape;
     }
 
+    get denotation() { 
+        return this._denotation;
+    }
+
     toString() {
-        return this.dataType + (this._shape ? ('[' + this._shape.map((dimension) => dimension.toString()).join(',') + ']') : '');
+        return this.dataType + ((this._shape && this._shape.length) ? ('[' + this._shape.join(',') + ']') : '');
     }
+}
+
+class OnnxSequenceType {
+
+    constructor(elementType, denotation) {
+        this._elementType = elementType;
+        this._denotation = denotation;
+    }
+
+    get elementType() {
+        return this._elementType;
+    }
+
+    get dennotation() {
+        return this._dennotation;
+    }
+
+    toString() {
+        return 'sequence<' + this._elementType.toString() + '>';
+    }
+}
 
+class OnnxMapType {
+
+    constructor(keyType, valueType, denotation) {
+        this._keyType = OnnxTensor._formatElementType(keyType);
+        this._valueType = valueType;
+        this._denotation = denotation;
+    }
+
+    get keyType() {
+        return this._keyType;
+    }
+
+    get valueType() {
+        return this._valueType;
+    }
+
+    get denotation() {
+        return this._denotation;
+    }
+
+    toString() {
+        return 'map<' + this._keyType + ',' + this._valueType.toString() + '>';
+    }
 }
 
 class OnnxGraphOperatorMetadata {
diff --git a/src/tf-model.js b/src/tf-model.js
@@ -414,7 +414,7 @@ class TensorFlowNode {
                 input.connections.forEach((connection) => {
                     var initializer = this._graph._getInitializer(connection.id);
                     if (initializer) {
-                        connection.type = initializer.type.toString();
+                        connection.type = initializer.type;
                         connection.initializer = initializer;
                     }
                 });
@@ -503,9 +503,6 @@ class TensorFlowAttribute {
             return TensorFlowTensor.formatTensorShape(value.shape);
         }
         else if (value.hasOwnProperty('s')) {
-            if (value.s.length == 0) {
-                return '';
-            }
             if (value.s.filter(c => c <= 32 && c >= 128).length == 0) {
                 return '"' + TensorFlowOperatorMetadata.textDecoder.decode(value.s) + '"';
             }
@@ -581,6 +578,7 @@ class TensorFlowTensor {
         if (kind) {
             this._kind = kind;
         }
+        this._type = new TensorFlowTensorType(this._tensor.dtype, this._tensor.tensorShape);
     }
 
     get id() {
@@ -592,7 +590,7 @@ class TensorFlowTensor {
     }
 
     get type() {
-        return new TensorFlowTensorType(this._tensor.dtype, this._tensor.tensorShape);
+        return this._type;
     }
 
     get kind() {
diff --git a/src/tflite-model.js b/src/tflite-model.js
diff --git a/src/view-sidebar.js b/src/view-sidebar.js
diff --git a/src/view.js b/src/view.js

Original file line number	Diff line number	Diff line change
`@@ -281,7 +281,7 @@ class KerasGraph {`
`281`	`281`	`if (addGraphOutput) {`
`282`	`282`	`this._outputs.push({`
`283`	`283`	`id: inputName,`
`284`		`- type: 'T',`
	`284`	`+ type: null,`
`285`	`285`	`name: inputName`
`286`	`286`	`});`
`287`	`287`	`}`
`@@ -340,7 +340,7 @@ class KerasGraph {`
`340`	`340`	`if (connection) {`
`341`	`341`	`this._outputs.push({`
`342`	`342`	`id: connection,`
`343`		`- type: 'T',`
	`343`	`+ type: null,`
`344`	`344`	`name: connection`
`345`	`345`	`});`
`346`	`346`	`}`
`@@ -363,19 +363,20 @@ class KerasGraph {`
`363`	`363`	`}`
`364`	`364`
`365`	`365`	`_loadInput(layer, input) {`
`366`		`- input.type = '';`
	`366`	`+ input.type = null;`
`367`	`367`	`if (layer && layer.config) {`
	`368`	`+ var dataType = '?';`
	`369`	`+ var shape = [];`
`368`	`370`	`var config = layer.config;`
`369`	`371`	`if (config.dtype) {`
`370`		`- input.type = config.dtype;`
	`372`	`+ dataType = config.dtype;`
`371`	`373`	`delete config.dtype;`
`372`	`374`	`}`
`373`	`375`	`if (config.batch_input_shape) {`
`374`		`- var shape = config.batch_input_shape;`
`375`		`- shape = shape.map(s => s == null ? '?' : s).join(',');`
`376`		`- input.type = input.type + '[' + shape + ']';`
	`376`	`+ shape = config.batch_input_shape.map(s => s == null ? '?' : s);`
`377`	`377`	`delete config.batch_input_shape;`
`378`	`378`	`}`
	`379`	`+ input.type = new KerasTensorType(dataType, shape);`
`379`	`380`	`}`
`380`	`381`	`}`
`381`	`382`	`}`
`@@ -471,7 +472,7 @@ class KerasNode {`
`471`	`472`	`input.connections.forEach((connection) => {`
`472`	`473`	`var initializer = this._initializers[connection.id];`
`473`	`474`	`if (initializer) {`
`474`		`- connection.type = initializer.type.toString();`
	`475`	`+ connection.type = initializer.type;`
`475`	`476`	`connection.initializer = initializer;`
`476`	`477`	`}`
`477`	`478`	`});`
Original file line number	Diff line number	Diff line change
`@@ -293,10 +293,10 @@ class MXNetGraph {`
`293`	`293`	`var output = {};`
`294`	`294`	`output.id = MXNetGraph._updateOutput(nodes, head);`
`295`	`295`	`output.name = nodes[output.id[0]] ? nodes[output.id[0]].name : ('output' + ((index == 0) ? '' : (index + 1).toString()));`
`296`		`- output.type = 'T';`
	`296`	`+ output.type = null;`
`297`	`297`	`var outputSignature = outputs[output.name];`
`298`	`298`	`if (outputSignature && outputSignature.data_shape) {`
`299`		`- output.type = '?' + '[' + outputSignature.data_shape.toString() + ']';`
	`299`	`+ output.type = new MXNetTensorType(null, outputSignature.data_shape);`
`300`	`300`	`}`
`301`	`301`	`this._outputs.push(output);`
`302`	`302`	`});`
`@@ -315,10 +315,10 @@ class MXNetGraph {`
`315`	`315`	`var input = {};`
`316`	`316`	`input.id = argument.outputs[0];`
`317`	`317`	`input.name = argument.name;`
`318`		`- input.type = 'T';`
	`318`	`+ input.type = null;`
`319`	`319`	`var inputSignature = inputs[input.name];`
`320`	`320`	`if (inputSignature && inputSignature.data_shape) {`
`321`		`- input.type = '?' + '[' + inputSignature.data_shape.toString() + ']';`
	`321`	`+ input.type = new MXNetTensorType(null, inputSignature.data_shape);`
`322`	`322`	`}`
`323`	`323`	`this._inputs.push(input);`
`324`	`324`	`}`
`@@ -464,7 +464,7 @@ class MXNetNode {`
`464`	`464`	`var initializer = this._initializers[connection.id];`
`465`	`465`	`if (initializer) {`
`466`	`466`	`connection.id = initializer.name \|\| connection.id;`
`467`		`- connection.type = initializer.type.toString();`
	`467`	`+ connection.type = initializer.type;`
`468`	`468`	`connection.initializer = initializer;`
`469`	`469`	`}`
`470`	`470`	`});`
`@@ -674,7 +674,7 @@ class MXNetTensorType {`
`674`	`674`	`}`
`675`	`675`
`676`	`676`	`toString() {`
`677`		`- return this.dataType + (this._shape ? ('[' + this._shape.map((dimension) => dimension.toString()).join(',') + ']') : '');`
	`677`	`+ return (this.dataType \|\| '?') + (this._shape ? ('[' + this._shape.map((dimension) => dimension.toString()).join(',') + ']') : '');`
`678`	`678`	`}`
`679`	`679`	`}`
`680`	`680`
Original file line number	Diff line number	Diff line change
`@@ -414,7 +414,7 @@ class TensorFlowNode {`
`414`	`414`	`input.connections.forEach((connection) => {`
`415`	`415`	`var initializer = this._graph._getInitializer(connection.id);`
`416`	`416`	`if (initializer) {`
`417`		`- connection.type = initializer.type.toString();`
	`417`	`+ connection.type = initializer.type;`
`418`	`418`	`connection.initializer = initializer;`
`419`	`419`	`}`
`420`	`420`	`});`
`@@ -503,9 +503,6 @@ class TensorFlowAttribute {`
`503`	`503`	`return TensorFlowTensor.formatTensorShape(value.shape);`
`504`	`504`	`}`
`505`	`505`	`else if (value.hasOwnProperty('s')) {`
`506`		`- if (value.s.length == 0) {`
`507`		`- return '';`
`508`		`- }`
`509`	`506`	`if (value.s.filter(c => c <= 32 && c >= 128).length == 0) {`
`510`	`507`	`return '"' + TensorFlowOperatorMetadata.textDecoder.decode(value.s) + '"';`
`511`	`508`	`}`
`@@ -581,6 +578,7 @@ class TensorFlowTensor {`
`581`	`578`	`if (kind) {`
`582`	`579`	`this._kind = kind;`
`583`	`580`	`}`
	`581`	`+ this._type = new TensorFlowTensorType(this._tensor.dtype, this._tensor.tensorShape);`
`584`	`582`	`}`
`585`	`583`
`586`	`584`	`get id() {`
`@@ -592,7 +590,7 @@ class TensorFlowTensor {`
`592`	`590`	`}`
`593`	`591`
`594`	`592`	`get type() {`
`595`		`- return new TensorFlowTensorType(this._tensor.dtype, this._tensor.tensorShape);`
	`593`	`+ return this._type;`
`596`	`594`	`}`
`597`	`595`
`598`	`596`	`get kind() {`