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/keras-metadata.json → keras-metadata.json}

@@ -227,7 +227,7 @@
     "name": "AveragePooling2D",
     "module": "keras.layers",
     "category": "Pool",
-    "description": "Average pooling operation for 2D spatial data.\n\nDownsamples the input along its spatial dimensions (height and width)\nby taking the average value over an input window\n(of size defined by `pool_size`) for each channel of the input.\nThe window is shifted by `strides` along each dimension.\n\nThe resulting output when using the `\"valid\"` padding option has a spatial\nshape (number of rows or columns) of:\n`output_shape = math.floor((input_shape - pool_size) / strides) + 1`\n(when `input_shape >= pool_size`)\n\nThe resulting output shape when using the `\"same\"` padding option is:\n`output_shape = math.floor((input_shape - 1) / strides) + 1`",
+    "description": "Average pooling operation for 2D spatial data.\n\nDownsamples the input along its spatial dimensions (height and width)\nby taking the average value over an input window\n(of size defined by `pool_size`) for each channel of the input.\nThe window is shifted by `strides` along each dimension.\n\nThe resulting output when using the `\"valid\"` padding option has a spatial\nshape (number of rows or columns) of:\n`output_shape = math.floor((input_shape - pool_size) / strides) + 1`\n(when `input_shape >= pool_size`)\n\nThe resulting output shape when using the `\"same\"` padding option is:\n`output_shape = input_shape`",
     "attributes": [
       {
         "default": "channels_last",
@@ -339,7 +339,7 @@
       },
       {
         "name": "rms_scaling",
-        "description": "If True, `center` and `scale` are ignored, and the\n        inputs are scaled by `gamma` and the inverse square root\n        of the square of all inputs. This is an approximate and faster\n        approach that avoids ever computing the mean of the input."
+        "description": "If True, `center` and `scale` are ignored, and the\n        inputs are scaled by `gamma` and the inverse square root\n        of the square of all inputs. This is an approximate and faster\n        approach that avoids ever computing the mean of the input. Note that\n        this *isn't* equivalent to the computation that the\n        `keras.layers.RMSNormalization` layer performs."
       },
       {
         "name": "beta_initializer",
@@ -998,7 +998,7 @@
       },
       {
         "default": "channels_last",
-        "description": "string, either `\"channels_last\"` or `\"channels_first\"`.\n        The ordering of the dimensions in the inputs. `\"channels_last\"`\n        corresponds to inputs with shape\n        `(batch_size, height, width, channels)`\n        while `\"channels_first\"` corresponds to inputs with shape\n        `(batch_size, channels, height, width)`. It defaults to the\n        `image_data_format` value found in your Keras config file at\n        `~/.keras/keras.json`. If you never set it, then it will be\n        `\"channels_last\"`.",
+        "description": "string, either `\"channels_last\"` or `\"channels_first\"`.\n        The ordering of the dimensions in the inputs. `\"channels_last\"`\n        corresponds to inputs with shape\n        `(batch_size, height, width, channels)`\n        while `\"channels_first\"` corresponds to inputs with shape\n        `(batch_size, channels, height, width)`. It defaults to the\n        `image_data_format` value found in your Keras config file at\n        `~/.keras/keras.json`. If you never set it, then it will be\n        `\"channels_last\"`.\n     dilation_rate: An integer or tuple/list of 2 integers,\n        specifying the dilation rate for\n        all spatial dimensions for dilated convolution.\n        Specifying different dilation rates\n        for different dimensions is not supported.\n        Currently, specifying any `dilation_rate` value != 1 is\n        incompatible with specifying any stride value != 1.",
         "name": "data_format"
       },
       {
@@ -1062,7 +1062,7 @@
         "name": "bias_constraint"
       },
       {
-        "description": "An integer or tuple/list of 2 integers,\n    specifying the amount of padding along the height and width\n    of the output tensor.\n    Can be a single integer to specify the same value for all\n    spatial dimensions.\n    The amount of output padding along a given dimension must be\n    lower than the stride along that same dimension.\n    If set to `None` (default), the output shape is inferred.",
+        "description": "An integer or tuple/list of 2 integers,\n        specifying the amount of padding along the height and width\n        of the output tensor.\n        Can be a single integer to specify the same value for all\n        spatial dimensions.\n        The amount of output padding along a given dimension must be\n        lower than the stride along that same dimension.\n        If set to `None` (default), the output shape is inferred.",
         "name": "output_padding"
       }
     ],
@@ -1779,6 +1779,10 @@
       {
         "name": "lora_rank",
         "description": "Optional integer. If set, the layer's forward pass\n        will implement LoRA (Low-Rank Adaptation)\n        with the provided rank. LoRA sets the layer's kernel\n        to non-trainable and replaces it with a delta over the\n        original kernel, obtained via multiplying two lower-rank\n        trainable matrices. This can be useful to reduce the\n        computation cost of fine-tuning large dense layers.\n        You can also enable LoRA on an existing\n        `Dense` layer by calling `layer.enable_lora(rank)`."
+      },
+      {
+        "name": "lora_alpha",
+        "description": "Optional integer. If set, this parameter scales the\n        low-rank adaptation delta (computed as the product of two lower-rank\n        trainable matrices) during the forward pass. The delta is scaled by\n        `lora_alpha / lora_rank`, allowing you to fine-tune the strength of\n        the LoRA adjustment independently of `lora_rank`."
       }
     ],
     "inputs": [
@@ -2057,6 +2061,10 @@
       {
         "name": "weights",
         "description": "Optional floating-point matrix of size\n        `(input_dim, output_dim)`. The initial embeddings values\n        to use."
+      },
+      {
+        "name": "lora_alpha",
+        "description": "Optional integer. If set, this parameter scales the\n        low-rank adaptation delta (computed as the product of two lower-rank\n        trainable matrices) during the forward pass. The delta is scaled by\n        `lora_alpha / lora_rank`, allowing you to fine-tune the strength of\n        the LoRA adjustment independently of `lora_rank`."
       }
     ],
     "inputs": [
@@ -2251,7 +2259,7 @@
     "name": "GRU",
     "module": "keras.layers",
     "category": "Layer",
-    "description": "Gated Recurrent Unit - Cho et al. 2014.\n\nBased on available runtime hardware and constraints, this layer\nwill choose different implementations (cuDNN-based or backend-native)\nto maximize the performance. If a GPU is available and all\nthe arguments to the layer meet the requirement of the cuDNN kernel\n(see below for details), the layer will use a fast cuDNN implementation\nwhen using the TensorFlow backend.\n\nThe requirements to use the cuDNN implementation are:\n\n1. `activation` == `tanh`\n2. `recurrent_activation` == `sigmoid`\n3. `dropout` == 0 and `recurrent_dropout` == 0\n4. `unroll` is `False`\n5. `use_bias` is `True`\n6. `reset_after` is `True`\n7. Inputs, if use masking, are strictly right-padded.\n8. Eager execution is enabled in the outermost context.\n\nThere are two variants of the GRU implementation. The default one is based\non [v3](https://arxiv.org/abs/1406.1078v3) and has reset gate applied to\nhidden state before matrix multiplication. The other one is based on\n[original](https://arxiv.org/abs/1406.1078v1) and has the order reversed.\n\nThe second variant is compatible with CuDNNGRU (GPU-only) and allows\ninference on CPU. Thus it has separate biases for `kernel` and\n`recurrent_kernel`. To use this variant, set `reset_after=True` and\n`recurrent_activation='sigmoid'`.\n\nFor example:\n\n```\n>>> inputs = np.random.random((32, 10, 8))\n>>> gru = keras.layers.GRU(4)\n>>> output = gru(inputs)\n>>> output.shape\n(32, 4)\n>>> gru = keras.layers.GRU(4, return_sequences=True, return_state=True)\n>>> whole_sequence_output, final_state = gru(inputs)\n>>> whole_sequence_output.shape\n(32, 10, 4)\n>>> final_state.shape\n(32, 4)\n```",
+    "description": "Gated Recurrent Unit - Cho et al. 2014.\n\nBased on available runtime hardware and constraints, this layer\nwill choose different implementations (cuDNN-based or backend-native)\nto maximize the performance. If a GPU is available and all\nthe arguments to the layer meet the requirement of the cuDNN kernel\n(see below for details), the layer will use a fast cuDNN implementation\nwhen using the TensorFlow backend.\n\nThe requirements to use the cuDNN implementation are:\n\n1. `activation` == `tanh`\n2. `recurrent_activation` == `sigmoid`\n3. `recurrent_dropout` == 0\n4. `unroll` is `False`\n5. `use_bias` is `True`\n6. `reset_after` is `True`\n7. Inputs, if use masking, are strictly right-padded.\n8. Eager execution is enabled in the outermost context.\n\nThere are two variants of the GRU implementation. The default one is based\non [v3](https://arxiv.org/abs/1406.1078v3) and has reset gate applied to\nhidden state before matrix multiplication. The other one is based on\n[original](https://arxiv.org/abs/1406.1078v1) and has the order reversed.\n\nThe second variant is compatible with CuDNNGRU (GPU-only) and allows\ninference on CPU. Thus it has separate biases for `kernel` and\n`recurrent_kernel`. To use this variant, set `reset_after=True` and\n`recurrent_activation='sigmoid'`.\n\nFor example:\n\n```\n>>> inputs = np.random.random((32, 10, 8))\n>>> gru = keras.layers.GRU(4)\n>>> output = gru(inputs)\n>>> output.shape\n(32, 4)\n>>> gru = keras.layers.GRU(4, return_sequences=True, return_state=True)\n>>> whole_sequence_output, final_state = gru(inputs)\n>>> whole_sequence_output.shape\n(32, 10, 4)\n>>> final_state.shape\n(32, 4)\n```",
     "attributes": [
       {
         "default": "tanh",
@@ -2899,7 +2907,7 @@
     "name": "LSTM",
     "module": "keras.layers",
     "category": "Layer",
-    "description": "Long Short-Term Memory layer - Hochreiter 1997.\n\nBased on available runtime hardware and constraints, this layer\nwill choose different implementations (cuDNN-based or backend-native)\nto maximize the performance. If a GPU is available and all\nthe arguments to the layer meet the requirement of the cuDNN kernel\n(see below for details), the layer will use a fast cuDNN implementation\nwhen using the TensorFlow backend.\nThe requirements to use the cuDNN implementation are:\n\n1. `activation` == `tanh`\n2. `recurrent_activation` == `sigmoid`\n3. `dropout` == 0 and `recurrent_dropout` == 0\n4. `unroll` is `False`\n5. `use_bias` is `True`\n6. Inputs, if use masking, are strictly right-padded.\n7. Eager execution is enabled in the outermost context.\n\nFor example:\n\n```\n>>> inputs = np.random.random((32, 10, 8))\n>>> lstm = keras.layers.LSTM(4)\n>>> output = lstm(inputs)\n>>> output.shape\n(32, 4)\n>>> lstm = keras.layers.LSTM(\n...     4, return_sequences=True, return_state=True)\n>>> whole_seq_output, final_memory_state, final_carry_state = lstm(inputs)\n>>> whole_seq_output.shape\n(32, 10, 4)\n>>> final_memory_state.shape\n(32, 4)\n>>> final_carry_state.shape\n(32, 4)\n```",
+    "description": "Long Short-Term Memory layer - Hochreiter 1997.\n\nBased on available runtime hardware and constraints, this layer\nwill choose different implementations (cuDNN-based or backend-native)\nto maximize the performance. If a GPU is available and all\nthe arguments to the layer meet the requirement of the cuDNN kernel\n(see below for details), the layer will use a fast cuDNN implementation\nwhen using the TensorFlow backend.\nThe requirements to use the cuDNN implementation are:\n\n1. `activation` == `tanh`\n2. `recurrent_activation` == `sigmoid`\n3. `recurrent_dropout` == 0\n4. `unroll` is `False`\n5. `use_bias` is `True`\n6. Inputs, if use masking, are strictly right-padded.\n7. Eager execution is enabled in the outermost context.\n\nFor example:\n\n```\n>>> inputs = np.random.random((32, 10, 8))\n>>> lstm = keras.layers.LSTM(4)\n>>> output = lstm(inputs)\n>>> output.shape\n(32, 4)\n>>> lstm = keras.layers.LSTM(\n...     4, return_sequences=True, return_state=True)\n>>> whole_seq_output, final_memory_state, final_carry_state = lstm(inputs)\n>>> whole_seq_output.shape\n(32, 10, 4)\n>>> final_memory_state.shape\n(32, 4)\n>>> final_carry_state.shape\n(32, 4)\n```",
     "attributes": [
       {
         "description": "Positive integer, dimensionality of the output space.",
@@ -3715,7 +3723,7 @@
     ],
     "examples": [
       {
-        "code": "from keras.layers import RNN\nfrom keras import ops\n\n# First, let's define a RNN Cell, as a layer subclass.\nclass MinimalRNNCell(keras.Layer):\n\n    def __init__(self, units, **kwargs):\n        super().__init__(**kwargs)\n        self.units = units\n        self.state_size = units\n\n    def build(self, input_shape):\n        self.kernel = self.add_weight(shape=(input_shape[-1], self.units),\n                                      initializer='uniform',\n                                      name='kernel')\n        self.recurrent_kernel = self.add_weight(\n            shape=(self.units, self.units),\n            initializer='uniform',\n            name='recurrent_kernel')\n        self.built = True\n\n    def call(self, inputs, states):\n        prev_output = states[0]\n        h = ops.matmul(inputs, self.kernel)\n        output = h + ops.matmul(prev_output, self.recurrent_kernel)\n        return output, [output]\n\n# Let's use this cell in a RNN layer:\n\ncell = MinimalRNNCell(32)\nx = keras.Input((None, 5))\nlayer = RNN(cell)\ny = layer(x)\n\n# Here's how to use the cell to build a stacked RNN:\n\ncells = [MinimalRNNCell(32), MinimalRNNCell(64)]\nx = keras.Input((None, 5))\nlayer = RNN(cells)\ny = layer(x)"
+        "code": "from keras.layers import RNN\nfrom keras import ops\n\n# First, let's define a RNN Cell, as a layer subclass.\nclass MinimalRNNCell(keras.Layer):\n\n    def __init__(self, units, **kwargs):\n        super().__init__(**kwargs)\n        self.units = units\n        self.state_size = units\n\n    def build(self, input_shape):\n        self.kernel = self.add_weight(shape=(input_shape[-1], self.units),\n                                      initializer='uniform',\n                                      name='kernel')\n        self.recurrent_kernel = self.add_weight(\n            shape=(self.units, self.units),\n            initializer='uniform',\n            name='recurrent_kernel')\n\n    def call(self, inputs, states):\n        prev_output = states[0]\n        h = ops.matmul(inputs, self.kernel)\n        output = h + ops.matmul(prev_output, self.recurrent_kernel)\n        return output, [output]\n\n# Let's use this cell in a RNN layer:\n\ncell = MinimalRNNCell(32)\nx = keras.Input((None, 5))\nlayer = RNN(cell)\ny = layer(x)\n\n# Here's how to use the cell to build a stacked RNN:\n\ncells = [MinimalRNNCell(32), MinimalRNNCell(64)]\nx = keras.Input((None, 5))\nlayer = RNN(cells)\ny = layer(x)"
       }
     ]
   },

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

@@ -9,7 +9,7 @@ keras.ModelFactory = class {
 
     async match(context) {
         const identifier = context.identifier;
-        const extension = identifier.split('.').pop().toLowerCase();
+        const extension = identifier.lastIndexOf('.') > 0 ? identifier.split('.').pop().toLowerCase() : '';
         const group = await context.peek('hdf5');
         if (group && group.attributes && group.attributes.get('CLASS') !== 'hickle') {
             if (identifier === 'model.weights.h5') {
@@ -518,7 +518,7 @@ keras.Model = class {
         this.runtime = backend;
         this.producer = producer;
         metadata = new keras.GraphMetadata(metadata);
-        this.graphs = [new keras.Graph(metadata, config, weights)];
+        this.modules = [new keras.Graph(metadata, config, weights)];
     }
 };
 
@@ -565,15 +565,22 @@ keras.Graph = class {
                 return null;
             };
             this.name = config.name || (config.config && config.config.name ? config.config.name : '');
-            this.type = config.class_name;
+            this.description = config.class_name;
             let baseType = config.class_name;
             switch (baseType) {
-                case 'Sequential':
                 case '__Function__':
+                    this.type = 'function';
+                    break;
+                case 'Sequential':
                 case 'Functional':
                 case 'Model': {
                     break;
                 }
+                case 'Tokenizer': {
+                    config = { config: { layers: [config] } };
+                    baseType = 'Functional';
+                    break;
+                }
                 default: {
                     const layers = Array.from(config.layers ? config.layers : config);
                     const sequential = layers.every((layer) => layer.inbound_nodes === undefined);
@@ -766,9 +773,7 @@ keras.Graph = class {
                                     layer.inputs = [];
                                     layer.outputs = [];
                                     layer.args = {};
-                                    /* eslint-disable prefer-destructuring */
-                                    layer.inbound_node = layer.inbound_nodes[0];
-                                    /* eslint-enable prefer-destructuring */
+                                    [layer.inbound_node] = layer.inbound_nodes;
                                     nodes.set(`${layer.name}[${first_index}]`, layer);
                                 } else {
                                     let config = {};
@@ -861,6 +866,7 @@ keras.Graph = class {
                 }
             }
         } else if (weights) {
+            this.type = 'weights';
             for (const name of weights.keys()) {
                 if (weights.get('', name).length <= 6) {
                     const layer = { class_name: 'Weights', config: { name } };

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

@@ -24,7 +24,7 @@ kmodel.Model = class {
 
     constructor(model) {
         this.format = `kmodel v${model.version}`;
-        this.graphs = model.modules.map((module) => new kmodel.Graph(module));
+        this.modules = model.modules.map((module) => new kmodel.Graph(module));
     }
 };
 
@@ -32,7 +32,7 @@ kmodel.Graph = class {
 
     constructor(module) {
         this.name = module.name || '';
-        this.type = module.type || '';
+        this.description = module.type || '';
         this.inputs = [];
         this.outputs = [];
         this.nodes = [];
@@ -252,7 +252,7 @@ kmodel.Reader = class {
     }
 
     read() {
-        if (this.version < 3 || this.version > 5) {
+        if (this.version < 3 || this.version > 7) {
             throw new kmodel.Error(`Unsupported model version '${this.version}'.`);
         }
         const types = new Map();

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

@@ -23,7 +23,7 @@ lasagne.Model = class {
 
     constructor(metadata, model) {
         this.format = 'Lasagne';
-        this.graphs = [new lasagne.Graph(metadata, model)];
+        this.modules = [new lasagne.Graph(metadata, model)];
     }
 };
 
@@ -48,7 +48,7 @@ lasagne.Graph = class {
             const layer = model.layers_[name];
             if (layer.input_layer && layer.input_layer.name) {
                 const input_layer = layer.input_layer;
-                const dataType = input_layer.input_var ? input_layer.input_var.type.dtype : '?';
+                const dataType = input_layer.input_var && input_layer.input_var.type ? input_layer.input_var.type.dtype : '?';
                 const shape = layer.input_shape ? new lasagne.TensorShape(layer.input_shape) : null;
                 const type = shape ? new lasagne.TensorType(dataType, shape) : null;
                 values.map(input_layer.name, type);

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

@@ -45,7 +45,7 @@ lightgbm.Model = class {
 
     constructor(obj, format) {
         this.format = format + (obj && obj.version ? ` ${obj.version}` : '');
-        this.graphs = [new lightgbm.Graph(obj)];
+        this.modules = [new lightgbm.Graph(obj)];
     }
 };
 

qairt_visualizer/core/ui/dist/browser/main-EVI665MB.js

@@ -0,0 +1 @@
+Promise.all([]).then(()=>import("./chunk-JPD5T7FP.js")).catch(r=>console.error("error",r));

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

@@ -33,7 +33,7 @@ mediapipe.Model = class {
 
     constructor(config) {
         this.format = 'MediaPipe';
-        this.graphs = [new mediapipe.Graph(config)];
+        this.modules = [new mediapipe.Graph(config)];
     }
 };
 

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

@@ -72,7 +72,7 @@ megengine.Model = class {
         } else if (type === 'megengine.mge') {
             this.format += ` Mge${obj.model_version ? ` v${obj.model_version}` : ''}`;
         }
-        this.graphs = [new megengine.Graph(metadata, obj)];
+        this.modules = [new megengine.Graph(metadata, obj)];
     }
 };
 

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

@@ -37,11 +37,12 @@ message.Model = class {
         this.metadata = (data.metadata || []).map((entry) => {
             return { name: entry.name, value: entry.value };
         });
-        this.graphs = (data.graphs || []).map((graph) => new message.Graph(graph));
+        const modules = data.modules || data.graphs || [];
+        this.modules = modules.map((module) => new message.Module(module));
     }
 };
 
-message.Graph = class {
+message.Module = class {
 
     constructor(data) {
         this.inputs = [];

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

@@ -34,13 +34,14 @@ mlir.ModelFactory = class {
                 const decoder = await context.read('text.decoder');
                 const parser = new mlir.Parser(decoder);
                 const obj = await parser.read();
-                return new mlir.Model(obj);
+                const metadata = new mlir.Metadata();
+                return new mlir.Model(metadata, obj);
             }
             case 'mlir.binary': {
                 const reader = await context.read('binary');
                 const parser = new mlir.BytecodeReader(reader);
                 parser.read();
-                throw new mlir.Error('Invalid file content. File contains MLIR bytecode data.');
+                throw new mlir.Error('File contains unsupported MLIR bytecode data.');
             }
             default: {
                 throw new mlir.Error(`Unsupported MLIR format '${context.type}'.`);
@@ -51,22 +52,22 @@ mlir.ModelFactory = class {
 
 mlir.Model = class {
 
-    constructor(obj) {
+    constructor(metadata, obj) {
         this.format = 'MLIR';
-        this.graphs = [];
+        this.modules = [];
         this.metadata = [];
         for (const op of obj.operations) {
             if (op.name.endsWith('.func')) {
-                const graph = new mlir.Graph(op);
-                this.graphs.push(graph);
+                const graph = new mlir.Graph(metadata, op);
+                this.modules.push(graph);
             }
             if (op.name.endsWith('.module')) {
                 for (const region of op.regions) {
                     for (const block of region.blocks) {
                         for (const op of block.operations) {
                             if (op.name.endsWith('.func')) {
-                                const graph = new mlir.Graph(op);
-                                this.graphs.push(graph);
+                                const graph = new mlir.Graph(metadata, op);
+                                this.modules.push(graph);
                             }
                         }
                     }
@@ -75,7 +76,8 @@ mlir.Model = class {
         }
         if (obj.definitions) {
             for (const attribute of obj.definitions) {
-                const metadata = new mlir.Argument(attribute.name, attribute.value, attribute.type);
+                const value = typeof attribute.value === 'string' ? attribute.value : JSON.stringify(attribute.value);
+                const metadata = new mlir.Argument(attribute.name, value, 'attribute');
                 this.metadata.push(metadata);
             }
         }
@@ -84,10 +86,11 @@ mlir.Model = class {
 
 mlir.Graph = class {
 
-    constructor(func) {
+    constructor(metadata, func) {
         const attr = Object.fromEntries(func.attributes.map((attr) => [attr.name, attr.value]));
         this.name = attr.sym_name || '';
-        this.type = func.name;
+        this.type = func.name === 'func' || func.name.endsWith('.func') ? 'function' : '';
+        this.description = func.name;
         this.inputs = [];
         this.outputs = [];
         this.nodes = [];
@@ -285,7 +288,7 @@ mlir.Graph = class {
             //     const map = new Map(metadata.inputs.map((input) => [ input.name, index++ ]));
             //     op.inputs.sort((a, b) => (map.get(a.name) || map.size) - (map.get(b.name) || map.size));
             // }
-            const node = new mlir.Node(op);
+            const node = new mlir.Node(metadata, op);
             this.nodes.push(node);
         }
     }
@@ -301,8 +304,8 @@ mlir.Argument = class {
             case 'i64': this.type = 'int64'; break;
             case 'si64': this.type = 'int64'; break;
             case 'i32': this.type = 'int32'; break;
-            case 'f32': this.type = 'float32'; break;
-            case 'f64': this.type = 'float64'; break;
+            case 'f32': case 'float32': this.type = 'float32'; break;
+            case 'f64': case 'float64': this.type = 'float64'; break;
             case null:
             case 'attribute':
             case 'boolean':
@@ -331,11 +334,13 @@ mlir.Value = class {
 
 mlir.Node = class {
 
-    constructor(op) {
+    constructor(metadata, op) {
         if (!op.type) {
             throw new mlir.Error('Undefined node type.');
         }
-        this.type = { name: op.type || '', identifier: op.identifier || '' };
+        this.type = { ...metadata.type(op.identifier || '') };
+        this.type.name = op.type || '';
+        this.type.identifier = op.identifier || '';
         this.name = op.name || '';
         this.inputs = op.operands || [];
         this.outputs = op.results || [];
@@ -1214,7 +1219,7 @@ mlir.Parser = class {
         const open = this._eat('(');
         while (!this._match(')') && !this._match('->') && !this._match('{')) {
             const input = {};
-            if (this._token.kind === 'id' && this._token.value !== 'dense') {
+            if (this._token.kind === 'id' && this._token.value !== 'dense' && this._token.value !== 'dense_resource') {
                 const identifier = this._read('id');
                 if (this._eat('(')) {
                     const args = this._parseArguments();
@@ -1455,6 +1460,16 @@ mlir.Parser = class {
             value.type = 'type';
             return value;
         }
+        if (this._eat('id', 'dense_resource')) {
+            value.value = null;
+            value.type = 'dense';
+            this._read('<');
+            if (!this._match('>')) {
+                value.value = this._read();
+            }
+            this._read('>');
+            return value;
+        }
         if (this._eat('id', 'dense')) {
             value.value = null;
             value.type = 'dense';
@@ -1872,6 +1887,27 @@ mlir.Utility = class {
     }
 };
 
+mlir.Metadata = class {
+
+    constructor() {
+        this._types = new Map();
+        this.register('stablehlo.reshape', 'Shape');
+        this.register('asuka.split', 'Tensor');
+        this.register('stablehlo.transpose', 'Transform');
+        this.register('toy.transpose', 'Transform');
+        this.register('asuka.softmax', 'Activation');
+        this.register('stablehlo.slice', 'Tensor');
+    }
+
+    register(name, category) {
+        this._types.set(name, { name, category });
+    }
+
+    type(name) {
+        return this._types.get(name) || { name };
+    }
+};
+
 mlir.Error = class extends Error {
 
     constructor(message) {

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

@@ -32,12 +32,11 @@ mlnet.Model = class {
         if (reader.version && reader.version.length > 0) {
             this.format += ` v${reader.version}`;
         }
-        const graph = new mlnet.Graph(metadata, reader);
-        this.graphs = [graph];
+        this.modules = [new mlnet.Module(metadata, reader)];
     }
 };
 
-mlnet.Graph = class {
+mlnet.Module = class {
 
     constructor(metadata, reader) {
         this.inputs = [];

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

@@ -269,7 +269,7 @@ MNN.IDSTQuan = class IDSTQuan {
         $.quantScale = reader.float32_(position, 12, 0);
         $.scaleIn = reader.float32_(position, 14, 0);
         $.scaleOut = reader.float32_(position, 16, 0);
-        $.aMax = reader.int32_(position, 18, 0);
+        $.aMaxOrBits = reader.int32_(position, 18, 0);
         $.aMin = reader.int32_(position, 20, 0);
         $.readType = reader.int32_(position, 22, 0);
         $.has_scaleInt = reader.bool_(position, 24, false);
@@ -288,7 +288,7 @@ MNN.IDSTQuan = class IDSTQuan {
         $.quantScale = reader.value(json.quantScale, 0);
         $.scaleIn = reader.value(json.scaleIn, 0);
         $.scaleOut = reader.value(json.scaleOut, 0);
-        $.aMax = reader.value(json.aMax, 0);
+        $.aMaxOrBits = reader.value(json.aMaxOrBits, 0);
         $.aMin = reader.value(json.aMin, 0);
         $.readType = reader.value(json.readType, 0);
         $.has_scaleInt = reader.value(json.has_scaleInt, false);
@@ -2489,7 +2489,7 @@ MNN.OpType = {
     LRN: 37,
     LSTM: 38,
     MatMul: 39,
-    MVN: 40,
+    MoE: 40,
     NonMaxSuppression: 41,
     NonMaxSuppressionV2: 42,
     Normalize: 43,
@@ -3157,9 +3157,12 @@ MNN.TensorDescribe = class TensorDescribe {
 MNN.ForwardType = {
     CPU: 0,
     METAL: 1,
-    OPENCL: 2,
-    OPENGLES: 3,
-    VULKAN: 4
+    CUDA: 2,
+    OPENCL: 3,
+    AUTO: 4,
+    NNAPI: 5,
+    OPENGLES: 6,
+    VULKAN: 7
 };
 
 MNN.Usage = {

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

@@ -64,7 +64,7 @@ mnn.Model = class {
             throw new mnn.Error(`Unsupported model source '${net.sourceType}'.`);
         }
         this.source = sources.get(net.sourceType);
-        this.graphs = [new mnn.Graph(metadata, net)];
+        this.modules = [new mnn.Graph(metadata, net)];
     }
 };
 
@@ -178,7 +178,7 @@ mnn.Node = class {
                 delete param.symmetricQuan;
             } else if (param instanceof mnn.schema.InnerProduct) {
                 const outputCount = param.outputCount;
-                const inputCount = param.weightSize / outputCount;
+                const inputCount = outputCount > 0 ? param.weightSize / outputCount : 0;
                 this._buildTensor('weight', mnn.schema.DataType.DT_FLOAT, [outputCount, inputCount], param.weight);
                 this._buildTensor('bias', mnn.schema.DataType.DT_FLOAT, [outputCount], param.bias);
                 delete param.weight;

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

@@ -47,17 +47,17 @@ mslite.Model = class {
 
     constructor(metadata, model) {
         this.name = model.name || '';
-        this.graphs = [];
+        this.modules = [];
         const version = model.version ? model.version.match(/^.*(\d\.\d\.\d)$/) : null;
         this.format = `MindSpore Lite${version ? ` v${version[1]}` : ''}`;
         const subgraphs = model.subGraph;
         if (Array.isArray(subgraphs)) {
             for (const subgraph of subgraphs) {
-                this.graphs.push(new mslite.Graph(metadata, subgraph, model));
+                this.modules.push(new mslite.Graph(metadata, subgraph, model));
             }
         } else {
             const graph = new mslite.Graph(metadata, model, model);
-            this.graphs.push(graph);
+            this.modules.push(graph);
         }
     }
 };

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

@@ -7,7 +7,7 @@ mxnet.ModelFactory = class {
 
     async match(context) {
         const identifier = context.identifier;
-        const extension = identifier.split('.').pop().toLowerCase();
+        const extension = identifier.lastIndexOf('.') > 0 ? identifier.split('.').pop().toLowerCase() : '';
         if (extension === 'json') {
             const obj = await context.peek('json');
             if (obj && Array.isArray(obj.nodes) && Array.isArray(obj.arg_nodes) && Array.isArray(obj.heads) && !obj.nodes.some((node) => node && node.op === 'tvm_op')) {
@@ -259,7 +259,7 @@ mxnet.Model = class {
         if (manifest.license) {
             this.metadata.push(new mxnet.Argument('license', manifest.license));
         }
-        this.graphs = [new mxnet.Graph(metadata, manifest, symbol, params)];
+        this.modules = [new mxnet.Graph(metadata, manifest, symbol, params)];
     }
 };
 

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

@@ -191,7 +191,7 @@ ncnn.Model = class {
 
     constructor(metadata, format, param, blobs) {
         this.format = format === 'pnnx' ? 'PNNX' : 'ncnn';
-        this.graphs = [new ncnn.Graph(metadata, format, param, blobs)];
+        this.modules = [new ncnn.Graph(metadata, format, param, blobs)];
     }
 };
 
@@ -367,7 +367,8 @@ ncnn.Node = class {
                 const weight_data_size = parseInt(params.get('2') || 0, 10);
                 const int8_scale_term = parseInt(params.get('8') || 0, 10);
                 const activation_type = parseInt(params.get('9') || 0, 10);
-                blobs.weight('weight', [num_output, weight_data_size / num_output]);
+                const input_size = num_output > 0 ? Math.floor(weight_data_size / num_output) : 0;
+                blobs.weight('weight', [num_output, input_size]);
                 if (bias_term) {
                     blobs.weight('bias', [num_output], 1);
                 }

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

@@ -79,7 +79,7 @@ nnabla.Model = class {
 
     constructor(metadata, model, version) {
         this.format = `NNabla${version ? ` v${version}` : ''}`;
-        this.graphs = [];
+        this.modules = [];
         const tensors = new Map(model.parameter.map((parameter) => {
             const name = parameter.variable_name;
             const shape = new nnabla.TensorShape(parameter.shape.dim);
@@ -90,17 +90,17 @@ nnabla.Model = class {
         for (const executor of model.executor) {
             const network = networks.get(executor.network_name);
             const graph = new nnabla.Graph(metadata, network, executor.data_variable, executor.output_variable, tensors);
-            this.graphs.push(graph);
+            this.modules.push(graph);
         }
         for (const optimizer of model.optimizer) {
             const network = networks.get(optimizer.network_name);
             const graph = new nnabla.Graph(metadata, network, optimizer.data_variable, optimizer.loss_variable, tensors);
-            this.graphs.push(graph);
+            this.modules.push(graph);
         }
         for (const monitor of model.monitor) {
             const network = networks.get(monitor.network_name);
             const graph = new nnabla.Graph(metadata, network, monitor.data_variable, monitor.monitor_variable, tensors);
-            this.graphs.push(graph);
+            this.modules.push(graph);
         }
     }
 };

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

@@ -5,7 +5,7 @@ nnef.ModelFactory = class {
 
     async match(context) {
         const identifier = context.identifier;
-        const extension = identifier.split('.').pop().toLowerCase();
+        const extension = identifier.lastIndexOf('.') > 0 ? identifier.split('.').pop().toLowerCase() : '';
         switch (extension) {
             case 'nnef': {
                 const reader = await nnef.TextReader.open(context);