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

qairt_visualizer/core/ui/dist/browser/assets/netron_plugin/source/server.js

@@ -1,250 +0,0 @@
-
-// Experimental
-
-const message = {};
-
-message.ModelFactory = class {
-
-    match(context) {
-        const stream = context.stream;
-        if (stream) {
-            const buffer = stream.peek(Math.min(64, stream.length));
-            const content = String.fromCharCode.apply(null, buffer);
-            const match = content.match(/^{\s*"signature":\s*"(.*)"\s*,\s*/);
-            if (match && match[1].startsWith('netron:')) {
-                const obj = context.peek('json');
-                if (obj && obj.signature && obj.signature.startsWith('netron:')) {
-                    return obj;
-                }
-            }
-        }
-        return null;
-    }
-
-    async open(context, target) {
-        return new message.Model(target);
-    }
-};
-
-message.Model = class {
-
-    constructor(data) {
-        this._format = data.format || '';
-        this._producer = data.producer || '';
-        this._version = data.version || '';
-        this._description = data.description || '';
-        this._metadata = (data.metadata || []).map((entry) => {
-            return { name: entry.name, value: entry.value };
-        });
-        this._graphs = (data.graphs || []).map((graph) => new message.Graph(graph));
-    }
-
-    get format() {
-        return this._format;
-    }
-
-    get producer() {
-        return this._producer;
-    }
-
-    get version() {
-        return this._version;
-    }
-
-    get description() {
-        return this._description;
-    }
-
-    get metadata() {
-        return this._metadata;
-    }
-
-    get graphs() {
-        return this._graphs;
-    }
-};
-
-message.Graph = class {
-
-    constructor(data) {
-        this._inputs = [];
-        this._outputs = [];
-        this._nodes = [];
-        const args = data.arguments ? data.arguments.map((argument) => new message.Value(argument)) : [];
-        for (const parameter of data.inputs || []) {
-            parameter.arguments = parameter.arguments.map((index) => args[index]).filter((argument) => !argument.initializer);
-            if (parameter.arguments.filter((argument) => !argument.initializer).length > 0) {
-                this._inputs.push(new message.Argument(parameter));
-            }
-        }
-        for (const parameter of data.outputs || []) {
-            parameter.arguments = parameter.arguments.map((index) => args[index]);
-            if (parameter.arguments.filter((argument) => !argument.initializer).length > 0) {
-                this._outputs.push(new message.Argument(parameter));
-            }
-        }
-        for (const node of data.nodes || []) {
-            for (const parameter of node.inputs || []) {
-                parameter.arguments = parameter.arguments.map((index) => args[index]);
-            }
-            for (const parameter of node.outputs || []) {
-                parameter.arguments = parameter.arguments.map((index) => args[index]);
-            }
-            this._nodes.push(new message.Node(node));
-        }
-    }
-
-    get inputs() {
-        return this._inputs;
-    }
-
-    get outputs() {
-        return this._outputs;
-    }
-
-    get nodes() {
-        return this._nodes;
-    }
-};
-
-message.Argument = class {
-
-    constructor(data) {
-        this._name = data.name || '';
-        this._value = (data.arguments || []);
-    }
-
-    get name() {
-        return this._name;
-    }
-
-    get value() {
-        return this._value;
-    }
-};
-
-message.Value = class {
-
-    constructor(data) {
-        this._name= data.name || '';
-        this._type = data.type ? new message.TensorType(data.type) : null;
-        this._initializer = data.initializer ? new message.Tensor(data.initializer) : null;
-    }
-
-    get name() {
-        return this._name;
-    }
-
-    get type() {
-        if (this._initializer && this._initializer.type) {
-            return this._initializer.type;
-        }
-        return this._type;
-    }
-
-    get initializer() {
-        return this._initializer;
-    }
-};
-
-message.Node = class {
-
-    constructor(data) {
-        this._type = { name: data.type.name, category: data.type.category };
-        this._name = data.name;
-        this._inputs = (data.inputs || []).map((input) => new message.Argument(input));
-        this._outputs = (data.outputs || []).map((output) => new message.Argument(output));
-        this._attributes = (data.attributes || []).map((attribute) => new message.Attribute(attribute));
-    }
-
-    get type() {
-        return this._type;
-    }
-
-    get name() {
-        return this._name;
-    }
-
-    get inputs() {
-        return this._inputs;
-    }
-
-    get outputs() {
-        return this._outputs;
-    }
-
-    get attributes() {
-        return this._attributes;
-    }
-};
-
-message.Attribute = class {
-
-    constructor(data) {
-        this._type = data.type || '';
-        this._name = data.name;
-        this._value = data.value;
-    }
-
-    get name() {
-        return this._name;
-    }
-
-    get value() {
-        return this._value;
-    }
-
-    get type() {
-        return this._type;
-    }
-};
-
-message.TensorType = class {
-
-    constructor(data) {
-        this._dataType = data.dataType;
-        this._shape = new message.TensorShape(data.shape);
-    }
-
-    get dataType() {
-        return this._dataType;
-    }
-
-    get shape() {
-        return this._shape;
-    }
-
-    toString() {
-        return this._dataType + this._shape.toString();
-    }
-};
-
-message.TensorShape = class {
-
-    constructor(data) {
-        this._dimensions = data.dimensions;
-    }
-
-    get dimensions() {
-        return this._dimensions;
-    }
-
-    toString() {
-        return `[${this._dimensions}]`;
-    }
-};
-
-message.Tensor = class {
-
-    constructor() {
-    }
-};
-
-message.Error = class extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'Message Error';
-    }
-};
-
-export const ModelFactory = message.ModelFactory;

qairt_visualizer/core/ui/dist/browser/assets/netron_plugin/test/backend.py

@@ -1,80 +0,0 @@
-#!/usr/bin/env python
-
-''' Expermiental Python Server backend test '''
-
-import os
-import sys
-
-root_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-sys.path.append(root_dir)
-sys.pycache_prefix = os.path.join(root_dir, 'dist', 'pycache', 'test', 'backend')
-netron = __import__('source')
-
-third_party_dir = os.path.join(root_dir, 'third_party')
-test_data_dir = os.path.join(third_party_dir, 'test')
-
-def _test_onnx():
-    file = os.path.join(test_data_dir, 'onnx', 'candy.onnx')
-    onnx = __import__('onnx')
-    model = onnx.load(file)
-    netron.serve(None, model)
-
-def _test_onnx_iterate():
-    folder = os.path.join(test_data_dir, 'onnx')
-    for item in os.listdir(folder):
-        file = os.path.join(folder, item)
-        if file.endswith('.onnx') and \
-            item != 'super_resolution.onnx' and \
-            item != 'arcface-resnet100.onnx':
-            print(item)
-            onnx = __import__('onnx')
-            model = onnx.load(file)
-            address = netron.serve(file, model, verbosity='quiet')
-            netron.stop(address)
-
-def _test_torchscript(file):
-    torch = __import__('torch')
-    model = torch.load(os.path.join(test_data_dir, 'pytorch', file))
-    torch._C._jit_pass_inline(model.graph) # pylint: disable=protected-access
-    netron.serve(file, model)
-
-def _test_torchscript_transformer():
-    torch = __import__('torch')
-    model = torch.nn.Transformer(nhead=16, num_encoder_layers=12)
-    module = torch.jit.trace(model, (torch.rand(10, 32, 512), torch.rand(20, 32, 512)))
-    # module = torch.jit.script(model)
-    torch._C._jit_pass_inline(module.graph) # pylint: disable=protected-access
-    netron.serve('transformer', module)
-
-def _test_torchscript_resnet34():
-    torch = __import__('torch')
-    torchvision = __import__('torchvision')
-    model = torchvision.models.resnet34()
-    # model = torchvision.models.alexnet(weights=torchvision.models.AlexNet_Weights.DEFAULT)
-    # model = torchvision.models.resnet34(weights=torchvision.models.ResNet34_Weights.DEFAULT)
-    state_dict = torch.load(os.path.join(test_data_dir, 'pytorch', 'resnet34-333f7ec4.pth'))
-    model.load_state_dict(state_dict)
-    trace = torch.jit.trace(model, torch.zeros([1, 3, 224, 224]), strict=True)
-    torch._C._jit_pass_inline(trace.graph) # pylint: disable=protected-access
-    netron.serve('resnet34', trace)
-
-def _test_torchscript_quantized():
-    torch = __import__('torch')
-    __import__('torchvision')
-    torch.backends.quantized.engine = 'qnnpack'
-    trace = torch.jit.load(os.path.join(test_data_dir, 'pytorch', 'd2go.pt'))
-    torch._C._jit_pass_inline(trace.graph) # pylint: disable=protected-access
-    netron.serve('d2go', trace)
-
-# _test_onnx()
-# _test_onnx_iterate()
-
-# _test_torchscript('alexnet.pt')
-_test_torchscript('gpt2.pt')
-# _test_torchscript('inception_v3_traced.pt')
-# _test_torchscript('netron_issue_920.pt') # scalar
-# _test_torchscript('fasterrcnn_resnet50_fpn.pt') # tuple
-# _test_torchscript('mobilenetv2-quant_full-nnapi.pt') # nnapi
-# _test_torchscript_quantized()
-# _test_torchscript_resnet34()
-# _test_torchscript_transformer()

qairt_visualizer/core/ui/dist/browser/assets/netron_plugin/test/measures.py

@@ -1,27 +0,0 @@
-#!/usr/bin/env python
-
-''' Test Measures Script '''
-
-import pandas  # pylint: disable=import-error
-
-pandas.set_option('display.max_rows', None)
-
-def _summarize(summary_df, measures_df, column, threshold):
-    measures_df = measures_df.sort_values(column, ascending=False)
-    total = measures_df[column].sum()
-    column_df = measures_df[measures_df[column] > threshold]
-    top = column_df[column].sum()
-    summary_df.loc[len(summary_df)] = [ column, total, top, len(column_df), 100 * (top / total) ]
-    return column_df.to_string(index=False) + '\n'
-
-def main(): # pylint: disable=missing-function-docstring
-    measures_df = pandas.read_csv('dist/test/measures.csv')
-    measures_df.fillna(0, inplace=True)
-    summary_df = pandas.DataFrame(columns=[ 'Name', 'Total', 'Top', 'Count', 'Ratio' ])
-    print(_summarize(summary_df, measures_df, 'load', 1))
-    print(_summarize(summary_df, measures_df, 'validate', 1))
-    print(_summarize(summary_df, measures_df, 'render', 1))
-    print(summary_df.to_string(index=False))
-
-if __name__ == '__main__':
-    main()