def gen_data(dtype, shape, with_l2_shrinkage=False):
"""Generate data for testing the op"""
# tensors
var = random_gaussian(shape).astype(dtype)
accum = np.abs(random_gaussian(shape).astype(dtype))
linear = random_gaussian(shape).astype(dtype)
grad = random_gaussian(shape).astype(dtype)
tensors = [var, accum, linear, grad]
# scalars
scalar_shape = (1, )
lr = np.random.random_sample(scalar_shape).astype(dtype)
l1 = np.random.random_sample(scalar_shape).astype(dtype)
l2 = np.random.random_sample(scalar_shape).astype(dtype)
lr_power = np.array([0.5], dtype)
if with_l2_shrinkage:
l2_shrinkage = np.random.random_sample(scalar_shape).astype(dtype)
scalars = [lr, l1, l2, l2_shrinkage, lr_power]
else:
scalars = [lr, l1, l2, lr_power]
# expects
expects = apply_ftrl_impl(tensors, scalars, with_l2_shrinkage)
return expects, tensors, scalars
def add_ad_run(ashape, bshape, dtype, kernel_name="add", scale=1.0, attrs_op={}, polyhedral=True, attrs={}):
if type(scale) is not float or not int:
if type(attrs_op) is not bool:
scale, attrs_op = 1.0, scale
else:
scale, attrs_op, polyhedral = 1.0, scale, attrs_op
attrs.update(attrs_op)
if 'tuning' in attrs.keys():
t = attrs.get("tuning", False)
kernel_name = attrs.get("kernel_name", False)
a = random_gaussian(ashape, miu=1, sigma=0.1).astype(dtype)
b = random_gaussian(bshape, miu=1, sigma=0.1).astype(dtype)
out = np.add(a, b * scale)
mod = utils.op_build_test(add_ad, [out.shape, ashape, bshape], [dtype, dtype, dtype], kernel_name=kernel_name,
op_attrs=[scale], attrs=attrs, polyhedral=polyhedral, tuning=t)
if t:
expect, head_np, output = gen_data(dtype, out)
return mod, expect, (head_np, a, b, output)
else:
return mod
else:
a = random_gaussian(ashape, miu=1, sigma=0.1).astype(dtype)
b = random_gaussian(bshape, miu=1, sigma=0.1).astype(dtype)
out = np.add(a, b * scale)
mod = utils.op_build_test(add_ad, [out.shape, ashape, bshape], [dtype, dtype, dtype], kernel_name='add_ad',
op_attrs=[scale], attrs=attrs, polyhedral=polyhedral)
expect, head_np, output = gen_data(dtype, out)
output = utils.mod_launch(mod, (head_np, a, b, output), expect=expect)
return (head_np, a, b), output, expect, compare_tensor(output, expect, atol=0.1)
def gen_data(shape1, dtype1, shape2, dtype2):
"""generate valid data for arctangent"""
head = random_gaussian(shape1, miu=0, sigma=0.5).astype(dtype1)
input_x = random_gaussian(shape2, miu=0, sigma=0.5).astype(dtype2)
expect = np.divide(1, np.add(1, np.square(input_x))) * head
out_buf = np.full(shape1, np.nan, dtype1)
return expect, (head, input_x), out_buf
def avgpool_ad_run(shape, kernel, stride, pad, dtype, polyhedral=False, attrs=None):
support_list = {"float16": np.float16, "float32": np.float32}
if attrs is None:
attrs = {'loop_partition_unroll': True}
else:
attrs['loop_partition_unroll'] = True
kernel_name = 'avgpool_ad'
if polyhedral:
avgpool = avgpool_ad
else:
kernel_name = kernel_name + "_manual_schedule"
avgpool = avgpool_ad_no_custom_diff_manual_schedule
if 'tuning' in attrs.keys():
t = attrs.get("tuning", False)
kernel_name = attrs.get("kernel_name", False)
input = random_gaussian(shape, miu=1, sigma=0.1).astype(support_list[dtype])
y = avgpool_run.benchmark(input, kernel, stride, pad)
mod = utils.op_build_test(avgpool, [y.shape, shape], [dtype, dtype], op_attrs=[kernel, stride, pad],
kernel_name=kernel_name, attrs=attrs, log_code=True, dump_code=True, tuning=t)
if t:
expect, head, output = gen_data(dtype, input, kernel, pad, stride, support_list, y)
return mod, expect, (head, input, output)
else:
return mod
else:
input = random_gaussian(shape, miu=1, sigma=0.1).astype(support_list[dtype])
y = avgpool_run.benchmark(input, kernel, stride, pad)
mod = utils.op_build_test(avgpool, [y.shape, shape], [dtype, dtype], op_attrs=[kernel, stride, pad],
kernel_name=kernel_name, attrs=attrs, log_code=True, dump_code=True)
expect, head, output = gen_data(dtype, input, kernel, pad, stride, support_list, y)
output = utils.mod_launch(mod, [head, input, output], expect=expect)
return [head, input], output, expect, compare_tensor(output, expect, rtol=5e-03, atol=5e-03, equal_nan=True)
def gen_data(shape_ref, shape_indices, dtype_ref, dtype_indices):
ref = random_gaussian(shape_ref, miu=10, sigma=0.3).astype(dtype_ref)
new_ref = ref.copy()
# generate valid index
indices = np.random.randint(low=0,
high=shape_ref[0],
size=shape_indices,
dtype=dtype_indices)
# reshape to a 1D tensor to index
all_shape = np.prod(shape_indices).astype(dtype_indices)
new_indices = np.reshape(indices, (all_shape, ))
# according to indices shape and ref shape to make updates shape
updates_shape = shape_indices + shape_ref[1:]
updates = random_gaussian(updates_shape, miu=3,
sigma=0.3).astype(dtype_ref)
# according to new_indieces shape and ref shape to make new_update_shape, make sure to update base on new_indices
new_updates_shape = new_indices.shape + shape_ref[1:]
new_updates = np.reshape(updates, new_updates_shape)
# get results by new_updates
for i in range(new_indices.shape[0]):
new_ref[new_indices[i], ] += new_updates[i, ]
output = np.full(shape_ref, np.nan, dtype_ref)
args = [ref, indices, updates, output]
return args, new_ref, ref, indices, updates,
def gen_data(shape, dtype):
var = random_gaussian(shape, miu=1, sigma=0.1).astype(dtype)
m = random_gaussian(shape, miu=1, sigma=0.1).astype(dtype)
grad = random_gaussian(shape, miu=1, sigma=0.1).astype(dtype)
lr = np.random.rand(1).astype(dtype)
logbase = np.random.rand(1).astype(dtype)
sign_decay = np.random.rand(1).astype(dtype)
beta = np.random.rand(1).astype(dtype)
inputs = [var, m, grad, lr, logbase, sign_decay, beta]
if dtype == "float16":
var, m, grad, lr, logbase, sign_decay, beta = [i.astype("float32") for i in inputs]
one = np.array([1]).astype(var.dtype)
m_out = m * beta + grad * (one - beta)
var_out = var - lr * np.exp(logbase * sign_decay * np.sign(grad) * np.sign(m_out)) * grad
if dtype == "float16":
exp_output = (var_out.astype(dtype), m_out.astype(dtype))
else:
exp_output = (var_out, m_out)
args = inputs
return exp_output, inputs, args
def gen_data(fm_shape, w_shape, pad, stride, dilation, bias, expect_file):
conv_param = {'stride': stride, 'pad': pad, 'dilation': dilation}
stride, pad, dilation = conv_param_prepare(conv_param)
fm_shape, w_shape, out_shape = conv_shape_4d(fm_shape, w_shape, pad,
stride, dilation)
IN, IC, IH, IW = fm_shape
WN, WC, WH, WW = w_shape
x = random_gaussian((IN, IC, IH, IW), miu=1, sigma=0.1).astype(np.float16)
w = random_gaussian((WN, WC, WH, WW), miu=0.5,
sigma=0.01).astype(np.float16)
if bias:
b = random_gaussian((WN, ), miu=1, sigma=0.1).astype(np.float16)
else:
b = (np.array(np.zeros(WN))).astype(np.float16, copy=False)
flag_w = os.environ.get("WRITE_TO_DISK", "No")
if (flag_w == "No") and (os.path.exists(expect_file) == True):
#read expect from file
out = np.fromfile(expect_file, np.float16).reshape(out_shape)
else:
#compute expect data:
out = conv_forward_naive(x.astype(np.float32), w.astype(np.float32),
b.astype(np.float32), conv_param)
out = out.astype(np.float16)
if flag_w == "Yes":
# write expect to file
with open(expect_file, "w+") as file:
out.tofile(file)
file.close()
return conv_tensor_4d_to_5d(x, w, b, out)
def gen_data(shape, dtype, lr, momentum, rho, epsilon):
"""Generates input, output and expect data."""
var = random_gaussian(shape, miu=10, sigma=1.0).astype(dtype)
ms = np.abs(random_gaussian(shape, miu=4, sigma=0.1).astype(dtype))
mom = random_gaussian(shape, miu=3, sigma=0.3).astype(dtype)
grad = random_gaussian(shape, miu=3, sigma=0.3).astype(dtype)
lr = np.array([lr]).astype(dtype)
momentum = np.array([momentum]).astype(dtype)
rho = np.array([rho]).astype(dtype)
inputs = [var, ms, mom, grad, lr, momentum, rho]
# ms = rho * ms + (1-rho) * grad * grad
# mom = momentum * mom + lr * grad / sqrt(ms + epsilon)
# var = var - mom
one = np.array([1.0]).astype(dtype)
ms_1 = rho * ms
ms_2 = (one - rho) * grad * grad
ms_update = ms_1 + ms_2
mom_1 = momentum * mom
mom_2_1 = lr * grad
mom_2_2 = one / np.sqrt(ms_update + epsilon)
mom_3 = mom_2_1 * mom_2_2
mom_update = mom_1 + mom_3
var_update = var - mom_update
expects = (var_update, var_update.astype("float16"), ms_update, mom_update)
outputs = np.full(var_update.shape, np.nan, "float16")
args = [*inputs, outputs]
return inputs, expects, args
def gen_data(shape1, shape2, shape3, shape4, data_type, indices_type, axis,
keepdims, num):
input1 = random_gaussian(shape1, miu=1, sigma=0.1).astype(data_type)
out_dim1 = 1
for i in range(len(shape2) - 1):
out_dim1 = out_dim1 * shape2[i]
input2 = np.zeros([shape2[-1], out_dim1]).astype(indices_type)
for i in range(shape2[-1]):
input2[i] = np.random.randint(low=0, high=shape1[i], size=out_dim1)
input3 = random_gaussian(shape3, miu=1, sigma=0.1).astype(data_type)
prod = np.sum(input1[tuple(input2.tolist())], axis=axis,
keepdims=keepdims) * input3
input4 = np.random.randint(low=0, high=10,
size=shape4).astype(indices_type)
input5 = np.random.randint(low=0, high=10,
size=shape4).astype(indices_type)
expect1 = np.zeros((num, ) + shape3[len(shape4):]).astype(data_type)
expect2 = np.zeros((num, ) + shape3[len(shape4):]).astype(data_type)
np.add.at(expect1, input4, prod)
np.add.at(expect2, input5, prod)
input2 = input2.transpose()
input2 = input2.reshape(shape2)
return input1, input2, input3, input4, input5, expect1, expect2
def get_input_data(dtype, kernel, pad, shape, stride, support_list):
# Generate data for testing the op
x = random_gaussian(shape, miu=1, sigma=0.1).astype(support_list[dtype])
y = avgpool_run.benchmark(x, kernel, stride, pad)
dy = random_gaussian(y.shape, miu=1, sigma=0.1).astype(support_list[dtype])
dy = np.abs(dy)
return dy, x, y
def gen_data(shape1, dtype1, shape2, dtype2):
"""generate valid data for arctangent2"""
input1 = random_gaussian(shape1, miu=0, sigma=0.5).astype(dtype1)
input2 = random_gaussian(shape2, miu=0, sigma=0.5).astype(dtype2)
expect = np.arctan2(input1, input2)
out_buf = np.full(shape1, np.nan, dtype1)
return expect, (input1, input2), out_buf
def gen_data(dtype, shape):
"""Generate data for testing the op"""
y = random_gaussian(size=shape).astype(dtype)
dy = random_gaussian(size=shape).astype(dtype)
expect = _asinh_grad_compute(y, dy)
output = np.full(expect.shape, np.nan, dtype)
return expect, [y, dy], output
def gen_data(dtype, shape, use_nesterov=False):
"""Generate data for testing the op"""
# tensors
var = random_gaussian(shape).astype(dtype)
m = random_gaussian(shape).astype(dtype)
v = np.abs(random_gaussian(shape).astype(dtype))
grad = random_gaussian(shape).astype(dtype)
tensors = [var, m, v, grad]
# scalars
lr = np.array([0.001], dtype)
beta1 = np.array([0.9], dtype)
beta2 = np.array([0.999], dtype)
epsilon = np.array([1e-7], dtype)
t = np.random.randint(1, 100, size=(1, ))
beta1_power = np.array([beta1**t], dtype)
beta2_power = np.array([beta2**t], dtype)
sclars = [beta1_power, beta2_power, lr, beta1, beta2, epsilon]
# expects
lr_coffient = np.sqrt(1.0 - beta2_power) / (1.0 - beta1_power)
lr_t = lr * lr_coffient
m_t = m + (1.0 - beta1) * (grad - m)
v_t = v + (1.0 - beta2) * (grad * grad - v)
v_t_sqrt = np.sqrt(v_t)
if use_nesterov:
var_t = var - (lr_t * (m_t * beta1 +
(1.0 - beta1) * grad)) / (epsilon + v_t_sqrt)
else:
var_t = var - (lr_t * m_t) / (epsilon + v_t_sqrt)
expects = [var_t, m_t, v_t]
return expects, tensors, sclars
def mul_ad_run(ashape, bshape, dtype, kernel_name, attrs):
if 'tuning' in attrs.keys():
t = attrs.get("tuning", False)
kernel_name = attrs.get("kernel_name", False)
a = random_gaussian(ashape, miu=1, sigma=0.1).astype(dtype)
b = random_gaussian(bshape, miu=1, sigma=0.1).astype(dtype)
out = np.multiply(a, b)
mod = utils.op_build_test(mul_ad, [out.shape, ashape, bshape],
[dtype, dtype, dtype],
kernel_name=kernel_name,
attrs=attrs,
tuning=t)
if t:
expect, head_np, output = gen_data(b, dtype, out)
return mod, expect, (head_np, a, b, output)
else:
return mod
else:
a = random_gaussian(ashape, miu=1, sigma=0.1).astype(dtype)
b = random_gaussian(bshape, miu=1, sigma=0.1).astype(dtype)
out = np.multiply(a, b)
expect, head_np, output = gen_data(b, dtype, out)
mod = utils.op_build_test(mul_ad, [out.shape, ashape, bshape],
[dtype, dtype, dtype],
kernel_name=kernel_name,
attrs=attrs)
output = utils.mod_launch(mod, (head_np, a, b, output), expect=expect)
return (head_np, a, b), output, expect, compare_tensor(output,
expect,
atol=0.1)
def gen_data(shape1, shape2, shape3, shape4, dtype1, dtype2, axis):
# gather
input1 = random_gaussian(shape1).astype(dtype1)
input2 = np.random.randint(low=0, high=shape1[axis],
size=shape2).astype(dtype2)
gather_out = np.take(input1, input2, axis=axis)
# mul
input3 = random_gaussian(shape3).astype(dtype1)
mul_out = np.multiply(gather_out, input3)
# scatter_add
params = np.zeros(shape1, dtype1)
#params = random_gaussian(shape1).astype(dtype1)
indices = np.zeros(shape4, dtype2)
original_shape = indices.shape
indices = indices.reshape(-1, indices.shape[-1])
for i in range(indices.shape[0]):
for j in range(indices.shape[1]):
indices[i][j] = np.random.randint(shape1[j], size=())
indices = indices.reshape(original_shape)
expect = deepcopy(params)
np.add.at(expect, tuple(indices.T.tolist()), mul_out)
indices = indices.reshape(shape4)
return input1, input2, input3, indices, expect
def gen_data(shape, dtype, shape_origin, format, out_dtype):
if format == 'zN':
input = random_gaussian(shape, miu=1, sigma=0.3).astype(dtype)
n1, m1, m0, n0 = shape[-4:]
new_shape = shape[:-4] + [m1 * m0, n1 * n0]
tranpose_axis = [1, 2, 0, 3]
elif format == 'zZ':
input = random_gaussian(shape, miu=1, sigma=0.3).astype(dtype)
m1, n1, m0, n0 = shape[-4:]
new_shape = shape[:-4] + [m1 * m0, n1 * n0]
tranpose_axis = [0, 2, 1, 3]
tranpose_axis = [x + len(shape) - 4 for x in tranpose_axis]
tranpose_axis = [i for i in range(len(shape) - 4)] + tranpose_axis
bench_mark = input.transpose(tranpose_axis).reshape(new_shape)
if new_shape != shape_origin:
if len(shape_origin) == 2:
bench_mark = bench_mark[:shape_origin[0], :shape_origin[1]].astype(
out_dtype)
elif len(shape_origin) == 3:
bench_mark = bench_mark[:,
shape_origin[0], :shape_origin[1]].astype(
out_dtype)
elif len(shape_origin) == 4:
bench_mark = bench_mark[:, :,
shape_origin[0], :shape_origin[1]].astype(
out_dtype)
new_shape = shape_origin
output = np.full(new_shape, np.nan, out_dtype)
return output, input, bench_mark
def gen_data(shape_matrix, shape_diagonal, dtype):
"""generate valid data to test"""
input_matrix = random_gaussian(shape_matrix, miu=10,
sigma=0.3).astype(dtype)
input_diagonal = random_gaussian(shape_diagonal, miu=5,
sigma=0.3).astype(dtype)
# make shape_diagonal can support broadcast
if shape_matrix[-2] <= shape_matrix[-1]:
shape_b_newshape = list(shape_diagonal) + [1]
# The penultimate dimension of the shape_diag is extended for broadcast.
else:
shape_b_newshape = list(shape_diagonal)
shape_b_newshape.insert(-1, 1)
new_input_diagonal = np.reshape(input_diagonal, shape_b_newshape)
# need to generate a multi dimensional 01 diagonal matrix by broadcasting a 2D 01 diagonal matrix
input_help = np.zeros((shape_matrix[-2], shape_matrix[-1]))
for i in range(min(shape_matrix[-2], shape_matrix[-1])):
input_help[i, i] = 1.0
input_help = np.broadcast_to(input_help, shape_matrix)
input_help = input_help.astype(dtype)
if dtype == 'uint8':
new_help = np.abs(input_help.astype('float16') - 1).astype(dtype)
else:
new_help = np.abs(input_help - 1)
exp_output = input_matrix * new_help + input_help * new_input_diagonal
# inputs and output to hold the data
output = np.full(shape_matrix, np.nan, dtype)
args = [input_matrix, input_diagonal, input_help, output]
return args, exp_output, input_matrix, input_diagonal, input_help
def gen_data(bs, m, n, k, shape_bias, trans_a, trans_b, dtype):
shape_a, shape_b, shape_out = get_shape(bs, m, n, k, trans_a, trans_b)
matrix_a = random_gaussian(shape_a, miu=0.5, sigma=0.01).astype(dtype)
matrix_b = random_gaussian(shape_b, miu=0.5, sigma=0.01).astype(dtype)
if len(shape_bias) > 0:
matrix_bias = random_gaussian(shape_bias, miu=0.5,
sigma=0.01).astype(dtype)
else:
matrix_bias = np.zeros(shape_bias, dtype=dtype)
# cast to float32 for fast compute in numpy
if dtype == "float16":
matrix_a_for_np = matrix_a.astype(np.float32)
matrix_b_for_np = matrix_b.astype(np.float32)
matrix_bias_for_np = matrix_bias.astype(np.float32)
else:
matrix_a_for_np = matrix_a
matrix_b_for_np = matrix_b
matrix_bias_for_np = matrix_bias
if trans_a and trans_b:
res = np.matmul(np.swapaxes(matrix_a_for_np, -1, -2),
np.swapaxes(matrix_b_for_np, -1, -2))
elif trans_a:
res = np.matmul(np.swapaxes(matrix_a_for_np, -1, -2), matrix_b_for_np)
elif trans_b:
res = np.matmul(matrix_a_for_np, np.swapaxes(matrix_b_for_np, -1, -2))
else:
res = np.matmul(matrix_a_for_np, matrix_b_for_np)
res = np.add(res, matrix_bias_for_np)
if dtype == "float16":
res = res.astype(dtype)
return matrix_a, matrix_b, matrix_bias, res
def gen_data(in_shape, in_dtype, inter_dtype, layout, out_dtype):
if layout == "NHWC":
num_channel = in_shape[3]
else:
num_channel = in_shape[1]
data = [np.nan] * 10
data[0] = random_gaussian([num_channel], miu=1,
sigma=0.1).astype(inter_dtype)
data[1] = random_gaussian([num_channel], miu=1,
sigma=0.1).astype(inter_dtype)
data[2] = random_gaussian([num_channel], miu=1,
sigma=0.1).astype(inter_dtype)
data[3] = random_gaussian([num_channel], miu=1,
sigma=0.1).astype(inter_dtype)
data[4] = random_gaussian(in_shape, miu=1, sigma=0.1).astype(in_dtype)
data[5] = random_gaussian([num_channel], miu=1,
sigma=0.1).astype(inter_dtype)
data[6] = random_gaussian([num_channel], miu=1,
sigma=0.1).astype(inter_dtype)
data[7] = random_gaussian([num_channel], miu=1,
sigma=0.1).astype(inter_dtype)
data[8] = random_gaussian([num_channel], miu=1,
sigma=0.1).astype(inter_dtype)
data[9] = random_gaussian(in_shape, miu=1, sigma=0.1).astype(in_dtype)
expect = compute_expect(data, inter_dtype, layout, out_dtype)
output = np.full(expect.shape, np.nan, out_dtype)
return data, output, expect
def gen_data(begin_norm_axis, begin_params_axis, dtype, shape_x):
input = random_gaussian(shape_x, miu=1, sigma=0.1).astype(dtype)
gamma = random_gaussian(shape_x[begin_params_axis:], miu=1, sigma=0.1).astype(dtype)
beta = random_gaussian(shape_x[begin_params_axis:], miu=1, sigma=0.1).astype(dtype)
in_rank = len(shape_x)
if begin_norm_axis < 0:
norm_axis = begin_norm_axis + in_rank
else:
norm_axis = begin_norm_axis
norm_axes = tuple(range(norm_axis, in_rank))
mean = np.broadcast_to(np.mean(input, axis=norm_axes, keepdims=True), shape_x)
diff = input - mean
square = np.square(diff)
smean = np.broadcast_to(np.mean(square, axis=norm_axes, keepdims=True), shape_x)
meps = smean + 1e-5
# sqrt = np.sqrt(meps)
# rsqrt = 1.0 / sqrt
logs = np.log(meps)
mul = logs * (-0.5)
rsqrt = np.exp(mul)
out = diff * rsqrt
bn = out * gamma + beta
output = np.full(shape_x, np.nan, dtype)
out_mean = np.full(shape_x, np.nan, dtype)
out_variance = np.full(shape_x, np.nan, dtype)
expect = (bn, mean, smean)
return beta, expect, gamma, input, out_mean, out_variance, output
def gen_data(dtype, shape):
input1 = random_gaussian(shape, miu=1, sigma=0.1).astype(dtype)
input2 = random_gaussian(shape, miu=1, sigma=0.1).astype(dtype)
head_np = random_gaussian(shape, miu=1, sigma=0.1).astype(dtype)
expect = head_np * input2
output = np.full(shape, np.nan, dtype)
return expect, head_np, input1, input2, output
def gen_data(data_shape, dtype, num_rois, pooled_size, rois_shape):
inputs = random_gaussian(data_shape, miu=1, sigma=0.1).astype(dtype)
# rois = np.array([[0.0,2.0,2.0,8.0,8.0],[0.0,4.0,4.0,12.0,12.0]]).astype(dtype)
rois = np.random.uniform(0.0, 0.1, size=rois_shape)
for x in range(num_rois):
rois[x][0] = np.random.randint(data_shape[0], size=1)
rois[x][1] = np.random.uniform(low=0.0, high=data_shape[3], size=1)
rois[x][2] = np.random.uniform(low=0.0, high=data_shape[2], size=1)
rois[x][3] = np.random.uniform(low=rois[x][1],
high=data_shape[3],
size=1)
rois[x][4] = np.random.uniform(low=rois[x][2],
high=data_shape[2],
size=1)
rois = rois.astype(dtype)
pooled_size_h = 0.0
pooled_size_w = 0.0
if isinstance(pooled_size, int):
pooled_size_h = pooled_size
pooled_size_w = pooled_size
e_shape = (num_rois, data_shape[1], pooled_size_h, pooled_size_w)
else:
pooled_size_h, pooled_size_w = pooled_size
e_shape = (num_rois, data_shape[1], pooled_size_h, pooled_size_w)
output = np.full(e_shape, 1.0, dtype)
expect = random_gaussian(e_shape, miu=1, sigma=0.1)
return e_shape, expect, inputs, output, pooled_size_h, pooled_size_w, rois
def matmul_ad_run(data_shape,
weight_shape,
dtype,
attrs_op={},
cce_path="./",
attrs={}):
attrs.update(attrs_op)
check_list = ["float16"]
if not (dtype.lower() in check_list):
raise RuntimeError("matmul test only support %s while dtype is %s" %
(",".join(check_list), dtype))
mod = matmul_ad.matmul_ad(data_shape, weight_shape, dtype, attrs=attrs)
input_data = random_gaussian(data_shape, miu=0.1, sigma=0.1)
input_data = input_data.astype(np.float16)
input_weight = random_gaussian(weight_shape, miu=0.1, sigma=0.1)
input_weight = input_weight.astype(np.float16)
expect = np.matmul(np.matmul(input_data, input_weight),
np.transpose(input_weight))
output = np.full(data_shape, 1.0, dtype)
output = utils.mod_launch(
mod, (np.matmul(input_data, input_weight), input_weight, output),
expect=expect)
return (np.matmul(input_data, input_weight),
input_weight), output, expect, compare_tensor(output,
expect,
atol=5e-01,
rtol=5e-03,
equal_nan=True)
def gen_data(dtype, shape1, shape2):
def pow_data_process(x, y):
# For pow, if value of x is a negative number, the corresponding value of y must be an integer,
# for example, the corresponding value of y is 1.0, -2.0, 3.0.
x_b = np.broadcast_to(x, np.broadcast(x, y).shape)
x_b_neg_index = np.where(x_b < 0)
if len(x_b_neg_index) > 0 and len(x_b_neg_index[0]) > 0:
shape_len_diff = len(x_b.shape) - len(y.shape)
y_int_index = list(x_b_neg_index[shape_len_diff:])
for dim in range(len(y.shape)):
if y.shape[dim] != x_b.shape[dim + shape_len_diff]:
if y.shape[dim] != 1:
raise ValueError("broadcast dismatch %s vs %s" %
(y.shape[dim], x_b.shape[dim]))
y_int_index[dim] = np.array([0] * len(y_int_index[dim]))
y_int_index = tuple(y_int_index)
y_int = y.astype(np.int32).astype(y.dtype)
y[y_int_index] = y_int[y_int_index]
input1 = random_gaussian(shape1, miu=1, sigma=0.1).astype(dtype)
input2 = random_gaussian(shape2, miu=1, sigma=0.1).astype(dtype)
pow_data_process(input1, input2)
expect = np.power(input1, input2)
output = np.full(expect.shape, np.nan, dtype)
return expect, input1, input2, output
def gen_data(shape, dtype, lr, momentum, rho, epsilon):
var = random_gaussian(shape, miu=1, sigma=0.1).astype(dtype)
grad = random_gaussian(shape, miu=1, sigma=0.1).astype(dtype)
rho = np.array([rho]).astype(dtype)
mg = grad * rho
ms = grad * grad
mom = random_gaussian(shape, miu=1, sigma=0.1).astype(dtype)
lr = np.array([lr]).astype(dtype)
momentum = np.array([momentum]).astype(dtype)
inputs = [var, mg, ms, mom, grad, lr, momentum, rho]
if dtype == "float16":
var, mg, ms, mom, grad, lr, momentum, rho = [
x.astype("float32") for x in inputs
]
one = np.array([1.0], dtype=rho.dtype)
out_mg = rho * mg + (one - rho) * grad
out_ms = rho * ms + (one - rho) * grad * grad
out_mom = momentum * mom + lr * grad / np.sqrt(out_ms - out_mg * out_mg +
epsilon)
out_var = var - out_mom
exp_output = (out_var, out_mg, out_ms, out_mom)
if dtype != out_var.dtype:
exp_output = tuple([x.astype(dtype) for x in exp_output])
args = inputs
return exp_output, inputs, args
def gen_data(dtype, shape):
input_np = random_gaussian(shape, miu=1, sigma=0.5).astype(dtype)
head_np = random_gaussian(shape, miu=1, sigma=0.5).astype(dtype)
softplus_grad = softplus_ad_benchmark(input_np)
expect = softplus_grad * head_np
output = np.full(expect.shape, np.nan, dtype)
return expect, head_np, input_np, output
def gen_data(bias_shape, dtype, input_shape, scale_shape):
bias_data = None
if dtype.lower() in ["float16", "float32", "int32"]:
input_data = random_gaussian(input_shape, miu=1,
sigma=50.0).astype(dtype.lower())
scale_data = random_gaussian(scale_shape, miu=1,
sigma=2.0).astype(dtype.lower())
if len(bias_shape) > 0:
bias_data = random_gaussian(bias_shape, miu=1,
sigma=0.5).astype(dtype.lower())
elif dtype.lower() == "int8":
input_data = np.random.randint(-40, 40, size=input_shape, dtype="int8")
scale_data = np.random.randint(-3, 3, size=scale_shape, dtype="int8")
if len(bias_shape) > 0:
bias_data = np.random.randint(-3, 3, size=bias_shape, dtype="int8")
elif dtype.lower() == "uint8":
input_data = np.random.randint(0, 40, size=input_shape, dtype="uint8")
scale_data = np.random.randint(0, 5, size=scale_shape, dtype="uint8")
if len(bias_shape) > 0:
bias_data = np.random.randint(0,
10,
size=bias_shape,
dtype="uint8")
else:
raise RuntimeError("not supported data type %s" % dtype)
expect = input_data * scale_data
if len(bias_shape) > 0:
expect = expect + bias_data
output = np.full(expect.shape, np.nan, dtype)
return bias_data, expect, input_data, output, scale_data
def gen_data(dtype, reduction, shape):
# support_list = {"float16": np.float16, "float32": np.float32}
target = random_gaussian(shape, miu=0, sigma=1).astype(dtype)
target = np.abs(target)
prediction = random_gaussian(shape, miu=0, sigma=1).astype(dtype)
prediction = np.abs(prediction)
# off_set = np.full(prediction.shape, 0.05, dtype)
off_set = np.full(prediction.shape, 2, dtype)
prediction = np.add(prediction, off_set)
target = np.add(target, off_set)
pre_log = np.log(prediction).astype(dtype)
tar_log = np.log(target).astype(dtype)
sub_log = np.subtract(tar_log, pre_log)
expect = np.multiply(target, sub_log).astype(dtype)
if reduction == 'sum':
expect = np.sum(expect)
if reduction == 'mean':
expect = np.mean(expect)
if reduction == 'batchmean':
reduce_axis = tuple(np.arange(1, len(shape)))
expect = np.mean(expect, axis=reduce_axis, keepdims=False)
if reduction == 'sum' or reduction == 'mean':
out_shape = []
out_shape.append(1)
output = np.full(out_shape, 0, dtype)
if reduction == 'batchmean':
reduce_axis = tuple(np.arange(1, len(shape)))
out_shape = get_reduce_out_shape(shape,
axis=reduce_axis,
keepdims=False)
output = np.full(expect.shape, np.nan, dtype)
if reduction == 'none':
output = np.full(expect.shape, np.nan, dtype)
return expect, output, prediction, target
def gen_data(shape, dtype):
data1 = random_gaussian(shape, miu=3, sigma=0.1).astype(dtype)
data2 = random_gaussian(shape, miu=3, sigma=0.1).astype(dtype)
data3 = random_gaussian(shape, miu=3, sigma=0.1).astype(dtype)
data4 = random_gaussian(shape, miu=3, sigma=0.1).astype(dtype)
return [data1, data2, data3, data4]
def gen_data(dtype, shape, w_shape):
# input_data = -0.01 * np.ones(shape).astype(dtype)
# dy = -0.01 * np.ones(shape).astype(dtype)
input_data = random_gaussian(shape, miu=0,
sigma=0.001).astype(dtype.lower())
dy = random_gaussian(shape, miu=-0.01, sigma=0.001).astype(dtype.lower())
# w_data = random_gaussian(w_shape, miu=0, sigma=1).astype(dtype.lower())
# input_data = np.random.uniform(low=-1.0, high=1.0, size=shape).astype(dtype)
# dy = np.random.uniform(low=-1.0, high=1.0, size=shape).astype(dtype)
w_data = np.random.uniform(low=0, high=1.0, size=w_shape).astype(dtype)
w_reshape = w_data.reshape(1, w_shape[0], 1, 1)
w_broadcast = np.broadcast_to(w_reshape, shape)
expect_dA = dy * (input_data >= 0) + dy * (input_data < 0) * w_broadcast
# expect_dA = (dy.astype("float32") * (input_data >= 0) + dy.astype("float32") * (input_data < 0) * w_broadcast.astype("float32")).astype(dtype.lower())
dw_intermediate = dy * (input_data < 0) * input_data
if w_shape[0] == 1:
# expect_dw = np.sum(dw_intermediate, keepdims = True, dtype=dtype)
expect_dw = (np.sum(dw_intermediate,
dtype="float32")).astype(dtype.lower())
# expect_dw = np.sum(dw_intermediate, dtype=dtype)
expect_dw = expect_dw.reshape(1)
else:
expect_dw = (np.sum(dw_intermediate, axis=(0, 2, 3),
dtype="float32")).astype(dtype.lower())
# expect_dw = np.sum(dw_intermediate, axis=(0,2,3), dtype=dtype)
# expect_dw = np.sum(dw_intermediate.astype("float32"), axis=(0,2,3))
# expect_dw = expect_dw.astype(dtype)
output_dA = np.full(expect_dA.shape, np.nan, dtype)
output_dw = np.full(expect_dw.shape, np.nan, dtype)
return dy, expect_dA, expect_dw, input_data, output_dA, output_dw, w_data
