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/modular.js

@@ -1,81 +0,0 @@
-
-const modular = {};
-
-modular.ModelFactory = class {
-
-    async match(context) {
-        const obj = await context.peek('json');
-        if (obj && obj.signature === "netron:modular") {
-            return context.set('modular', obj);
-        }
-        return null;
-    }
-
-    async open(context) {
-        return new modular.Model(context.value);
-    }
-};
-
-modular.Model = class {
-
-    constructor(obj) {
-        this.format = 'Modular';
-        this.graphs = obj.graphs.map((graph) => new modular.Graph(graph));
-    }
-};
-
-modular.Graph = class {
-
-    constructor(graph) {
-        this.nodes = Array.from(graph.nodes.map((node) => new modular.Node(node)));
-        this.inputs = [];
-        this.outputs = [];
-    }
-};
-
-modular.Argument = class {
-
-    constructor(name, value) {
-        this.name = name;
-        this.value = value;
-    }
-};
-
-modular.Value = class {
-
-    constructor(name, value) {
-        if (typeof name !== 'string') {
-            throw new modular.Error(`Invalid value identifier '${JSON.stringify(name)}'.`);
-        }
-        this.name = name;
-        this.value = value;
-    }
-};
-
-modular.Node = class {
-
-    constructor(node) {
-        this.name = '';
-        this.type = { name: node.type.name };
-        if (node.type.category === 'List') {
-            this.type.category = 'Data';
-        } else if (node.type.category === 'ControlFlow') {
-            this.type.category = 'Control';
-        } else {
-            this.type.category = node.type.category;
-        }
-        this.attributes = Array.isArray(node.attributes) ? Array.from(node.attributes).map((attribute) => new modular.Argument(attribute.name, attribute.value)) : [];
-        this.inputs = Array.from(node.inputs.map((input) => new modular.Argument(input.name, Array.from(input.arguments.map((value) => new modular.Value(value.toString(), input.name))))));
-        this.outputs = Array.from(node.outputs.map((output) => new modular.Argument(output.name, Array.from(output.arguments.map((value) => new modular.Value(value.toString(), output.name))))));
-    }
-};
-
-modular.Error = class extends Error {
-
-    constructor(message) {
-        super(message);
-        this.name = 'Error loading Modular model.';
-    }
-};
-
-export const ModelFactory = modular.ModelFactory;

qairt_visualizer/core/ui/dist/browser/assets/netron_plugin/source/onnx.py

@@ -1,227 +0,0 @@
-''' ONNX backend '''
-
-import collections
-import enum
-import json
-import os
-
-class ModelFactory: # pylint: disable=too-few-public-methods
-    ''' ONNX backend model factory '''
-    def open(self, model): # pylint: disable=missing-function-docstring
-        return _Model(model)
-
-class _Model: # pylint: disable=too-few-public-methods
-    def __init__(self, model):
-        ''' Serialize ONNX model to JSON message '''
-        # import onnx.shape_inference
-        # model = onnx.shape_inference.infer_shapes(model)
-        self.value = model
-        self.metadata = _Metadata()
-        self.graph = _Graph(model.graph, self.metadata)
-
-    def to_json(self): # pylint: disable=missing-function-docstring
-        ''' Serialize model to JSON message '''
-        model = self.value
-        json_model = {}
-        json_model['signature'] = 'netron:onnx'
-        json_model['format'] = 'ONNX' + (' v' + str(model.ir_version) if model.ir_version else '')
-        if model.producer_name and len(model.producer_name) > 0:
-            producer_version = ' v' + model.producer_version if model.producer_version else ''
-            json_model['producer'] = model.producer_name + producer_version
-        if model.model_version and model.model_version != 0:
-            json_model['version'] = str(model.model_version)
-        if model.doc_string and len(model.doc_string):
-            json_model['description'] = str(model.doc_string)
-        json_metadata = self._metadata_props(model.metadata_props)
-        if len(json_metadata) > 0:
-            json_model['metadata'] = json_metadata
-        json_model['graphs'] = []
-        json_model['graphs'].append(self.graph.to_json())
-        return json_model
-
-    def _metadata_props(self, metadata_props): # pylint: disable=missing-function-docstring
-        json_metadata = []
-        metadata_props = [ [ entry.key, entry.value ] for entry in metadata_props ]
-        metadata = collections.OrderedDict(metadata_props)
-        value = metadata.get('converted_from')
-        if value:
-            json_metadata.append({ 'name': 'source', 'value': value })
-        value = metadata.get('author')
-        if value:
-            json_metadata.append({ 'name': 'author', 'value': value })
-        value = metadata.get('company')
-        if value:
-            json_metadata.append({ 'name': 'company', 'value': value })
-        value = metadata.get('license')
-        license_url = metadata.get('license_url')
-        if license_url:
-            value = '<a href=\'' + license_url + '\'>' + (value if value else license_url) + '</a>'
-        if value:
-            json_metadata.append({ 'name': 'license', 'value': value })
-        if 'author' in metadata:
-            metadata.pop('author')
-        if 'company' in metadata:
-            metadata.pop('company')
-        if 'converted_from' in metadata:
-            metadata.pop('converted_from')
-        if 'license' in metadata:
-            metadata.pop('license')
-        if 'license_url' in metadata:
-            metadata.pop('license_url')
-        for name, value in metadata.items():
-            json_metadata.append({ 'name': name, 'value': value })
-        return json_metadata
-
-class _Graph:
-    def __init__(self, graph, metadata):
-        self.metadata = metadata
-        self.graph = graph
-        self.values_index = {}
-        self.values = []
-
-    def _tensor(self, tensor): # pylint: disable=unused-argument
-        return {}
-
-    def value(self, name, tensor_type=None, initializer=None): # pylint: disable=missing-function-docstring
-        if not name in self.values_index:
-            argument = _Value(name, tensor_type, initializer)
-            self.values_index[name] = len(self.values)
-            self.values.append(argument)
-        index = self.values_index[name]
-        # argument.set_initializer(initializer)
-        return index
-
-    def attribute(self, _, op_type): # pylint: disable=missing-function-docstring,too-many-branches
-        if _.type == _AttributeType.UNDEFINED:
-            attribute_type = None
-            value = None
-        elif _.type == _AttributeType.FLOAT:
-            attribute_type = 'float32'
-            value = _.f
-        elif _.type == _AttributeType.INT:
-            attribute_type = 'int64'
-            value = _.i
-        elif _.type == _AttributeType.STRING:
-            attribute_type = 'string'
-            value = _.s.decode('latin1' if op_type == 'Int8GivenTensorFill' else 'utf-8')
-        elif _.type == _AttributeType.TENSOR:
-            attribute_type = 'tensor'
-            value = self._tensor(_.t)
-        elif _.type == _AttributeType.GRAPH:
-            attribute_type = 'tensor'
-            raise Exception('Unsupported graph attribute type') # pylint: disable=broad-exception-raised
-        elif _.type == _AttributeType.FLOATS:
-            attribute_type = 'float32[]'
-            value = list(_.floats)
-        elif _.type == _AttributeType.INTS:
-            attribute_type = 'int64[]'
-            value = list(_.ints)
-        elif _.type == _AttributeType.STRINGS:
-            attribute_type = 'string[]'
-            value = [ item.decode('utf-8') for item in _.strings ]
-        elif _.type == _AttributeType.TENSORS:
-            attribute_type = 'tensor[]'
-            raise Exception('Unsupported tensors attribute type') # pylint: disable=broad-exception-raised
-        elif _.type == _AttributeType.GRAPHS:
-            attribute_type = 'graph[]'
-            raise Exception('Unsupported graphs attribute type') # pylint: disable=broad-exception-raised
-        elif _.type == _AttributeType.SPARSE_TENSOR:
-            attribute_type = 'tensor'
-            value = self._tensor(_.sparse_tensor)
-        else:
-            raise Exception("Unsupported attribute type '" + str(_.type) + "'.") # pylint: disable=broad-exception-raised
-        json_attribute = {}
-        json_attribute['name'] = _.name
-        if attribute_type:
-            json_attribute['type'] = attribute_type
-        json_attribute['value'] = value
-        return json_attribute
-
-    def to_json(self): # pylint: disable=missing-function-docstring
-        graph = self.graph
-        json_graph = {
-            'nodes': [],
-            'inputs': [],
-            'outputs': [],
-            'values': []
-        }
-        for value_info in graph.value_info:
-            self.value(value_info.name)
-        for initializer in graph.initializer:
-            self.value(initializer.name, None, initializer)
-        for node in graph.node:
-            op_type = node.op_type
-            json_node = {}
-            json_node_type = {}
-            json_node_type['name'] = op_type
-            type_metadata = self.metadata.type(op_type)
-            if type and 'category' in type_metadata:
-                json_node_type['category'] = type_metadata['category']
-            json_node['type'] = json_node_type
-            if node.name:
-                json_node['name'] = node.name
-            json_node['inputs'] = []
-            for value in node.input:
-                json_node['inputs'].append({
-                        'name': 'X',
-                        'value': [ self.value(value) ]
-                    })
-            json_node['outputs'] = []
-            for value in node.output:
-                json_node['outputs'].append({
-                        'name': 'X',
-                        'value': [ self.value(value) ]
-                    })
-            json_node['attributes'] = []
-            for _ in node.attribute:
-                json_attribute = self.attribute(_, op_type)
-                json_node['attributes'].append(json_attribute)
-            json_graph['nodes'].append(json_node)
-        for _ in self.values:
-            json_graph['values'].append(_.to_json())
-        return json_graph
-
-class _Value: # pylint: disable=too-few-public-methods
-    def __init__(self, name, tensor_type=None, initializer=None):
-        self.name = name
-        self.type = tensor_type
-        self.initializer = initializer
-
-    def to_json(self): # pylint: disable=missing-function-docstring
-        target = {}
-        target['name'] = self.name
-        # if self.initializer:
-        #     target['initializer'] = {}
-        return target
-
-class _Metadata: # pylint: disable=too-few-public-methods
-    metadata = {}
-
-    def __init__(self):
-        metadata_file = os.path.join(os.path.dirname(__file__), 'onnx-metadata.json')
-        with open(metadata_file, 'r', encoding='utf-8') as file:
-            for item in json.load(file):
-                name = item['name']
-                self.metadata[name] = item
-
-    def type(self, name): # pylint: disable=missing-function-docstring
-        if name in self.metadata:
-            return self.metadata[name]
-        return {}
-
-class _AttributeType(enum.IntEnum):
-    UNDEFINED = 0
-    FLOAT = 1
-    INT = 2
-    STRING = 3
-    TENSOR = 4
-    GRAPH = 5
-    FLOATS = 6
-    INTS = 7
-    STRINGS = 8
-    TENSORS = 9
-    GRAPHS = 10
-    SPARSE_TENSOR = 11
-    SPARSE_TENSORS = 12
-    TYPE_PROTO = 13
-    TYPE_PROTOS = 14

qairt_visualizer/core/ui/dist/browser/assets/netron_plugin/source/pytorch.py

@@ -1,298 +0,0 @@
-''' PyTorch backend '''
-
-import json
-import os
-
-class ModelFactory: # pylint: disable=too-few-public-methods
-    ''' PyTorch backend model factory '''
-    def open(self, model): # pylint: disable=missing-function-docstring
-        metadata = {}
-        metadata_files = [
-            ('pytorch-metadata.json', ''),
-            ('onnx-metadata.json', 'onnx::')
-        ]
-        path = os.path.dirname(__file__)
-        for entry in metadata_files:
-            file = os.path.join(path, entry[0])
-            with open(file, 'r', encoding='utf-8') as handle:
-                for item in json.load(handle):
-                    name = entry[1] + item['name'].split('(', 1)[0]
-                    metadata[name] = item
-        metadata = Metadata(metadata)
-        return _Model(metadata, model)
-
-class _Model: # pylint: disable=too-few-public-methods
-    def __init__(self, metadata, model):
-        self.graph = _Graph(metadata, model)
-
-    def to_json(self):
-        ''' Serialize model to JSON message '''
-        import torch # pylint: disable=import-outside-toplevel,import-error
-        json_model = {
-            'signature': 'netron:pytorch',
-            'format': 'TorchScript v' + torch.__version__,
-            'graphs': [ self.graph.to_json() ]
-        }
-        return json_model
-
-class _Graph: # pylint: disable=too-few-public-methods
-
-    def __init__(self, metadata, model):
-        self.metadata = metadata
-        self.param = model
-        self.value = model.graph
-        self.nodes = []
-
-    def _getattr(self, node):
-        if node.kind() == 'prim::Param':
-            return (self.param, '')
-        if node.kind() == 'prim::GetAttr':
-            name = node.s('name')
-            obj, parent = self._getattr(node.input().node())
-            return (getattr(obj, name), parent + '.' + name if len(parent) > 0 else name)
-        raise NotImplementedError()
-
-    def to_json(self): # pylint: disable=missing-function-docstring,too-many-locals,too-many-statements,too-many-branches
-        import torch # pylint: disable=import-outside-toplevel,import-error
-        graph = self.value
-        json_graph = {
-            'values': [],
-            'nodes': [],
-            'inputs': [],
-            'outputs': []
-        }
-        data_type_map = dict([
-            [ torch.float16, 'float16'], # pylint: disable=no-member
-            [ torch.float32, 'float32'], # pylint: disable=no-member
-            [ torch.float64, 'float64'], # pylint: disable=no-member
-            [ torch.int32, 'int32'], # pylint: disable=no-member
-            [ torch.int64, 'int64'], # pylint: disable=no-member
-        ])
-        def constant_value(node):
-            if node.hasAttribute('value'):
-                selector = node.kindOf('value')
-                return getattr(node, selector)('value')
-            return None
-        values_index = {}
-        def argument(value):
-            if not value in values_index:
-                json_value = {}
-                json_value['name'] = str(value.unique())
-                node = value.node()
-                if node.kind() == "prim::GetAttr":
-                    tensor, name = self._getattr(node)
-                    if tensor is not None and len(name) > 0 and \
-                        isinstance(tensor, torch.Tensor):
-                        json_tensor_shape = {
-                            'dimensions': list(tensor.shape)
-                        }
-                        tensor_type = {
-                            'dataType': data_type_map[tensor.dtype],
-                            'shape': json_tensor_shape
-                        }
-                        json_value['name'] = name
-                        json_value['type'] = tensor_type
-                        json_value['initializer'] = { 'type': tensor_type }
-                elif node.kind() == "prim::Constant":
-                    tensor = constant_value(node)
-                    if tensor and isinstance(tensor, torch.Tensor):
-                        json_tensor_shape = {
-                            'dimensions': list(tensor.shape)
-                        }
-                        tensor_type = {
-                            'dataType': data_type_map[tensor.dtype],
-                            'shape': json_tensor_shape
-                        }
-                        json_value['type'] = tensor_type
-                        json_value['initializer'] = { 'type': tensor_type }
-                elif value.isCompleteTensor():
-                    json_tensor_shape = {
-                        'dimensions': value.type().sizes()
-                    }
-                    json_value['type'] = {
-                        'dataType': data_type_map[value.type().dtype()],
-                        'shape': json_tensor_shape
-                    }
-                values = json_graph['values']
-                values_index[value] = len(values)
-                values.append(json_value)
-            return values_index[value]
-
-        for value in graph.inputs():
-            if len(value.uses()) != 0 and value.type().kind() != 'ClassType':
-                json_graph['inputs'].append({
-                    'name': value.debugName(),
-                    'value': [ argument(value) ]
-                })
-        for value in graph.outputs():
-            json_graph['outputs'].append({
-                'name': value.debugName(),
-                'value': [ argument(value) ]
-            })
-        constants = {}
-        for node in graph.nodes():
-            if node.kind() == 'prim::Constant':
-                constants[node] = 0
-
-        lists = {}
-        for node in graph.nodes():
-            if node.kind() == 'prim::ListConstruct':
-                if all(_.node() in constants for _ in node.inputs()):
-                    for _ in node.inputs():
-                        constants[_.node()] += 1
-                    lists[node] = 0
-
-        def create_node(node):
-            identifier = node.schema()
-            schema, category = self.metadata.type(identifier)
-            json_node = {
-                'type': {
-                    'name': node.kind(),
-                    'category': category
-                },
-                'inputs': [],
-                'outputs': [],
-                'attributes': []
-            }
-            json_graph['nodes'].append(json_node)
-            for name in node.attributeNames():
-                selector = node.kindOf(name)
-                value = getattr(node, selector)(name)
-                json_attribute = {
-                    'name': name,
-                    'value': value
-                }
-                if torch.is_tensor(value):
-                    json_node['inputs'].append({
-                        'name': name,
-                        'value': []
-                    })
-                else:
-                    json_node['attributes'].append(json_attribute)
-
-            for i, value in enumerate(node.inputs()):
-                arg = schema.arguments[i] if schema and i < len(schema.arguments) else None
-                parameter_name = arg.name if arg else 'input'
-                real_type = arg.real_type if arg else None
-                input_node = value.node()
-                if input_node in constants:
-                    if (real_type and real_type.kind() == 'TensorType') or \
-                        value.type().kind() == 'TensorType':
-                        json_node['inputs'].append({
-                            'name': parameter_name,
-                            'value': [ argument(value) ]
-                        })
-                    else:
-                        json_attribute = {
-                            'name': parameter_name,
-                            'value': constant_value(input_node)
-                        }
-                        if real_type:
-                            json_attribute['type'] = self._argument_type(real_type)
-                        json_node['attributes'].append(json_attribute)
-                    constants[input_node] = constants[input_node] + 1
-                    continue
-                if input_node in lists:
-                    json_attribute = {
-                        'name': parameter_name,
-                        'value': [ constant_value(_.node()) for _ in input_node.inputs() ]
-                    }
-                    json_node['attributes'].append(json_attribute)
-                    lists[input_node] += 1
-                    continue
-                if input_node.kind() == 'prim::TupleUnpack':
-                    continue
-                if input_node.kind() == 'prim::TupleConstruct':
-                    continue
-                json_node['inputs'].append({
-                    'name': parameter_name,
-                    'value': [ argument(value) ]
-                })
-
-            for i, value in enumerate(node.outputs()):
-                ret = schema.returns[i] if schema and i < len(schema.returns) else None
-                name = ret.name if ret else 'output'
-                json_node['outputs'].append({
-                    'name': name,
-                    'value': [ argument(value) ]
-                })
-
-        for node in graph.nodes():
-            if node in lists:
-                continue
-            if node in constants:
-                continue
-            if node.kind() == 'prim::GetAttr':
-                continue
-            create_node(node)
-
-        for node in graph.nodes():
-            if node.kind() == 'prim::Constant' and \
-                node in constants and constants[node] != len(node.output().uses()):
-                create_node(node)
-            if node.kind() == 'prim::ListConstruct' and \
-                node in lists and lists[node] != len(node.output().uses()):
-                create_node(node)
-
-        return json_graph
-
-    def _argument_type(self, value): # pylint: disable=too-many-branches,too-many-return-statements
-        if value.kind() == 'TensorType':
-            return 'Tensor'
-        if value.kind() == 'OptionalType':
-            element_type = self._argument_type(value.getElementType())
-            return f'{element_type}?'
-        if value.kind() == 'ListType':
-            element_type = self._argument_type(value.getElementType())
-            size = str(value.size) if hasattr(value, 'size') else ''
-            return f'{element_type}[{size}]'
-        if value.kind() == 'DictType':
-            key_type = self._argument_type(value.getKeyType())
-            value_type = self._argument_type(value.getValueType())
-            return f'Dict({key_type}, {value_type})'
-        if value.kind() == 'TupleType':
-            elements = []
-            for element in value.elements():
-                elements.append(self._argument_type(element))
-            return f'({', '.join(elements)})'
-        if value.kind() == 'IntType':
-            return 'int64'
-        if value.kind() == 'SymIntType':
-            return 'SymInt'
-        if value.kind() == 'FloatType':
-            return 'float32'
-        if value.kind() == 'BoolType':
-            return 'boolean'
-        if value.kind() == 'StringType':
-            return 'string'
-        if value.kind() == 'NumberType':
-            return 'Scalar'
-        if value.kind() == 'ScalarTypeType':
-            return 'ScalarType'
-        if value.kind() == 'LayoutType':
-            return 'Layout'
-        if value.kind() == 'MemoryFormatType':
-            return 'MemoryFormat'
-        if value.kind() == 'DeviceObjType':
-            return 'Device'
-        if value.kind() == 'GeneratorType':
-            return 'Generator'
-        if value.kind() == 'VarType':
-            return value.annotation_str
-        raise NotImplementedError()
-
-class Metadata: # pylint: disable=too-few-public-methods,missing-class-docstring
-
-    def __init__(self, metadata):
-        self.types = metadata
-
-    def type(self, identifier): # pylint: disable=missing-function-docstring
-        if identifier == '(no schema)':
-            return (None, '')
-        key = identifier.split('(', 1)[0]
-        value = self.types.get(key)
-        category = value['category'] if value and 'category' in value else ''
-        name, overload_name = key.split('.', 1) if key.find('.') > 0 else (key, '')
-        import torch # pylint: disable=import-outside-toplevel,import-error
-        schema = torch._C._get_schema(name, overload_name) # pylint: disable=protected-access
-        return (schema, category)