def fused_bn_grad_5D_run_3(shape, dtype, kernel_name, attrs): """ test bnGrad_3 """ def get_expect(dy, rs, dgamma_dx, dbeta_dx, data_minus_mean): dx = rs * dy + dbeta_dx + data_minus_mean * dgamma_dx return [dx] shape_c1c0 = (1, shape[1], 1, 1, shape[4]) bng3_shapes = [shape, shape_c1c0, shape_c1c0, shape_c1c0, shape] bng3_dtypes = [dtype, "float32", "float32", "float32", "float32"] if 'tuning' in attrs.keys(): t = attrs.get("tuning", False) kernel_name = attrs.get("kernel_name", False) mod = utils.op_build_test(fused_batch_norm_grad_split.fused_bn_grad_3, bng3_shapes, bng3_dtypes, kernel_name=kernel_name + "_step3", attrs=attrs, tuning=t) if t: inputs = [np.random.rand(*s).astype(t) for (s, t) in zip(bng3_shapes, bng3_dtypes)] outputs = np.full(shape, np.nan, dtype) expects = get_expect(*inputs) return mod, expects, (*inputs, *outputs) else: return mod # np.random.seed(0) inputs = [np.random.rand(*s).astype(t) for (s, t) in zip(bng3_shapes, bng3_dtypes)] outputs = np.full(shape, np.nan, dtype) mod = utils.op_build_test(fused_batch_norm_grad_split.fused_bn_grad_3, bng3_shapes, bng3_dtypes, kernel_name=kernel_name + "_step3", attrs=attrs) outputs = [ utils.mod_launch(mod, (*inputs, outputs), expect=get_expect(*inputs)) ] expects = get_expect(*inputs) rtol, atol = get_rtol_atol("fused_batch_norm_grad", dtype) results = list(map(lambda x, y: np.allclose(x, y, rtol=rtol, atol=atol), outputs, expects)) print("results", results) return inputs, outputs, expects, all(results)
def unsortedsegmentsum_execute(shape, ids_shape, num_segments, dtype, attrs): if 'tuning' in attrs.keys(): t = attrs.get("tuning", False) kernel_name = attrs.get("kernel_name", False) mod = unsortedsegmentsum_compile(shape, ids_shape, num_segments, dtype, attrs, kernel_name=kernel_name, tuning=t) if t: expect, input, output, segment_ids = gen_data( dtype, ids_shape, num_segments, shape) return mod, expect, (input, segment_ids, output) else: return mod else: mod = unsortedsegmentsum_compile(shape, ids_shape, num_segments, dtype, attrs) expect, input, output, segment_ids = gen_data(dtype, ids_shape, num_segments, shape) output = utils.mod_launch(mod, (input, segment_ids, output), expect=expect) rtol, atol = get_rtol_atol("unsortedsegmentsum", dtype) return (input, segment_ids, num_segments), output, expect, compare_tensor(output, expect, rtol=rtol, atol=atol, equal_nan=True)
def fake_quant_with_min_max_vars_per_channel_run(shape_input, shape_min, shape_max, dtype, num_bits=8, narror_range=False, attrs=None): """fake_quant_with_min_max_vars_per_channel_run""" mod = utils.op_build_test( fake_quant_with_min_max_vars_per_channel. fake_quant_with_min_max_vars_per_channel, [shape_input, shape_min, shape_max], [dtype, dtype, dtype], [num_bits, narror_range], kernel_name='fake_quant_with_min_max_vars_per_channel', attrs=attrs) args, exp_output, input_data, input_min, input_max = gen_data( shape_input, shape_min, shape_max, dtype, num_bits, narror_range) acu_output = utils.mod_launch(mod, args, expect=exp_output) # compare result rtol, atol = get_rtol_atol("fake_quant_with_min_max_vars_per_channel", dtype) testcase_result = compare_tensor(acu_output, exp_output, rtol=rtol, atol=atol, equal_nan=True) return [input_data, input_min, input_max], acu_output, exp_output, testcase_result
def dropout_execute(shape_tensor, keep_prob, dtype, kernel_name, attrs=None): # Create op if 'tuning' in attrs.keys(): t = attrs.get("tuning", False) kernel_name = attrs.get("kernel_name", False) mod = dropout_compile(shape_tensor, keep_prob, dtype, kernel_name, attrs, tuning=t) if t: expect, input, output, mask = gen_data(dtype, shape_tensor, keep_prob) return mod, expect, (input, mask, output) else: return mod else: mod = dropout_compile(shape_tensor, keep_prob, dtype, kernel_name, attrs) expect, input, output, mask = gen_data(dtype, shape_tensor, keep_prob) output = utils.mod_launch(mod, (input, mask, output), expect=expect) source_code = mod.imported_modules[0].get_source() utils.create_code(kernel_name, "./", source_code) rtol, atol = get_rtol_atol("dropout", dtype) return (input, mask), output, expect, compare_tensor(output, expect, rtol=rtol, atol=atol, equal_nan=True)
def logsoftmax_execute(shape, dtype, axis, kernel_name, attrs=None): if 'tuning' in attrs.keys(): t = attrs.get("tuning", False) kernel_name = attrs.get("kernel_name", False) mod = logsoftmax_compile(shape, dtype, axis, kernel_name, attrs=None, tuning=t) if t: expect, input, output = method_name(axis, dtype, shape) return mod, expect, (input, output) else: return mod else: mod = logsoftmax_compile(shape, dtype, axis, kernel_name, attrs) expect, input, output = method_name(axis, dtype, shape) output = utils.mod_launch(mod, (input, output), expect=expect) rtol, atol = get_rtol_atol("logsoftmax", dtype) return input, output, expect, compare_tensor(output, expect, rtol=rtol, atol=atol, equal_nan=True)
def matmul_execute(shape_x, shape_y, bias, left_format, right_format, out_format, adj_x, adj_y, dtype, out_dtype, kernel_name, attrs): ''' There are four types of fractal format in Davinci core: zZ, zN, nZ, nN general matmul format left_trans: False right_trans False: zZ * nZ = zN left_trans: True right_trans False: nN * nZ = zN left_trans: False right_trans True : zZ * zN = zN left_trans: True right_trans True : nN * zN = zN Now we need to support: zN * nZ = zN use left_format to specify, left matrix data format use right_format to specify, right matrix data format ''' batch_tuple, m, k, n = extract_dim(shape_x, shape_y, adj_x, adj_y) m = (m + 15) // 16 * 16 n = (n + 15) // 16 * 16 k = (k + 15) // 16 * 16 shape_xx, shape_yy, bias_shape, out_shape, k = get_converted_shapes(m, n, k, batch_tuple, adj_x, adj_y, bias, left_format, right_format, out_format) mod = dynamic_matmul_compile(shape_x, shape_y, bias, left_format, right_format, out_format, adj_x, adj_y, dtype, out_dtype, kernel_name, attrs) # Generate data m_x, m_y, bench_mark, bias_data = matmul_data(batch_tuple, m, k, n, dtype, out_dtype, bias, adj_x, adj_y, left_format, right_format, out_format) # mod launch output = np.full(out_shape, np.nan, out_dtype) if bias == 0: output = utils.mod_launch(mod, (m_x, m_y, output, 1, 1, 1, 1, 1, 1, 1, 1, 1), outputs=(2,), expect=bench_mark) elif bias == 1: output = utils.mod_launch(mod, (m_x, m_y, bias_data, output), expect=bench_mark) # compare result rtol, atol = get_rtol_atol("matmul", dtype) compare_result = compare_tensor(output, bench_mark, rtol=rtol, atol=atol, equal_nan=True) # compare_result = utils.result_compare(output, bench_mark, r_tol=5e-3) return (m_x, m_y), output, bench_mark, compare_result
def log_ad_run(shape, dtype, kernel_name, attrs): input_shape = [shape, shape] input_dtype = [dtype, dtype] if 'tuning' in attrs.keys(): t = attrs.get("tuning", False) kernel_name = attrs.get("kernel_name", False) mod = utils.op_build_test(log_ad.log_ad, input_shape, input_dtype, kernel_name=kernel_name, attrs=attrs, tuning=t) if t: expect, head_np, input, output = gen_data(dtype, shape) return mod, expect, (head_np, input, output) else: return mod else: mod = utils.op_build_test(log_ad.log_ad, input_shape, input_dtype, kernel_name=kernel_name, attrs=attrs) expect, head_np, input, output = gen_data(dtype, shape) output = utils.mod_launch(mod, (head_np, input, output), expect=expect) rtol, atol = get_rtol_atol("log_ad", dtype) return input, output, expect, compare_tensor(output, expect, rtol=rtol, atol=atol, equal_nan=True)
def cos_run(shape, dtype, attrs): # Generate data for testing the op inputs = random_gaussian(shape, miu=0, sigma=0.1).astype(dtype) expect = np.cos(inputs) # inputs and output to hold the data output = np.full(shape, np.nan, dtype) if 'tuning' in attrs.keys(): t = attrs.get("tuning", False) kernel_name = attrs.get("kernel_name", False) mod = utils.op_build_test(cos.cos, [shape], [dtype], kernel_name=kernel_name, attrs=attrs, tuning=t) if t: return mod, expect, (inputs, output) else: return mod else: mod = utils.op_build_test(cos.cos, [shape], [dtype], kernel_name='cos', attrs=attrs) # result_tvm output = utils.mod_launch(mod, (inputs, output)) # compare result rtol, atol = get_rtol_atol("cos", dtype) TestCase_Result = compare_tensor(output, expect, rtol=rtol, atol=atol, equal_nan=False) return inputs, output, expect, TestCase_Result
def cos_ad_run(shape, dtype, attrs): if 'tuning' in attrs.keys(): t = attrs.get("tuning", False) kernel_name = attrs.get("kernel_name", False) expect, head_np, inputs = get_input_data(dtype, shape) mod = utils.op_build_test(cos_ad.cos_ad, [expect.shape, shape], [dtype, dtype], kernel_name=kernel_name, attrs=attrs, tuning=t) if t: # inputs and output to hold the data output = np.full(expect.shape, np.nan, dtype) return mod, expect, (head_np, inputs, output) else: return mod else: expect, head_np, inputs = get_input_data(dtype, shape) mod = utils.op_build_test(cos_ad.cos_ad, [expect.shape, shape], [dtype, dtype], kernel_name='cos_ad', attrs=attrs) # inputs and output to hold the data output = np.full(expect.shape, np.nan, dtype) output = utils.mod_launch(mod, (head_np, inputs, output), expect=expect) # compare result rtol, atol = get_rtol_atol("cos_ad", dtype) TestCase_Result = compare_tensor(output, expect, rtol=rtol, atol=atol, equal_nan=False) return (head_np, inputs), output, expect, TestCase_Result
def fused_layernorm_execute(shape_x, begin_norm_axis, begin_params_axis, dtype, attrs): if 'tuning' in attrs.keys(): t = attrs.get("tuning", False) kernel_name = attrs.get("kernel_name", False) mod = fused_layernorm_compile(shape_x, begin_norm_axis, begin_params_axis, dtype, attrs, kernel_name=kernel_name, tuning=t) if t: beta, expect, gamma, input, out_mean, out_variance, output = gen_data( begin_norm_axis, begin_params_axis, dtype, shape_x) return mod, expect, { "args": (input, gamma, beta, output, out_mean, out_variance), 'outputs': (-3, -2, -1), 'tuning': False } else: return mod else: mod = fused_layernorm_compile(shape_x, begin_norm_axis, begin_params_axis, dtype, attrs) beta, expect, gamma, input, out_mean, out_variance, output = gen_data( begin_norm_axis, begin_params_axis, dtype, shape_x) res = utils.mod_launch( mod, (input, gamma, beta, output, out_mean, out_variance), outputs=(-3, -2, -1), expect=expect) rtol, atol = get_rtol_atol("layernorm", dtype) return (input, gamma, beta, begin_norm_axis, begin_params_axis), res, expect, \ all(map(lambda x, y: compare_tensor(x, y, rtol=rtol, atol=atol), res, expect))
def exp_run(shape, dtype, attrs): if 'tuning' in attrs.keys(): t = attrs.get("tuning", False) kernel_name = attrs.get("kernel_name", False) mod = utils.op_build_test(exp.exp, [shape], [dtype], kernel_name=kernel_name, attrs=attrs, tuning=t) if t: expect, input, output = gen_data(dtype, shape) return mod, expect, (input, output) else: return mod else: mod = utils.op_build_test(exp.exp, [shape], [dtype], kernel_name='exp', attrs=attrs) expect, input, output = gen_data(dtype, shape) output = utils.mod_launch(mod, (input, output), expect=expect) rtol, atol = get_rtol_atol("exp", dtype) return input, output, expect, compare_tensor(output, expect, rtol=rtol, atol=atol, equal_nan=True)
def KLdiv_ad_run(shape, dtype, kernel_name="", attrs=None): expects, head, mean, scale, outputs = gen_data(dtype, shape) mod = utils.op_build_test(distr_normal_diag_KLdiv_ad.normal_diag_KLdiv_ad, [head.shape, mean.shape, scale.shape], [dtype, dtype, dtype], kernel_name=kernel_name, op_attrs=None, attrs=None, log_cce=True, dump_cce=True, polyhedral=True) outputs = utils.mod_launch(mod, [head, mean, scale, *outputs], outputs=tuple(range(-len(outputs), 0)), expect=expects) outputs = list(outputs) result = True rtol, atol = get_rtol_atol("KL_div_ad", dtype) for i in range(len(outputs)): result &= compare_tensor(outputs[i], expects[i], rtol=rtol, atol=atol, equal_nan=True) return (head, mean, scale), outputs, expects, result
def apply_ftrl_run(shape, dtype, attrs=None): """run function for dsl function apply_ftrl.""" scalar_shape = (1, ) var_shape, accum_shape, linear_shape, grad_shape = [shape] * 4 lr_shape, l1_shape, l2_shape, lr_power_shape = [scalar_shape] * 4 shapes = [ var_shape, accum_shape, linear_shape, grad_shape, lr_shape, l1_shape, l2_shape, lr_power_shape ] dtypes = [dtype] * 9 mod = utils.op_build_test(apply_ftrl, shapes, dtypes, kernel_name='apply_ftrl', attrs=attrs) expects, (var, accum, linear, grad), (lr, l1, l2, lr_power) = gen_data(dtype, shape) outputs = utils.mod_launch( mod, (var, accum, linear, grad, lr, l1, l2, lr_power), outputs=(0, 1, 2)) rtol, atol = get_rtol_atol("apply_ftrl", dtype) compare_result = list( map(lambda x, y: compare_tensor(x, y, rtol=rtol, atol=atol), outputs, expects)) inputs = (var, accum, linear, grad, lr, l1, l2, lr_power) return inputs, outputs, expects, all(compare_result)
def fused_minimum_or_maximum_grad_execute(shape_dz, shape_x, shape_y, grad_x, grad_y, op_type, dtype, kernel_name, attrs): if 'tuning' in attrs.keys(): t = attrs.get("tuning", False) kernel_name = attrs.get("kernel_name", False) mod = fused_minimum_or_maximum_grad_compile(shape_dz, shape_x, shape_y, grad_x, grad_y, op_type, dtype, kernel_name, attrs, t) if t: input, expect = genData(shape_dz, shape_x, shape_y, grad_x, grad_y, op_type, dtype) output_dx = np.full(expect[0].shape, 0, dtype) output_dy = np.full(expect[1].shape, 0, dtype) return mod, expect, {"args": (input[2], input[0], input[1], output_dx, output_dy), 'outputs': (-2, -1), 'tuning': False} else: return mod input, expect = genData(shape_dz, shape_x, shape_y, grad_x, grad_y, op_type, dtype) mod = fused_minimum_or_maximum_grad_compile(shape_dz, shape_x, shape_y, grad_x, grad_y, op_type, dtype, kernel_name, attrs) # get the result from mod rtol, atol = get_rtol_atol("fused_minimum_or_maximum_grad", dtype) if grad_x and grad_y: output_dx = np.full(expect[0].shape, 0, dtype) output_dy = np.full(expect[1].shape, 0, dtype) res = utils.mod_launch(mod, (input[2], input[0], input[1], output_dx, output_dy), (-2, -1), expect=expect) return (input[2], input[0], input[1]), res, expect, all( map(lambda x, y: compare_tensor(x, y, rtol=rtol, atol=atol, equal_nan=True), res, expect)) else: output = np.full(expect.shape, 0, dtype) output = utils.mod_launch(mod, (input[2], input[0], input[1], output), expect=expect) test_case_result = compare_tensor(output, expect, rtol=rtol, atol=atol, equal_nan=True) return input, output, expect, test_case_result
def maxpool_run(shape, kernel, stride, pad, hybrid, dtype, attrs=None, polyhedral=True): if attrs.get("dynamic"): var_shape = [] for i in range(len(shape)): if i == len(shape) - 1: var_shape.append(shape[i]) else: var_shape.append(tvm.var("I" + str(i))) build_shape = var_shape else: build_shape = shape if 'tuning' in attrs.keys(): t = attrs.get("tuning", False) kernel_name = attrs.get("kernel_name", False) mod = utils.op_build_test(maxpool.maxpool, [build_shape], [dtype], op_attrs=[kernel, stride, pad], kernel_name=kernel_name, attrs=attrs, tuning=t) if t: expect, input, out_shape, res = gen_data(dtype, kernel, pad, shape, stride) return mod, expect, {"args": (input, res), 'outputs': (-1, ), 'tuning': False} else: return mod else: if polyhedral: if hybrid: mod = utils.op_build_test(maxpool.maxpool, [build_shape], [dtype], op_attrs=[kernel, stride, pad], kernel_name='maxpool', attrs=attrs) else: mod = utils.op_build_test(maxpool.old_maxpool, [build_shape], [dtype], op_attrs=[kernel, stride, pad], kernel_name='maxpool_old', attrs=attrs) else: mod = maxpool.maxpool_manual_schedule(build_shape, kernel, stride, pad, dtype,attrs=attrs, polyhedral=polyhedral) expect, input, out_shape, res = gen_data(dtype, kernel, pad, shape, stride) output = utils.mod_launch(mod, [input, res], expect=expect) rtol, atol = get_rtol_atol("maxpool", dtype) return input, output, expect, compare_tensor(output, expect, rtol=rtol, atol=atol, equal_nan=True)
def mul_run(shapes, dtype, attrs): if 'tuning' in attrs.keys(): t = attrs.get("tuning", False) kernel_name = attrs.get("kernel_name", False) mod = utils.op_build_test(mul.mul, shapes, [dtype, dtype], kernel_name=kernel_name, attrs=attrs, tuning=t) if t: expect, lhd, output, rhd = gen_data(dtype, shapes) return mod, expect, (lhd, rhd, output) else: return mod else: mod = utils.op_build_test(mul.mul, shapes, [dtype, dtype], kernel_name='mul', attrs=attrs) expect, lhd, output, rhd = gen_data(dtype, shapes) output = utils.mod_launch(mod, (lhd, rhd, output), expect=expect) rtol, atol = get_rtol_atol("mul", dtype) return (lhd, rhd), output, expect, compare_tensor(output, expect, rtol=rtol, atol=atol, equal_nan=True)
def reshape_execute(in_shape, out_shape, dtype, attrs): if attrs is None: attrs = {} if 'tuning' in attrs.keys(): t = attrs.get("tuning", False) kernel_name = attrs.get("kernel_name", False) mod = reshape_compile(in_shape, out_shape, dtype, attrs, kernel_name=kernel_name, tuning=t) if t: expect, input, output = gen_data(dtype, in_shape, out_shape) return mod, expect, (input, output) else: return mod else: mod = reshape_compile(in_shape, out_shape, dtype, attrs) expect, input, output = gen_data(dtype, in_shape, out_shape) args = [input, output] if attrs.get("dynamic"): for index in range(len(out_shape) - 1): args.append(out_shape[index]) for i in in_shape: args.append(i) block_dim = compute_blockdim(in_shape) args.append(block_dim) output = utils.mod_launch(mod, args, outputs=(1, ), expect=expect) rtol, atol = get_rtol_atol("reshape", dtype) return input, output, expect, compare_tensor(output, expect, rtol=rtol, atol=atol, equal_nan=True)
def exp_ad_run(shape, dtype, attrs): if 'tuning' in attrs.keys(): t = attrs.get("tuning", False) kernel_name = attrs.get("kernel_name", False) mod = utils.op_build_test(exp_ad, [shape, shape], [dtype, dtype], kernel_name=kernel_name, attrs=attrs, tuning=t) expect, head_np, input_np = gen_data(dtype, shape) if t: output = np.full(expect.shape, np.nan, dtype) return mod, expect, (head_np, input_np, output) else: return mod else: mod = utils.op_build_test(exp_ad, [shape, shape], [dtype, dtype], kernel_name='exp_ad', attrs=attrs) expect, head_np, input_np = gen_data(dtype, shape) output = np.full(expect.shape, np.nan, dtype) output = utils.mod_launch(mod, (head_np, input_np, output), expect=expect) rtol, atol = get_rtol_atol("exp", dtype) return (head_np, input_np), output, expect, compare_tensor(output, expect, rtol=rtol, atol=atol)
def relu_grad_run(shape, dtype, attrs): if 'tuning' in attrs.keys(): t = attrs.get("tuning", False) kernel_name = attrs.get("kernel_name", False) mod = utils.op_build_test(relu_grad.relu_grad, [shape, shape], [dtype, dtype], kernel_name=kernel_name, attrs=attrs, tuning=t) if t: dy, expect, input_np, output = gen_data(dtype, shape) return mod, expect, (input_np, dy, output) else: return mod else: mod = utils.op_build_test(relu_grad.relu_grad, [shape, shape], [dtype, dtype], kernel_name='relu_grad', attrs=attrs) dy, expect, input_np, output = gen_data(dtype, shape) output = utils.mod_launch(mod, (input_np, dy, output), expect=expect) rtol, atol = get_rtol_atol("relu_grad", dtype) return (input_np, dy), output, expect, compare_tensor(output, expect, rtol=rtol, atol=atol, equal_nan=True)
def minimum_ad_run(shape, dtype, grad_x=True, grad_y=True, attrs=None): """minimum_ad_run implementation""" mod = utils.op_build_test(minimum_ad.minimum_ad, [shape, shape, shape], [dtype, dtype, dtype], kernel_name='minimum_ad', op_attrs=[grad_x, grad_y], attrs=attrs) rtol, atol = get_rtol_atol("minimum_ad", dtype) grads, data_x, data_y, output_dx, output_dy, exp_dx, exp_dy = gen_data( shape, dtype) inputs = (grads, data_x, data_y) if grad_x and grad_y: args = (*inputs, output_dx, output_dy) expects = (exp_dx, exp_dy) outputs = utils.mod_launch(mod, args, outputs=(-2, -1), expect=expects) elif grad_x: args = (*inputs, output_dx) expects = exp_dx outputs = utils.mod_launch(mod, args, outputs=(-1, ), expect=expects) else: args = (*inputs, output_dy) expects = exp_dy outputs = utils.mod_launch(mod, args, outputs=(-1, ), expect=expects) testcase_result = compare_tensor(outputs, expects, rtol=rtol, atol=atol, equal_nan=True) return inputs, outputs, expects, testcase_result
def quantized_max_pool_run(shape, dtype1, shape_list, dtype2, ksize, strides, padding, data_format, quant_algo, scale_mode, scale_sqrt, attrs): """run function""" if not isinstance(shape_list, (list, tuple, type(None))): raise RuntimeError("shape_list should be a list, tuple or None!") op_attrs = [ksize, strides, padding, data_format, quant_algo, scale_mode, scale_sqrt] if shape_list is None: mod = utils.op_build_test(quantized_max_pool, [shape], [dtype1], op_attrs=[None] + op_attrs, kernel_name='quantized_maxpool', attrs=attrs) else: mod = utils.op_build_test(quantized_max_pool, [shape, shape_list], [dtype1, dtype2], op_attrs=op_attrs, kernel_name='quantized_maxpool', attrs=attrs) expect, inputs, out_buf = gen_data(shape, dtype1, shape_list, dtype2, ksize, strides, padding, data_format, quant_algo, scale_mode, scale_sqrt) output = utils.mod_launch(mod, (*inputs, *out_buf), expect=expect) rtol, atol = get_rtol_atol("quantized_maxpool", dtype1) if expect.dtype in ("int8", "uint8"): cmp_res = compare_int(output, expect) else: cmp_res = compare_tensor(output, expect, rtol=rtol, atol=atol) return inputs, output, expect, cmp_res
def scatter_add_run(shape_ref, shape_indices, dtype_ref, dtype_indices, attrs=None): """scatter_add_run implementation""" args, exp_output, ref, indices, updates = gen_data(shape_ref, shape_indices, dtype_ref, dtype_indices) shape_updates = updates.shape mod = utils.op_build_test(scatter_add.scatter_add, [shape_ref, shape_indices, shape_updates], [dtype_ref, dtype_indices, dtype_ref], kernel_name='scatter_add', op_attrs=[], attrs=attrs) acu_output = utils.mod_launch(mod, args, outputs=(0, ), expect=exp_output) # compare result rtol, atol = get_rtol_atol("scatter_add", dtype_ref) testcase_result = compare_tensor(acu_output, exp_output, rtol=rtol, atol=atol, equal_nan=True) return [ref, indices, updates], acu_output, exp_output, testcase_result
def blas_axby_ad_run(shape, dtype, kernel_name, attrs): alpha = 2.0 beta = 3.0 if 'tuning' in attrs.keys(): t = attrs.get("tuning", False) kernel_name = attrs.get("kernel_name", False) mod = utils.op_build_test(blas_axby_ad.blas_axby_ad, [shape], [dtype], [alpha, beta], kernel_name=kernel_name, attrs=attrs, tuning=t) if t: args, expect_dx, expect_dy, head = gen_data(alpha, beta, dtype, shape) return mod, (expect_dx, expect_dy), {"args": args, 'outputs': (1, 2), 'tuning': False} else: return mod else: mod = utils.op_build_test(blas_axby_ad.blas_axby_ad, [shape], [dtype], [alpha, beta], kernel_name=kernel_name, attrs=attrs) args, expect_dx, expect_dy, head = gen_data(alpha, beta, dtype, shape) output_dx, output_dy = utils.mod_launch(mod, args, outputs=(1, 2), expect=(expect_dx, expect_dy)) rtol, atol = get_rtol_atol("blas_axby_ad", dtype) result = compare_tensor(expect_dx, output_dx, rtol=rtol, atol=atol, equal_nan=True) and \ compare_tensor(expect_dy, output_dy, rtol=rtol, atol=atol, equal_nan=True) return (head), (expect_dx, expect_dy), (output_dx, output_dy), result
def div_execute(shape1, shape2, dtype, attrs=None): if 'tuning' in attrs.keys(): t = attrs.get("tuning", False) kernel_name = attrs.get("kernel_name", False) mod = div_compile(shape1, shape2, dtype, attrs, kernel_name=kernel_name, tuning=t) if t: expect, input1, input2, output = gen_data(dtype, shape1, shape2) return mod, expect, (input1, input2, output) else: return mod else: mod = div_compile(shape1, shape2, dtype, attrs) expect, input1, input2, output = gen_data(dtype, shape1, shape2) output = utils.mod_launch(mod, (input1, input2, output), expect=expect) rtol, atol = get_rtol_atol("div", dtype) return (input1, input2), output, expect, compare_tensor(output, expect, rtol=rtol, atol=atol, equal_nan=True)
def apply_rms_prop_mixed_precision_run(shape, dtype, lr, momentum, rho, epsilon, attrs=None): """run function for dsl function apply_rms_prop_mixed_precision.""" if attrs is None: attrs = {} dtype = dtype.lower() shapes = [shape, shape, shape, shape, (1, ), (1, ), (1, )] types = [dtype, dtype, dtype, dtype, dtype, dtype, dtype] op_attrs = [epsilon] mod = utils.op_build_test(apply_rms_prop.apply_rms_prop_mixed_precision, shapes, types, op_attrs=op_attrs, kernel_name="apply_rms_prop_mixed_precision", attrs=attrs) inputs, expects, args = gen_data(shape, dtype, lr, momentum, rho, epsilon) outputs = utils.mod_launch(mod, args, outputs=(0, -1, 1, 2), expect=expects) # output type: fp32, fp16, fp32, fp32 precision = [get_rtol_atol("apply_rms_prop", e.dtype) for e in expects] results = list( map(lambda x, y, p: compare_tensor(x, y, rtol=p[0], atol=p[1]), outputs, expects, precision)) return inputs, outputs, expects, all(results)
def gelu_grad_execute(shape, dtype, attrs): np.random.seed(0) if 'tuning' in attrs.keys(): t = attrs.get("tuning", False) kernel_name = attrs.get("kernel_name", False) mod = gelu_grad_compile(shape, dtype, attrs, kernel_name=kernel_name, tuning=t) if t: x, dy, bench_mark, output = gelu_grad_data(shape, dtype) return mod, bench_mark, (x, dy, output) else: return mod else: mod = gelu_grad_compile(shape, dtype, attrs) x, dy, bench_mark, output = gelu_grad_data(shape, dtype) output = utils.mod_launch(mod, (x, dy, output), expect=bench_mark) rtol, atol = get_rtol_atol("gelu_grad", dtype) compare_res = compare_tensor(output, bench_mark, rtol=rtol, atol=atol, equal_nan=False) return (x, dy), output, bench_mark, compare_res
def get_result(desc, poly, attrs=None): if poly: reduce_lib_key = "enable_akg_reduce_lib" if reduce_lib_key not in attrs.keys(): attrs[reduce_lib_key] = poly if attrs == {}: mod = composite.build(desc, {'dim':"0 0 9728 9728"}, poly=poly) else: mod = composite.build(desc, attrs, poly=poly) input_for_mod, expect, output_indexes = gen_json_data(desc) output = utils.mod_launch(mod, input_for_mod, output_indexes) rtol, atol = get_rtol_atol("FUSED", "float32") flag = True if len(output_indexes) > 1: if not all(map(lambda x, y: compare_tensor(x, y, rtol=rtol, atol=atol), output, expect)): logging.info(mod.imported_modules[0].get_source()) flag = False else: if not compare_tensor(output, expect, rtol=rtol, atol=atol): logging.info(mod.imported_modules[0].get_source()) flag = False desc_d = json.loads(desc) if desc_d["process"] == "cuda": inputs = to_tvm_nd_array(input_for_mod) expect = to_tvm_nd_array(expect) gpu_profiling(mod, *inputs, *expect, repeat_time=400) return flag
def two2fractal_execute(dim_size, format, dtype, attrs): # Generate data shape = dim_size support_formats = ['zN', 'zZ', 'nZ'] assert format in support_formats assert len(shape) >= 2 and len(shape) <= 4 # mod launch op_attrs = [format] if 'tuning' in attrs.keys(): t = attrs.get("tuning", False) kernel_name = attrs.get("kernel_name", False) mod = two2fractal_compile(shape, dtype, op_attrs, attrs, t) if t: bench_mark, input, output = gen_data(dtype, format, shape) return mod, bench_mark, (input, output) else: return mod else: mod = two2fractal_compile(shape, dtype, op_attrs, attrs) source_code = mod.imported_modules[0].get_source() bench_mark, input, output = gen_data(dtype, format, shape) output = utils.mod_launch(mod, (input, output), expect=bench_mark) # compare result rtol, atol = get_rtol_atol("tile", dtype) compare_result = compare_tensor(output, bench_mark, rtol=rtol, atol=atol, equal_nan=True) return input, output, bench_mark, compare_result
def truncatemod_run(shape1, shape2, dtype, attrs): if 'tuning' in attrs.keys(): t = attrs.get("tuning", False) kernel_name = attrs.get("kernel_name", False) mod = utils.op_build_test(truncatemod.truncatemod, [shape1, shape2], [dtype, dtype], kernel_name=kernel_name, attrs=attrs, dump_code=True, tuning=t) if t: expect, input1, input2, output = gen_data(dtype, shape1, shape2) return mod, expect, (input1, input2, output) else: return mod else: expect, input1, input2, output = gen_data(dtype, shape1, shape2) mod = utils.op_build_test(truncatemod.truncatemod, [shape1, shape2], [dtype, dtype], kernel_name="truncatemod", attrs=attrs, dump_code=True) output = utils.mod_launch(mod, (input1, input2, output), expect=expect) rtol, atol = get_rtol_atol("truncatemod", dtype) res = compare_tensor(output, expect, rtol=rtol, atol=atol, equal_nan=True) return (input1, input2), output, expect, res
def addn_execute(shape, dtype, n, attrs={}): # for i in range(len(shapes)): if 'tuning' in attrs.keys(): t = attrs.get("tuning", False) kernel_name = attrs.get("kernel_name", False) mod, shapes = addn_compile(shape, dtype, n, attrs, kernel_name=kernel_name, tuning=t) if t: expect, inputs, args = gen_data(dtype, n, shape, shapes) return mod, expect, args else: return mod else: # Result_addn mod, shapes = addn_compile(shape, dtype, n, attrs) exp_output, inputs, args = gen_data(dtype, n, shape, shapes) acu_output = utils.mod_launch(mod, args, expect=exp_output) # compare result rtol, atol = get_rtol_atol("addn", dtype) TestCase_Result = compare_tensor(acu_output, exp_output, rtol=rtol, atol=atol, equal_nan=True) return inputs, acu_output, exp_output, TestCase_Result