8.16

Author: remloveh

docs/deep_dive/mrt.rst

@@ -0,0 +1,63 @@
+
+***********
+MRT summary
+***********
+
+.. contents::
+
+Introduce
+=========
+
+MRT, short for **Model Representation Tool**, aims to convert floating model into a deterministi
+c and non-data-overflow network. MRT links the off-chain AI developer community to the on-chain e
+cosystem, from Off-chain deep learning to MRT transformations, and then uploading to Cortex Block
+chain for on-chain deterministic inference.
+
+As the above CVM Runtime section points out, the model that goes
+under MRT transformation can be accepted by CVM Runtime, which
+we called it on-chain model. MRT propose approaches to transform 
+floating model to on-chain model, mainly include:
+
+- do transformation from floating to full integer with minimum 
+  accuracy drop.
+- certify the process data to be non-flow over INT32.
+
+Application
+===========
+
+Quantization steps
+------------------
+
+The main quantization procedure is:
+
+    Model Load >>> Preparation >>> [Optional] Model Split >>>
+    
+    Calibration >>> Quantization >>> [Optional] Model Merge >>> Compilation to CVM,
+
+The execution steps of main.py include prepare, calibrate, quantize, evaluate, and mrt_compile. 
+Each step will generate a corresponding intermediate file. You can set the start from that step 
+ccording to the parameter COMMON.START_AFTER of the configuration file, 
+and use the corresponding intermediate file.
+
+prepare(calibrate, quantize, evaluate, mrt_compile): According to the COMMON and PREPARE(CALIBRATE, QUANTIZE, EVALUATE, MRT_COMPILE) parameters of the configuration file, load the corresponding
+model file, call the corresponding function, and save the file generated by the operation to the
+model directory. If the split parameter is not empty,
+you need to split the model into top and base after prepare, and merge the models after quantize.
+
+Instructions for use
+--------------------
+
+Quantization by executing the following code snippet:
+
+.. code-block::
+
+  python main.py config/file/path
+
+The sample configure file is located at ``python/mrt/model_zoo/config.example.ini`` (`config.example.ini <https://github.com/CortexFoundation/cvm-runtime/blob/master/python/mrt/model_zoo/config.example.ini>`_),
+and the configure file is located at ``tests/mrt/model_zoo/`` (`model_zoo <https://github.com/CortexFoundation/cvm-runtime/tree/wlt/tests/mrt/model_zoo>`_).
+
+Note
+====
+
+Before executing python main.py yaml_file, save the trained model json file and params file to ~/mrt_model/, and the quantized related files are stored in this directory.
+About the yaml file, the default value of PREPARE.INPUTSHAPE is [-1, 3, 224, 224], before quantization, you need to set this value to the size of the value input by the model

tests/deprecated/test_V3.py

@@ -0,0 +1,143 @@
+import unittest
+import logging
+import os
+from os import path
+import sys
+import json
+
+from mrt.utils import log_init
+from mrt.V3.execute import run
+from mrt.V3.utils import merge_cfg, override_cfg_args, get_logger
+from mrt.V3.evaluate import get_evaluation_info
+
+log_init()
+yaml_files = set()
+results = {}
+base_dir = path.join(path.dirname(path.realpath(__file__)), "..", "..")
+
+def _multi_validate(
+    messages, base_func, data_iter, *comp_funcs,
+    iter_num=10, logger=logging.getLogger(""), batch_size=16):
+    log_str = "Iteration: {:3d} | " + base_func.__name__ + ": {} | "
+    for func in comp_funcs:
+        log_str += func.__name__ + ": {} | "
+    log_str += "Total Sample: {:5d}"
+    total = 0
+
+    for i in range(iter_num):
+        data, label = data_iter()
+        base_acc = base_func(data, label)
+        comp_acc = [func(data, label) for func in comp_funcs]
+        total += batch_size
+
+        msg = log_str.format(i, base_acc, *comp_acc, total)
+        logger.info(msg)
+        messages.append(msg)
+
+def output_results():
+    rfile_path = path.join(base_dir, "docs", "mrt", "V3_results.rst")
+    cur_results = {}
+    with open(rfile_path, "r") as f:
+        for line in f:
+            if not line.startswith("**") or ":" not in line:
+                continue
+            _, model_name, result = line.split("**")
+            result = result[1:]
+            cur_results[model_name] = result
+    for model_name, result in results.items():
+        cur_results[model_name] = result
+    lines = [
+        "",
+        "************************",
+        "MRT Quantization Results",
+        "************************",
+        "",
+        ".. _mrt_quantization_results:",
+        "",
+    ]
+    for model_name, result in cur_results.items():
+        line = "**{0}**:{1}".format(model_name,result)
+        lines.append(line)
+        lines.append("")
+        lines.append("")
+    lines = [line+"\n" for line in lines]
+    with open(rfile_path, "w") as f:
+        f.writelines(lines)
+
+def register_test_case(yaml_file_name):
+    yaml_dir = path.join(base_dir, "tests", "mrt", "model_zoo")
+    yaml_file_name_ext = "{}.yaml".format(yaml_file_name)
+    yaml_file = path.join(yaml_dir, yaml_file_name_ext)
+
+    if yaml_file in yaml_files:
+        raise RuntimeError(
+            "test case: {} already registered.".format(yaml_file))
+    yaml_files.add(yaml_file)
+
+    def test_func(self):
+        base_cfg = merge_cfg(yaml_file)
+
+        # test preparation, calibration, quantization
+        argv = [
+            "--common.run_evaluate", "False",
+            "--common.run_compile", "False",
+        ]
+        cfg = override_cfg_args(base_cfg, argv)
+        run(cfg)
+
+        # test evaluation
+        evalfunc, data_iter_func, quantfunc = get_evaluation_info(
+            cfg.COMMON, cfg.EVALUATE)
+        logger = get_logger(cfg.COMMON.VERBOSITY)
+        messages = []
+        with self.assertRaises(StopIteration):
+            _multi_validate(
+                messages, evalfunc, data_iter_func, quantfunc,
+                iter_num=cfg.EVALUATE.ITER_NUM, logger=logger,
+                batch_size=cfg.EVALUATE.BATCH)
+        results[yaml_file_name] = messages[-1]
+        output_results()
+
+        # test compilation
+        argv = [
+            "--common.run_evaluate", "False",
+            "--common.run_compile", "True",
+            "--common.start_after", "quantize",
+        ]
+        cfg = override_cfg_args(base_cfg, argv)
+        run(cfg)
+
+    def wrapper(cls):
+        func_name = "test_case_{}".format(yaml_file_name)
+        setattr(cls, func_name, test_func)
+        return cls
+
+    return wrapper
+
+
+# @register_test_case("alexnet")
+# @register_test_case("densenet161")
+# @register_test_case("mobilenet1_0")
+# @register_test_case("mobilenetv2_1.0")
+# @register_test_case("resnet18_v1")
+# @register_test_case("resnet18_v1b_0.89")
+# @register_test_case("resnet50_v1")
+# @register_test_case("resnet50_v2")
+# @register_test_case("shufflenet_v1")
+# @register_test_case("squeezenet1.0")
+# @register_test_case("tf_inception_v3")
+# @register_test_case("vgg19")
+# @register_test_case("cifar_resnet20_v1")
+# @register_test_case("mnist")
+# @register_test_case("qd10_resnetv1_20")
+# @register_test_case("quickdraw")
+# @register_test_case("ssd")
+# @register_test_case("ssd_512_mobilenet1.0_voc")
+# @register_test_case("trec")
+# @register_test_case("yolo3_darknet53_voc")
+# @register_test_case("yolo3_mobilenet1.0_voc")
+class TestV3(unittest.TestCase):
+    pass
+
+if __name__ == "__main__":
+    unittest.main()

tests/deprecated/test_alexnet.py

@@ -0,0 +1,92 @@
+import gluon_zoo as gz
+import mxnet as mx
+from mxnet import ndarray as nd
+from mxnet import gluon
+
+import sym_pass as spass
+import dataset as ds
+import sym_calib as calib
+import sim_quant_helper as sim
+import utils
+import mrt as _mrt
+
+gz.save_model("alexnet")
+
+
+def load_fname(version, suffix=None, with_ext=False):
+    suffix = "."+suffix if suffix is not None else ""
+    prefix = "./data/alexnet%s%s" % (version, suffix)
+    return utils.extend_fname(prefix, with_ext=with_ext)
+
+batch_size = 700
+input_size = 224
+inputs_ext = { 'data': {
+    'shape': (batch_size, 3, input_size, input_size)
+}}
+inputs = [mx.sym.var(n) for n in inputs_ext]
+# ctx = mx.gpu(2)
+ctx = [mx.gpu(int(i)) for i in "1,2,3,4,5,6,7".split(',') if i.strip()]
+
+utils.log_init()
+
+data_iter = ds.load_imagenet_rec(batch_size, input_size)
+def data_iter_func():
+    data = data_iter.next()
+    return data.data[0], data.label[0]
+data, _ = data_iter_func()
+
+sym_file, param_file = load_fname("")
+net1 = utils.load_model(sym_file, param_file, inputs, ctx=ctx)
+acc_top1 = mx.metric.Accuracy()
+acc_top5 = mx.metric.TopKAccuracy(5)
+acc_top1.reset()
+acc_top5.reset()
+def alexnet(data, label):
+    data = gluon.utils.split_and_load(data, ctx_list=ctx, batch_axis=0, even_split=False)
+    res = [net1.forward(d) for d in data]
+    res = nd.concatenate(res)
+    acc_top1.update(label, res)
+    _, top1 = acc_top1.get()
+    acc_top5.update(label, res)
+    _, top5 = acc_top5.get()
+    return "top1={:6.2%} top5={:6.2%}".format(top1, top5)
+
+# sym, params = mx.sym.load(sym_file), nd.load(param_file)
+# sym, params = spass.sym_quant_prepare(sym, params, inputs_ext)
+# qsym, qparams, precs, _ = calib.sym_simulate(sym, params, inputs_ext, data, ctx)
+# qsym, qparams = calib.sym_realize(qsym, qparams, inputs_ext, precs, "cvm")
+# dump_sym, dump_params, dump_ext = load_fname("", "sym.quantize", True)
+# sim.save_ext(dump_ext, inputs_ext)
+# nd.save(dump_params, qparams)
+# open(dump_sym, "w").write(qsym.tojson())
+
+dump_sym, dump_params, dump_ext = load_fname("", "sym.quantize", True)
+sym, params = mx.sym.load(dump_sym), nd.load(dump_params)
+(inputs_ext,) = sim.load_ext(dump_ext)
+if True:
+    _mrt.std_dump(sym, params, inputs_ext, data, "alexnet",
+            is_mxnet=True)
+    exit()
+inputs = [mx.sym.var(n) for n in inputs_ext]
+net2 = utils.load_model(dump_sym, dump_params, inputs, ctx=ctx)
+qacc_top1 = mx.metric.Accuracy()
+qacc_top5 = mx.metric.TopKAccuracy(5)
+qacc_top1.reset()
+qacc_top5.reset()
+def cvm_quantize(data, label):
+    data = sim.load_real_data(data, 'data', inputs_ext)
+    data = gluon.utils.split_and_load(data, ctx_list=ctx, batch_axis=0, even_split=False)
+    res = [net2.forward(d) for d in data]
+    res = nd.concatenate(res)
+    qacc_top1.update(label, res)
+    _, top1 = qacc_top1.get()
+    qacc_top5.update(label, res)
+    _, top5 = qacc_top5.get()
+    return "top1={:6.2%} top5={:6.2%}".format(top1, top5)
+
+utils.multi_validate(alexnet, data_iter_func,
+        cvm_quantize,
+        iter_num=1000000)
+# utils.multi_eval_accuracy(alexnet, data_iter_func,
+#        cvm_quantize,
+#        iter_num=10000)

tests/deprecated/test_byr.py

@@ -0,0 +1,58 @@
+import transformer as tfm
+
+import sym_pass as spass
+import sym_utils as sutils
+from sym_utils import topo_visit_transformer
+import mxnet as mx
+import nnvm
+import numpy as np
+from ut_base import *
+
+class TestFuseMultiplyInputs(TfmTest):
+    def test_fmi(self):
+        d1 = mx.sym.var('d1', shape=(2, 3))
+        d2 = mx.sym.var('d2', shape=(2, 4))
+        d3 = mx.sym.var('d3', shape=(2, 3))
+        op = mx.sym.concat(d1, d2, d3)
+        sym = transfer_multiple_inputs(op, {})
+
+        data = mx.sym.var('data', shape=(20,))
+        s1 = mx.sym.slice(data, begin=(0,), end=(6,))
+        r1 = mx.sym.reshape(s1, shape=(2, 3))
+        s2 = mx.sym.slice(data, begin=(6,), end=(14,))
+        r2 = mx.sym.reshape(s2, shape=(2, 4))
+        s3 = mx.sym.slice(data, begin=(14,), end=(20,))
+        r3 = mx.sym.reshape(s3, shape=(2, 3))
+        des = mx.sym.concat(r1, r2, r3)
+
+        self._assert_equal(sym, des)
+
+@tfm.N.register_nm("fmi")
+def transfer_multiple_inputs(sym, params):
+    infer_shapes = tfm.infer_shape(sym, params)
+    dim_sum, dim_per, dims = 0, {}, {}
+    def _sum_input(node, params, **kwargs):
+        name = node.attr('name')
+        nonlocal dim_sum, dim_per, dims
+        if sutils.is_inputs(node, params):
+            dims[name] = infer_shapes[name][0]
+            dot = np.product(dims[name])
+            dim_per[name] = dot
+            dim_sum += dot
+    topo_visit_transformer(sym, params, _sum_input)
+    data_sum = mx.sym.var('data', shape=(dim_sum,))
+    first, last = 0, 0
+    def _change_node(op, params, graph, **kwargs):
+        name = op.attr('name')
+        if sutils.is_inputs(op, params):
+            nonlocal first, last
+            last = first + dim_per[name]
+            op = mx.sym.slice(data_sum, name=tfm.N.n('slice'),
+                    begin=(first,), end=(last,))
+            op = mx.sym.reshape(op, name=tfm.N.n('reshape'),
+                    shape=dims[name])
+            first = last
+        return op
+    sym, params = topo_visit_transformer(sym, params, _change_node)
+    return sym
+

tests/deprecated/test_check_graph.py

@@ -0,0 +1,27 @@
+import mxnet as mx
+import sym_utils as sutils
+import sym_pass as spass
+import logging
+import utils
+import json
+from mxnet import ndarray as nd
+
+version = "v3"
+
+def load_fname(version, suffix=None, with_ext=False):
+    suffix = "."+suffix if suffix is not None else ""
+    fname = "./data/tf_inception%s%s"%(version, suffix)
+    return utils.extend_fname(fname, with_ext)
+
+
+utils.log_init()
+logger = logging.getLogger("log.test.check_graph")
+sym, prm = load_fname(version)
+symbol, params = mx.sym.load(sym), nd.load(prm)
+
+
+symbol, params = sutils.check_graph(symbol, params, logger)
+symbol, params = spass.fuse_transpose(symbol, params, logger)
+fsym, _ = load_fname("vt2")
+with open(fsym, "w") as f:
+    f.write(symbol.tojson())