qairt-visualizer 0.5.1__py3-none-win_amd64.whl → 0.7.0__py3-none-win_amd64.whl

qairt_visualizer/core/ui/dist/browser/{assets/netron_plugin/source/dl4j.js → dl4j.js}

@@ -56,7 +56,7 @@ dl4j.Model = class {
 
     constructor(metadata, configuration, coefficients) {
         this.format = 'Deeplearning4j';
-        this.graphs = [new dl4j.Graph(metadata, configuration, coefficients)];
+        this.modules = [new dl4j.Graph(metadata, configuration, coefficients)];
     }
 };
 
@@ -133,7 +133,10 @@ dl4j.Graph = class {
                 this.nodes.push(node);
                 inputs = [layer.layerName];
             }
-            this.outputs.push(new dl4j.Argument('output', [values.map(inputs[0])]));
+            if (inputs && inputs.length > 0) {
+                const argument = new dl4j.Argument('output', [values.map(inputs[0])]);
+                this.outputs.push(argument);
+            }
         }
     }
 };

qairt_visualizer/core/ui/dist/browser/{assets/netron_plugin/source/dlc-schema.js → dlc-schema.js}

@@ -117,7 +117,7 @@ dlc.v4.Graph = class Graph {
         $.nodes = reader.tables(position, 6, dlc.v4.Node);
         $.tensors = reader.tables(position, 8, dlc.v4.Tensor);
         // QAIRT Netron: Identifying IO tensors and creating new node for the same
-        $.tensors.forEach(tensor => {
+        $.tensors.forEach((tensor) => {
             const isInput = tensor.location === 0;
             const isOutput = tensor.location === 1;
             if (isInput || isOutput) {
@@ -183,7 +183,7 @@ dlc.v4.Tensor = class Tensor {
         $.location = reader.int32_(position, 8, 0);
         $.shape = reader.array(position, 10, Int32Array);
         $.unk2 = reader.int32_(position, 12, 0);
-        $.QuantizationData = reader.table(position, 14, dlc.v4.QuantizationData);
+        $.quantizationData = reader.table(position, 14, dlc.v4.QuantizationData);
         $.dtype = reader.int32_(position, 16, 0);
         $.output_dtype = reader.int32_(position, 18, 0);
         $.unk6 = reader.uint8_(position, 20, 0);
@@ -331,12 +331,12 @@ dlc.v4.TensorData = class TensorData {
 // QAIRT Netron: Add DataPosition describing the file offset and size of the tensor data in model.params.bin
 dlc.v4.DataPosition = class DataPosition {
 
-  static decode(reader, position) {
-      const $ = new dlc.v4.DataPosition();
-      $.offset = Number(reader.int64_(position, 4, 0));
-      $.size = Number(reader.int64_(position, 6, 0));
-      return $;
-  }
+    static decode(reader, position) {
+        const $ = new dlc.v4.DataPosition();
+        $.offset = Number(reader.int64_(position, 4, 0));
+        $.size = Number(reader.int64_(position, 6, 0));
+        return $;
+    }
 };
 // QAIRT Netron END
 

qairt_visualizer/core/ui/dist/browser/{assets/netron_plugin/source/dlc.js → dlc.js}

@@ -4,6 +4,78 @@ import * as text from './text.js';
 
 const dlc = {};
 
+// QAIRT Netron: Define elementwise operations and padding size strategies mappings
+dlc.ElementWiseNeuronOperations = {
+    0: 'ELU',
+    1: 'GELU',
+    2: 'HARD_SIGMOID',
+    3: 'HARD_SWISH',
+    4: 'RELU',
+    5: 'RELU_MIN_MAX',
+    6: 'SIGMOID',
+    7: 'SOFTPLUS',
+    8: 'TANH'
+};
+
+dlc.EltwiseBinaryOperations = {
+    0: 'ADD',
+    1: 'AND',
+    2: 'DIVIDE',
+    3: 'EQUAL',
+    4: 'FLOOR_DIV',
+    5: 'FMOD',
+    6: 'GREATER',
+    7: 'GREATER_EQUAL',
+    8: 'LESS',
+    9: 'LESS_EQUAL',
+    10: 'MAXIMUM',
+    11: 'MINIMUM',
+    12: 'MOD',
+    13: 'MULTIPLY',
+    14: 'NOT_EQUAL',
+    15: 'OR',
+    16: 'POWER',
+    17: 'SQUARED_DIFFERENCE',
+    18: 'SUBTRACT',
+    19: 'XOR',
+};
+
+dlc.ElementWiseUnaryOperations = {
+    0: 'ABS',
+    1: 'ASIN',
+    2: 'ATAN',
+    3: 'CEIL',
+    4: 'COS',
+    5: 'EXP',
+    6: 'FLOOR',
+    7: 'LOG',
+    8: 'NEG',
+    9: 'NOT',
+    10: 'RECIPROCAL',
+    11: 'ROUND',
+    12: 'RSQRT',
+    13: 'SIGN',
+    14: 'SIN',
+    15: 'SQRT',
+};
+
+dlc.elementWiseOpMappings = {
+    'ElementWiseNeuron': dlc.ElementWiseNeuronOperations,
+    'Eltwise_Binary': dlc.EltwiseBinaryOperations,
+    'ElementWiseUnary': dlc.ElementWiseUnaryOperations,
+};
+
+dlc.PaddingSizeStrategies = {
+    0: 'implicit valid',
+    1: 'implicit same begin',
+    2: 'implicit same end',
+    3: 'explicit righthanded',
+    4: 'explicit',
+    5: 'explicit floor',
+    255: 'invalid',
+};
+// QAIRT Netron END
+
 dlc.ModelFactory = class {
 
     async match(context) {
@@ -47,7 +119,7 @@ dlc.Model = class {
             }
         }
         for (const graph of target.graphs) {
-            this.graphs = [new dlc.Graph(metadata, target.version, graph)];
+            this.modules = [new dlc.Graph(metadata, target.version, graph)];
         }
     }
 };
@@ -148,17 +220,18 @@ dlc.Value = class {
         this.type = type;
         this.initializer = initializer;
         // QAIRT Netron: Set quantization info if it exists on the tensor object
-        const quantizationData = tensor?.QuantizationData;
+        const quantizationData = tensor?.quantizationData;
         const { qInfo, ...axisInfo } = quantizationData?.axisQInfo || {};
         const { enc_infos, ...lpbqInfo } = quantizationData?.lpbq_info || {};
-        const encodingInfo = quantizationData?.qInfo || quantizationData?.axisQInfo?.qInfo || enc_infos;
-        if (quantizationData?.type !== 0x7FFFFFFF) { // Enum for undefined encoding type
-          this.qnnQuantization = {
-            encodingType: quantizationData.type,
-            encodingInfo,
-            axisInfo,
-            lpbqInfo,
-          };
+        const encodingInfo = quantizationData?.qInfo || qInfo || enc_infos;
+        const UNDEFINED_ENCODING_ENUM = 0x7FFFFFFF;
+        if (quantizationData?.type !== UNDEFINED_ENCODING_ENUM) {
+            this.qnnQuantization = {
+                encodingType: quantizationData.type,
+                encodingInfo,
+                axisInfo,
+                lpbqInfo,
+            };
         }
         // QAIRT Netron END
     }
@@ -311,7 +384,7 @@ dlc.Container = class {
 
     // QAIRT Netron: Store params bin data
     constructor(context, model, params, paramsBin, metadata) {
-        this._context = context;
+        this.context = context;
         this._model = model;
         this._params = params;
         this._paramsBin = paramsBin;
@@ -530,6 +603,16 @@ dlc.Container = class {
                             throw new dlc.Error(`Unknown attribute kind '${attribute.kind}'.`);
                         }
                     }
+                    // QAIRT Netron: Added support for mapping of elementwise operation and padding size strategy parameters
+                    if (attribute.name === 'operation') {
+                        const elementWiseOp = dlc.elementWiseOpMappings[node.type];
+                        if (elementWiseOp) {
+                            attribute.data = elementWiseOp[Number(attribute.data)] || attribute.data;
+                        }
+                    } else if (attribute.name === 'padding_size_strategy') {
+                        attribute.data = dlc.PaddingSizeStrategies[Number(attribute.data)] || attribute.data;
+                    }
+                    // QAIRT Netron END
                 }
             }
             for (const tensor of graph.tensors) {
@@ -615,7 +698,6 @@ dlc.Container = class {
         for (const graph of graphs) {
             const params = weights.get(graph.name);
             const tensors = new Map(params.tensors.map((tensor) => [tensor.name, tensor]));
-            let index = 0;
             graph.tensors.sort((a, b) => a.name.localeCompare(b.name));
             for (const tensor of graph.tensors) {
                 if (tensor.location === 4) {
@@ -632,37 +714,36 @@ dlc.Container = class {
                     for (const attribute of node.attributes) {
                         const tensor = attribute.tensor;
                         if (tensor) {
-                          // QAIRT Netron: Use custom logic to get tensor data
-                          tensor.data = this.getTensorData(tensors, tensor, paramsBinBuffer, buffers);
+                            // QAIRT Netron: Use custom logic to get tensor data
+                            tensor.data = this.getTensorData(tensors, tensor, paramsBinBuffer, buffers);
                         }
                     }
-              }
+                }
             }
         }
     }
 
     // QAIRT Netron: Get tensor data depending on the DLC version
     static getTensorData(tensors, tensor, paramsBinBuffer, buffers) {
-      if (!tensors.has(tensor.name)) {
-        throw new dlc.Error(`Unknown tensor`);
-      }
-      const tensorData = tensors.get(tensor.name);
-      if (paramsBinBuffer) {
-        // Tensor data exists in model.params.bin (introduced in DLC 4.1.0)
-        const { data_position } = tensorData;
-        return paramsBinBuffer.subarray(data_position.offset, data_position.offset + data_position.size);
-      } else if (buffers) {
-        // Tensor data exists inside Flatbuffer
-        return buffers[tensorData.data_index].bytes;
-      } else {
+        if (!tensors.has(tensor.name)) {
+            throw new dlc.Error(`Unknown tensor`);
+        }
+        const tensorData = tensors.get(tensor.name);
+        if (paramsBinBuffer) {
+            // Tensor data exists in model.params.bin (introduced in DLC 4.1.0)
+            const { data_position } = tensorData;
+            return paramsBinBuffer.subarray(data_position.offset, data_position.offset + data_position.size);
+        } else if (buffers) {
+            // Tensor data exists inside Flatbuffer
+            return buffers[tensorData.data_index].bytes;
+        }
         return tensorData.bytes;
-      }
     }
     // QAIRT Netron END
 
     async _fetch(name) {
         try {
-            const context = await this._context.fetch(name);
+            const context = await this.context.fetch(name);
             return context.stream;
         } catch {
             return null;

qairt_visualizer/core/ui/dist/browser/{assets/netron_plugin/source/dnn.js → dnn.js}

@@ -34,7 +34,7 @@ dnn.Model = class {
     constructor(metadata, model) {
         this.name = model.name || '';
         this.format = `SnapML${model.version ? ` v${model.version}` : ''}`;
-        this.graphs = [new dnn.Graph(metadata, model)];
+        this.modules = [new dnn.Graph(metadata, model)];
     }
 };
 
@@ -82,9 +82,7 @@ dnn.Graph = class {
             }
         }
         if (this.inputs.length === 0 &&  model.input_shape && model.input_shape.length === 4 && model.node.length > 0 && model.node[0].input.length > 0) {
-            /* eslint-disable prefer-destructuring */
-            const name = model.node[0].input[0];
-            /* eslint-enable prefer-destructuring */
+            const [name] = model.node[0].input;
             const shape = model.input_shape;
             const type = new dnn.TensorType('float32', new dnn.TensorShape([shape[1], shape[3], shape[2], shape[0]]));
             const argument = new dnn.Argument(name, [values.map(name, type)]);

qairt_visualizer/core/ui/dist/browser/{assets/netron_plugin/source/dot.js → dot.js}

@@ -41,7 +41,7 @@ dot.Model = class {
 
     constructor(graph) {
         this.format = 'DOT';
-        this.graphs = [new dot.Graph(graph)];
+        this.modules = [new dot.Graph(graph)];
     }
 };
 

qairt_visualizer/core/ui/dist/browser/eaix.js

@@ -0,0 +1,24 @@
+// QAIRT Netron: Add model factory for the EAIX format
+const eaix = {};
+
+eaix.ModelFactory = class {
+
+    async match(context) {
+        const obj = await context.peek('json');
+        return context.set('eaix', obj);
+    }
+
+    /*
+     * EAIX is a JSON that adheres to Netron's Model object format, however it is based on an older version of Netron.
+     * This method resolves the incompatibilities between the Model formats of the Netron version that EAIX is based on
+     * and the version used in Visualizer
+     */
+    async open(context) {
+        context.value.modules = context.value.graphs;
+        delete context.value.graphs;
+        return context.value;
+    }
+};
+
+export const ModelFactory = eaix.ModelFactory;
+// QAIRT Netron END

qairt_visualizer/core/ui/dist/browser/{assets/netron_plugin/source/espresso.js → espresso.js}

@@ -64,7 +64,7 @@ espresso.Model = class {
     constructor(metadata, reader) {
         this.format = reader.format;
         this.metadata = [];
-        this.graphs = [new espresso.Graph(metadata, reader)];
+        this.modules = [new espresso.Graph(metadata, reader)];
         if (reader.version) {
             this.version = reader.version;
         }