权重量化是将conv2d的权重进行int8量化，需要将量化的结果进行比较。

    tvm中的用于比较2个tensor是否近似相同的函数是：
    tvm**.testing.**assert_allclose,
    该函数等效于 **numpy.testing.assert_allclose**

    1. from warnings import showwarning
    2. import numpy as np
    3. import tensorflow as tf
    4. import tvm
    5. import vacc.quantize_weight
    6. from tvm import relay
    7. from tvm.relay import testing
    8. from tvm.relay.frontend.common import infer_value
    9. from tvm.relay import op as _op
    10. from tvm.relay import analysis as _analysis
    11. from tvm.relay import transform
    12. from tvm.contrib import graph_runtime
    15. def test_weight_quantization_result():
    16.     # tgt = "llvm"
    17.     # ctx = tvm.cpu()
    18.     # targets = {
    19.     #     tvm.expr.IntImm("int32", ctx.device_type): tgt
    20.     # }
    21.     targets = "llvm"
    22.     ctx = tvm.cpu(0)
    23.     dtype = "float32"
    24.     dshape = (1, 4, 8, 8)
    25.     wshape = (4, 4, 3, 3)
    27.     # function
    28.     data = relay.var("data", dtype=dtype, shape=dshape)
    29.     w0 = relay.var("weight", dtype=dtype, shape=wshape)
    30.     z = relay.nn.conv2d(data, w0)
    31.     func = relay.Function([data, w0], z)
    33.     # module
    34.     mod = relay.Module.from_expr(func)
    36.     # params
    37.     act = np.random.uniform(-1, 1, dshape).astype(dtype)
    38.     wei = np.random.uniform(-0.5, 0.5, wshape).astype(dtype)
    39.     DATA = tvm.nd.array(act, ctx=ctx)
    40.     WEIGHT = tvm.nd.array(wei, ctx=ctx)
    41.     params = {"weight": WEIGHT}
    43.     def get_output(mod, params):
    44.         print("\n---------------------------------------------")
    45.         print("original module and params:")
    46.         print(mod.astext(show_meta_data=False))
    47.         print(params)
    48.         print("---------------------------------------------")
    50.         # build
    51.         with relay.build_config(opt_level=2):
    52.             g_json, mmod, params = relay.build(
    53.                 mod, targets, "llvm", params=params)
    55.         # create module
    56.         rt = graph_runtime.create(g_json, mmod, ctx)
    58.         # set input and parameters
    59.         rt.set_input("data", DATA)
    60.         # rt.load_params(relay.save_param_dict(params))
    61.         rt.set_input(**params)
    63.         # run
    64.         rt.run()
    66.         # get output
    67.         out = rt.get_output(0)
    68.         print("out:\n", out)
    69.         return out.asnumpy()
    71.     def normal_compute():
    72.         """
    73.         normal compute
    74.         """
    75.         return get_output(mod, params)
    77.     def data_processed():
    78.         """
    79.         data are processed (divide, round, clip, multiply)
    80.         """
    81.         max_scale = np.amax(np.abs(wei))
    82.         valid_range = 127
    83.         k_scale = max_scale/valid_range
    84.         clip_min = -valid_range
    85.         clip_max = valid_range
    86.         wei_scaled = wei/k_scale
    87.         wei_scaled = np.round(wei_scaled)
    88.         wei_scaled = np.clip(wei_scaled, clip_min, clip_max)
    89.         wei_scaled = wei_scaled * k_scale
    90.         WEIGHT2 = tvm.nd.array(wei_scaled, ctx=ctx)
    91.         params2 = {"weight": WEIGHT2}
    92.         return get_output(mod, params2)
    94.     def weightonly_quantization():
    95.         """
    96.         weight-only quantization
    97.         """
    98.         # quantize
    99.         with vacc.quantize_weight.qconfig():
    100.             qmod = vacc.quantize_weight.quantize(mod, params)
    101.         print("\n---------------------------------------------")
    102.         print("module after quantization:")
    103.         print(qmod.astext(show_meta_data=False))
    104.         print("---------------------------------------------")
    106.         return get_output(qmod, params)
    108.     def compute_by_tf():
    109.         """
    110.         compute by tensorflow
    111.         """
    112.         x_in = act.transpose(0, 2, 3, 1)
    113.         kernel_in = wei.transpose(2, 3, 1, 0)
    114.         x = tf.constant(x_in, dtype=tf.float32)
    115.         kernel = tf.constant(kernel_in, dtype=tf.float32)
    116.         res = tf.nn.conv2d(x, kernel, strides=[1, 1, 1, 1], padding='VALID')
    117.         with tf.Session() as sess:
    118.             out = sess.run(res)
    119.             print(out)
    120.             print("input shape:", x_in.shape)
    121.             print("kernel shape:", kernel_in.shape)
    122.             print("output shape:", out.shape)
    123.             print("out:\n", out)
    124.             return out
    126.     r1 = normal_compute()
    127.     r2 = data_processed()
    128.     r3 = weightonly_quantization()
    129.     # note : layout of tensorflow is NHWC, transpose to NCHW
    130.     r4 = compute_by_tf().transpose(0, 3, 1, 2)
    132.     # np.testing.assert_allclose(r1, r2, rtol=1e-3, atol=1e-2)
    133.     tvm.testing.assert_allclose(r2, r3, rtol=1e-7, atol=1e-3)
    134.     tvm.testing.assert_allclose(r1, r4, rtol=1e-7, atol=1e-3)