def sample_program_configs(self, draw):
def generate_input(*args, **kwargs):
if kwargs["type"] == "int32":
return np.random.randint(kwargs["low"], kwargs["high"],
kwargs["shape"]).astype(np.int32)
elif kwargs["type"] == "int64":
return np.random.randint(kwargs["low"], kwargs["high"],
kwargs["shape"]).astype(np.int64)
elif kwargs["type"] == "float32":
return (kwargs["high"] - kwargs["low"]) * np.random.random(
kwargs["shape"]).astype(np.float32) + kwargs["low"]
input_type = draw(st.sampled_from(["float32"])) # "int32", "int64"
max_dim_size = 4
x1_shape = draw(
st.lists(st.integers(min_value=1, max_value=8),
min_size=4,
max_size=max_dim_size))
x2_shape = draw(
st.lists(st.integers(min_value=1, max_value=8),
min_size=4,
max_size=max_dim_size))
x3_shape = draw(
st.lists(st.integers(min_value=1, max_value=8),
min_size=4,
max_size=max_dim_size))
mask_shape = draw(
st.lists(st.integers(min_value=1, max_value=1),
min_size=1,
max_size=3))
select_input_op = OpConfig(type="select_input",
inputs={
"X": ["x1_data", "x2_data", "x3_data"],
"Mask": ["mask"]
},
outputs={"Out": ["output_data"]},
attrs={})
program_config = ProgramConfig(
ops=[select_input_op],
weights={},
inputs={
"x1_data":
TensorConfig(data_gen=partial(generate_input,
type=input_type,
low=-10,
high=10,
shape=x1_shape)),
"x2_data":
TensorConfig(data_gen=partial(generate_input,
type=input_type,
low=-10,
high=10,
shape=x2_shape)),
"x3_data":
TensorConfig(data_gen=partial(generate_input,
type=input_type,
low=-10,
high=10,
shape=x3_shape)),
"mask":
TensorConfig(data_gen=partial(generate_input,
type="int32",
low=1,
high=2,
shape=mask_shape))
},
outputs=["output_data"])
return program_config
def sample_program_configs(self, draw):
shape0 = draw(st.integers(min_value=1, max_value=3))
shape1 = draw(st.integers(min_value=1, max_value=3))
shape2 = draw(st.integers(min_value=1, max_value=3))
input_lod_ = [[0, shape0, shape0 + shape1,
shape0 + shape1 + shape2]] #must be increasing array
N = len(input_lod_[0]) - 1 #batch
D = draw(st.sampled_from([4, 8, 16])) #hidden_size, output_width
T = input_lod_[0][3] #time_step, output_height
in_shape = draw(st.sampled_from([[T, 4 * D]]))
input_weight_shape = draw(st.sampled_from([[D, D * 4]]))
input_h0_data_shape = draw(st.sampled_from([[N, D]]))
input_c0_data_shape = draw(st.sampled_from([[N, D]]))
use_p_ = draw(st.sampled_from([False, True]))
is_r_ = draw(st.sampled_from([False, True]))
gate_activation_ = draw(st.sampled_from(["sigmoid"]))
cell_activation_ = draw(st.sampled_from(["tanh"]))
candidate_activation_ = draw(st.sampled_from(["tanh"]))
input_bias_shape = draw(st.sampled_from([[1, D * 4]]))
if use_p_ == True:
input_bias_shape = draw(st.sampled_from([[1, D * 7]]))
def generate_input_data_in_shape(*args, **kwargs):
return np.random.random(in_shape).astype(np.float32)
def generate_input_data_input_weight_shape(*args, **kwargs):
return np.random.random(input_weight_shape).astype(np.float32)
def generate_input_data_input_h0_data_shape(*args, **kwargs):
return np.random.random(input_h0_data_shape).astype(np.float32)
def generate_input_data_input_c0_data_shape(*args, **kwargs):
return np.random.random(input_c0_data_shape).astype(np.float32)
def generate_input_data_input_bias_shape(*args, **kwargs):
return np.random.random(input_bias_shape).astype(np.float32)
lstm_op = OpConfig(type="lstm",
inputs={
"Input": ["input_data"],
"H0": ["input_h0_data"],
"C0": ["input_c0_data"],
"Weight": ["input_weight_data"],
"Bias": ["input_bias_data"]
},
outputs={
"Hidden": ["output_data_hidden"],
"Cell": ["output_data_cell"],
"BatchGate": ["BatchGate"],
"BatchCellPreAct": ["BatchCellPreAct"]
},
attrs={
"use_peepholes": use_p_,
"is_reverse": is_r_,
"gate_activation": gate_activation_,
"cell_activation": cell_activation_,
"candidate_activation": candidate_activation_,
"is_test": 1
})
program_config = ProgramConfig(
ops=[lstm_op],
weights={},
inputs={
"input_data":
TensorConfig(data_gen=partial(generate_input_data_in_shape),
lod=input_lod_),
"input_weight_data":
TensorConfig(
data_gen=partial(generate_input_data_input_weight_shape)),
"input_h0_data":
TensorConfig(
data_gen=partial(generate_input_data_input_h0_data_shape)),
"input_c0_data":
TensorConfig(
data_gen=partial(generate_input_data_input_c0_data_shape)),
"input_bias_data":
TensorConfig(
data_gen=partial(generate_input_data_input_bias_shape))
},
outputs={"output_data_hidden"})
return program_config
def sample_program_configs(draw):
in_shape = draw(
st.sampled_from([[3, 3, 24], [3, 24, 24], [3, 24], [24, 24], [24]]))
batch = draw(st.integers(min_value=1, max_value=10))
in_shape.insert(0, batch)
sections = draw(
st.sampled_from([[], [1, 2], [2, 1], [10, 14], [1, 1, 1], [2, 2, 2],
[3, 3, 3], [3, 7, 14]]))
input_num = draw(st.sampled_from([0, 1]))
num = draw(st.sampled_from([0, 3]))
input_axis = draw(st.sampled_from([0, 1, 2, 3]))
input_type = draw(st.sampled_from(["type_float", "type_int",
"type_int64"]))
Out = draw(
st.sampled_from([["output_var0", "output_var1"],
["output_var0", "output_var1", "output_var2"]]))
#Sections and num cannot both be equal to 0.
assume((num != 0 & len(sections) == 0) | (num == 0 & len(sections) != 0))
# the dimensions of input and axis match
assume(input_axis < len(in_shape))
#When sections and num are not both equal to 0, sections has higher priority.
#The sum of sections should be equal to the input size.
if len(sections) != 0:
assume(len(Out) == len(sections))
assume(in_shape[input_axis] % len(sections) == 0)
sum = 0
for num in sections:
sum += num
assume(sum == in_shape[input_axis])
if num != 0:
assume(len(Out) == num)
assume(in_shape[input_axis] % 3 == 0)
if input_num == 0:
assume((len(in_shape) == 2) & (in_shape[1] == 24)
& (sections == [10, 14]) & (len(Out) == 2))
def generate_input(*args, **kwargs):
if input_type == "type_float":
return np.random.normal(0.0, 1.0, in_shape).astype(np.float32)
elif input_type == "type_int":
return np.random.normal(0.0, 1.0, in_shape).astype(np.int32)
elif input_type == "type_int64":
return np.random.normal(0.0, 1.0, in_shape).astype(np.int64)
def generate_AxisTensor(*args, **kwargs):
return np.ones([1]).astype(np.int32)
def generate_SectionsTensorList1(*args, **kwargs):
return np.array([10]).astype(np.int32)
def generate_SectionsTensorList2(*args, **kwargs):
return np.array([14]).astype(np.int32)
dics_intput = [{
"X": ["input_data"],
"AxisTensor": ["AxisTensor"],
"SectionsTensorList": ["SectionsTensorList1", "SectionsTensorList2"]
}, {
"X": ["input_data"]
}]
dics_weight = [{
"AxisTensor":
TensorConfig(data_gen=partial(generate_AxisTensor)),
"SectionsTensorList1":
TensorConfig(data_gen=partial(generate_SectionsTensorList1)),
"SectionsTensorList2":
TensorConfig(data_gen=partial(generate_SectionsTensorList2))
}, {}]
ops_config = OpConfig(type="split",
inputs=dics_intput[input_num],
outputs={"Out": Out},
attrs={
"sections": sections,
"num": num,
"axis": input_axis
})
program_config = ProgramConfig(
ops=[ops_config],
weights=dics_weight[input_num],
inputs={"input_data": TensorConfig(data_gen=partial(generate_input))},
outputs=Out)
return program_config
def sample_program_configs(draw):
in_shape = draw(
st.lists(st.integers(min_value=1, max_value=8), min_size=1,
max_size=4))
bias = draw(st.floats(min_value=-5, max_value=5))
bias_after_scale = draw(st.booleans())
scale = draw(st.floats(min_value=-5, max_value=5))
input_type = draw(st.sampled_from(["int8", "int32", "int64", "float32"]))
has_scale_tensor = draw(st.booleans())
def generate_input_int8(*args, **kwargs):
return np.random.randint(1, 10, in_shape).astype(np.int8)
def generate_input_int32(*args, **kwargs):
return np.random.randint(-10, 10, in_shape).astype(np.int32)
def generate_input_int64(*args, **kwargs):
return np.random.randint(-10, 10, in_shape).astype(np.int64)
def generate_input_float32(*args, **kwargs):
return np.random.random(in_shape).astype(np.float32)
input_dict = {"X": ["input_data"]}
if has_scale_tensor:
input_dict["ScaleTensor"] = "scale_tensor_data"
scale_op = OpConfig(type="scale",
inputs=input_dict,
outputs={"Out": ["output_data"]},
attrs={
"bias": bias,
"bias_after_scale": bias_after_scale,
"scale": scale
})
if input_type == "int8":
if has_scale_tensor:
program_config = ProgramConfig(
ops=[scale_op],
weights={},
inputs={
"input_data":
TensorConfig(data_gen=partial(generate_input_int8)),
"scale_tensor_data":
TensorConfig(shape=[
1,
])
},
outputs=["output_data"])
else:
program_config = ProgramConfig(
ops=[scale_op],
weights={},
inputs={
"input_data":
TensorConfig(data_gen=partial(generate_input_int8))
},
outputs=["output_data"])
elif input_type == "int32":
if has_scale_tensor:
program_config = ProgramConfig(
ops=[scale_op],
weights={},
inputs={
"input_data":
TensorConfig(data_gen=partial(generate_input_int32)),
"scale_tensor_data":
TensorConfig(shape=[
1,
])
},
outputs=["output_data"])
else:
program_config = ProgramConfig(
ops=[scale_op],
weights={},
inputs={
"input_data":
TensorConfig(data_gen=partial(generate_input_int32))
},
outputs=["output_data"])
elif input_type == "int64":
if has_scale_tensor:
program_config = ProgramConfig(
ops=[scale_op],
weights={},
inputs={
"input_data":
TensorConfig(data_gen=partial(generate_input_int64)),
"scale_tensor_data":
TensorConfig(shape=[
1,
])
},
outputs=["output_data"])
else:
program_config = ProgramConfig(
ops=[scale_op],
weights={},
inputs={
"input_data":
TensorConfig(data_gen=partial(generate_input_int64))
},
outputs=["output_data"])
elif input_type == "float32":
if has_scale_tensor:
program_config = ProgramConfig(
ops=[scale_op],
weights={},
inputs={
"input_data":
TensorConfig(data_gen=partial(generate_input_float32)),
"scale_tensor_data":
TensorConfig(shape=[
1,
])
},
outputs=["output_data"])
else:
program_config = ProgramConfig(
ops=[scale_op],
weights={},
inputs={
"input_data":
TensorConfig(data_gen=partial(generate_input_float32))
},
outputs=["output_data"])
return program_config
def sample_program_configs(self, draw):
in_shape0 = draw(
st.lists(st.integers(min_value=1, max_value=128),
min_size=3,
max_size=3))
in_shape0 = [draw(st.integers(min_value=1, max_value=4))] + in_shape0
weight_shape0 = [
draw(st.integers(min_value=3, max_value=64)), in_shape0[1], 1, 1
]
weight_shape1 = [
draw(st.integers(min_value=3, max_value=64)), weight_shape0[0], 1,
1
]
scale_in = draw(st.floats(min_value=0.001, max_value=0.1))
scale_out = draw(st.floats(min_value=0.001, max_value=0.1))
padding_algorithm0 = draw(st.sampled_from(["VALID", "SAME"]))
strides0 = draw(st.sampled_from([[1, 1], [2, 2]]))
paddings0 = draw(
st.lists(st.integers(min_value=0, max_value=2),
min_size=2,
max_size=2))
dilations0 = draw(st.sampled_from([[1, 1], [2, 2]]))
assume(in_shape0[1] == weight_shape0[1] * 1)
mula = in_shape0[1] * (weight_shape1[0] - weight_shape0[0])
mulb = weight_shape0[0] * weight_shape1[0]
assume(not (mula <= 0 or mula > mulb))
paddings_, dilations_ = UpdatePaddingAndDilation(
in_shape=in_shape0,
weight_shape=weight_shape0,
paddings=[0, 0],
dilations=[1, 1],
groups=1,
padding_algorithm="VALID",
strides=[1, 1])
out_shape = [in_shape0[0], weight_shape0[0]]
oh, ow = ConvOutputSize(in_shape=in_shape0,
weight_shape=weight_shape0,
dilations=dilations_,
paddings=paddings_,
strides=[1, 1])
out_shape0 = out_shape + [oh, ow]
assume(oh > 0 and ow > 0)
in_shape1 = out_shape0
paddings_, dilations_ = UpdatePaddingAndDilation(
in_shape=in_shape1,
weight_shape=weight_shape1,
paddings=[0, 0],
dilations=[1, 1],
groups=1,
padding_algorithm="VALID",
strides=[1, 1])
out_shape = [in_shape1[0], weight_shape1[0]]
oh, ow = ConvOutputSize(in_shape=in_shape1,
weight_shape=weight_shape1,
dilations=dilations_,
paddings=paddings_,
strides=[1, 1])
out_shape1 = out_shape + [oh, ow]
assume(oh > 0 and ow > 0)
conv0_op = OpConfig(type="conv2d",
inputs={
"Input": ["input_data"],
"Filter": ["weight_data0"]
},
outputs={"Output": ["conv_output_data"]},
attrs={
"data_format": 'nchw',
"dilations": dilations0,
"padding_algorithm": padding_algorithm0,
"groups": 1,
"Scale_in": scale_in,
"Scale_out": scale_out,
"paddings": paddings0,
"strides": strides0
})
conv1_op = OpConfig(type="conv2d",
inputs={
"Input": ["conv_output_data"],
"Filter": ["weight_data1"]
},
outputs={"Output": ["output_data"]},
attrs={
"data_format": 'nchw',
"dilations": [1, 1],
"padding_algorithm": "VALID",
"Scale_in": scale_in,
"Scale_out": scale_out,
"groups": 1,
"paddings": [0, 0],
"strides": [1, 1]
})
ops = [conv0_op, conv1_op]
self.ops = ops
program_config = ProgramConfig(ops=ops,
weights={
"weight_data0":
TensorConfig(shape=weight_shape0),
"weight_data1":
TensorConfig(shape=weight_shape1)
},
inputs={
"input_data":
TensorConfig(shape=in_shape0),
},
outputs=["output_data"])
return program_config
def sample_program_config(self, draw):
padding_algorithm = draw(st.sampled_from(["EXPLICIT", "SAME",
"VALID"]))
groups = draw(st.integers(min_value=1, max_value=3))
data_format = draw(st.sampled_from(["NCHW", "NHWC"]))
axis = draw(st.sampled_from([1]))
filter_channel = draw(st.integers(min_value=1, max_value=16)) * 4
filter_size = draw(st.integers(min_value=1, max_value=4))
in_channel = groups * filter_channel
out_channel_factor = draw(st.integers(min_value=1, max_value=16)) * 4
out_channel = groups * out_channel_factor
batch_size = draw(st.integers(min_value=1, max_value=4))
dilations = draw(
st.lists(st.integers(min_value=1, max_value=2),
min_size=2,
max_size=2))
paddings = draw(
st.lists(st.integers(min_value=0, max_value=2),
min_size=2,
max_size=2))
strides = draw(
st.lists(st.integers(min_value=1, max_value=2),
min_size=2,
max_size=2))
has_bias = draw(st.booleans())
x_shape = [
batch_size, in_channel, 64, 64
] if data_format == "NCHW" else [batch_size, 64, 64, in_channel]
w_shape = [out_channel, filter_channel, filter_size, filter_size]
scale_shape = [out_channel]
bias_shape = [out_channel]
def generate_input():
return np.random.random(x_shape).astype(np.float32)
def generate_weight():
return np.random.random(w_shape).astype(np.float32)
def generate_bias():
return np.random.random(bias_shape).astype(np.float32)
def generate_scale_bias():
return np.random.random(bias_shape).astype(np.float32)
conv2d_op = OpConfig("conv2d",
inputs={
"Input": ["input_data"],
"Filter": ["conv2d_weight"],
},
outputs={"Output": ["conv_output"]},
data_format=data_format,
dilations=dilations,
padding_algorithm=padding_algorithm,
groups=groups,
paddings=paddings,
strides=strides,
has_bias=has_bias,
is_test=True)
ac_op = OpConfig("affine_channel",
inputs={
"X": ["conv_output"],
"Scale": ["affine_channel_scale"],
"Bias": ["affine_channel_bias"]
},
outputs={"Out": ["affine_channel_ouput"]},
data_layout=data_format)
if has_bias == True:
conv2d_op.inputs["Bias"] = ["conv2d_bias"]
ops = [conv2d_op, ac_op]
program_config = ProgramConfig(
ops=ops,
inputs={
"input_data": TensorConfig(data_gen=partial(generate_input)),
},
weights={
"conv2d_weight":
TensorConfig(data_gen=partial(generate_weight)),
"conv2d_bias":
TensorConfig(data_gen=partial(generate_bias)),
"affine_channel_scale":
TensorConfig(data_gen=partial(generate_scale_bias)),
"affine_channel_bias":
TensorConfig(data_gen=partial(generate_scale_bias)),
},
outputs=["affine_channel_ouput"])
if has_bias == True:
program_config.weights["conv2d_bias"] = TensorConfig(
data_gen=partial(generate_bias))
return program_config
def sample_program_configs(draw):
prior_box_type = draw(st.sampled_from(["density_prior_box"]))
if prior_box_type == "density_prior_box":
#image params
batch_size = draw(st.integers(min_value=1, max_value=4))
image_channels = 3
image_w = draw(st.integers(min_value=40, max_value=50))
image_h = draw(st.integers(min_value=40, max_value=50))
density_prior_box_layer1_channels = draw(
st.integers(
min_value=10, max_value=40))
density_prior_box_layer1_w = draw(
st.integers(
min_value=30, max_value=40))
density_prior_box_layer1_h = draw(
st.integers(
min_value=30, max_value=40))
density_prior_box_layer2_channels = draw(
st.integers(
min_value=10, max_value=40))
density_prior_box_layer2_w = draw(
st.integers(
min_value=30, max_value=40))
density_prior_box_layer2_h = draw(
st.integers(
min_value=30, max_value=40))
def generate_image(*args, **kwargs):
return np.random.random((batch_size, image_channels, image_h,
image_w)).astype('float32')
def generate_density_prior_box1(*args, **kwargs):
return np.random.random(
(batch_size, density_prior_box_layer1_channels,
density_prior_box_layer1_h,
density_prior_box_layer1_w)).astype('float32')
def generate_density_prior_box2(*args, **kwargs):
return np.random.random(
(batch_size, density_prior_box_layer2_channels,
density_prior_box_layer2_h,
density_prior_box_layer2_w)).astype('float32')
min_max_aspect_ratios_order = draw(st.sampled_from([True, False]))
clip = draw(st.sampled_from([True, False]))
variances = [0.1, 0.1, 0.2, 0.2] #common value
fixed_sizes_1 = draw(
st.lists(
st.floats(
min_value=1, max_value=80), min_size=3, max_size=3))
densities_1 = draw(
st.lists(
st.integers(
min_value=1, max_value=10), min_size=3, max_size=3))
fixed_ratios_1 = draw(
st.lists(
st.floats(
min_value=1, max_value=10), min_size=1, max_size=1))
fixed_sizes_2 = draw(
st.lists(
st.floats(
min_value=1, max_value=80), min_size=2, max_size=2))
densities_2 = draw(
st.lists(
st.integers(
min_value=1, max_value=10), min_size=2, max_size=2))
fixed_ratios_2 = draw(
st.lists(
st.floats(
min_value=1, max_value=10), min_size=1, max_size=1))
value = draw(st.floats(min_value=1, max_value=1))
step_h_1 = float(image_h) / float(density_prior_box_layer1_h)
step_w_1 = float(image_w) / float(density_prior_box_layer1_w)
step_h_2 = float(image_h) / float(density_prior_box_layer2_h)
step_w_2 = float(image_w) / float(density_prior_box_layer2_w)
offset_1 = 0.5 #common value
offset_2 = 0.5 #common value
#reshape2 params
reshape2_w = draw(st.integers(min_value=4, max_value=4))
#density_prior_box InferShape
num_priors_1 = 0
for index in range(len(densities_1)):
num_priors_1 += len(fixed_ratios_1) * (pow(densities_1[index], 2))
density_prior_box_out1_shape = [
density_prior_box_layer1_h, density_prior_box_layer1_w,
num_priors_1, 4
] #4 is a common value
num_priors_2 = 0
for index in range(len(densities_2)):
num_priors_2 += len(fixed_ratios_2) * (pow(densities_2[index], 2))
density_prior_box_out2_shape = [
density_prior_box_layer2_h, density_prior_box_layer2_w,
num_priors_2, 4
] #4 is a common value
density_prior_box_layer1_length = density_prior_box_layer1_h * density_prior_box_layer1_w * num_priors_1
density_prior_box_layer2_length = density_prior_box_layer2_h * density_prior_box_layer2_w * num_priors_2
priorbox_shape = [
density_prior_box_layer1_length + density_prior_box_layer2_length,
4
]
#box_coder params
code_type = draw(st.sampled_from(["decode_center_size"]))
axis = draw(st.sampled_from([0, 1]))
box_normalized = draw(st.booleans())
variance = draw(st.sampled_from([[0.1, 0.2, 0.3, 0.4], []]))
lod_data = [[1, 1, 1, 1, 1]]
if code_type == "encode_center_size":
targetbox_shape = draw(st.sampled_from(
[[30, 4], [80, 4]])) #4 is required in paddle
else:
num0 = 1
num1 = 1
num2 = 1
if axis == 0:
num1 = priorbox_shape[0]
num0 = np.random.randint(1, 100)
else:
num0 = priorbox_shape[0]
num1 = np.random.randint(1, 100)
num2 = priorbox_shape[1]
targetbox_shape = draw(st.sampled_from([[num0, num1, num2]]))
def generate_targetbox(*args, **kwargs):
return np.random.random(targetbox_shape).astype(np.float32)
density_prior_box_op_1 = OpConfig(
type="density_prior_box",
inputs={
"Input": ["density_prior_box_input_data_1"],
"Image": ["density_prior_box_input_image"]
},
outputs={
"Boxes": ["density_prior_box_output_boxes_1"],
"Variances": ["density_prior_box_output_variances_1"]
},
attrs={
"clip": clip,
"value": value,
"min_max_aspect_ratios_order": min_max_aspect_ratios_order,
"variances": variances,
"step_h_1": step_h_1,
"step_w_1": step_w_1,
"offset": offset_1,
"fixed_sizes": fixed_sizes_1,
"fixed_ratios": fixed_ratios_1,
"densities": densities_1,
"flatten_to_2d": False
})
density_prior_box_op_2 = OpConfig(
type="density_prior_box",
inputs={
"Input": ["density_prior_box_input_data_2"],
"Image": ["density_prior_box_input_image"]
},
outputs={
"Boxes": ["density_prior_box_output_boxes_2"],
"Variances": ["density_prior_box_output_variances_2"]
},
attrs={
"clip": clip,
"value": value,
"min_max_aspect_ratios_order": min_max_aspect_ratios_order,
"variances": variances,
"step_h_2": step_h_2,
"step_w_2": step_w_2,
"offset": offset_2,
"fixed_sizes": fixed_sizes_2,
"fixed_ratios": fixed_ratios_2,
"densities": densities_2,
"flatten_to_2d": False
})
reshape2_op_1 = OpConfig(
type="reshape2",
inputs={"X": ["density_prior_box_output_boxes_1"]},
outputs={
"Out": ["reshape2_out_1"],
"XShape": ["reshape2_xshape_1"]
},
attrs={"shape": [-1, reshape2_w]})
reshape2_op_2 = OpConfig(
type="reshape2",
inputs={"X": ["density_prior_box_output_boxes_2"]},
outputs={
"Out": ["reshape2_out_2"],
"XShape": ["reshape2_xshape_2"]
},
attrs={"shape": [-1, reshape2_w]})
reshape2_op_3 = OpConfig(
type="reshape2",
inputs={"X": ["density_prior_box_output_variances_1"]},
outputs={
"Out": ["reshape2_out_3"],
"XShape": ["reshape2_xshape_3"]
},
attrs={"shape": [-1, reshape2_w]})
reshape2_op_4 = OpConfig(
type="reshape2",
inputs={"X": ["density_prior_box_output_variances_2"]},
outputs={
"Out": ["reshape2_out_4"],
"XShape": ["reshape2_xshape_4"]
},
attrs={"shape": [-1, reshape2_w]})
axis_1 = draw(st.sampled_from([0]))
axis_2 = draw(st.sampled_from([0]))
concat_op_1 = OpConfig(
type="concat",
inputs={"X": ["reshape2_out_1", "reshape2_out_2"]},
outputs={"Out": ["concat_out_1"]},
attrs={"axis": axis_1})
concat_op_2 = OpConfig(
type="concat",
inputs={"X": ["reshape2_out_3", "reshape2_out_4"]},
outputs={"Out": ["concat_out_2"]},
attrs={"axis": axis_2})
box_coder_op = OpConfig(
type="box_coder",
inputs={
"PriorBox": ["concat_out_1"],
"TargetBox": ["targetbox_data"],
"PriorBoxVar": ["concat_out_2"]
},
outputs={"OutputBox": ["outputbox_data"]},
attrs={
"code_type": code_type,
"box_normalized": box_normalized,
"axis": axis,
"variance": []
})
ops = [
density_prior_box_op_1, density_prior_box_op_2, reshape2_op_1,
reshape2_op_2, reshape2_op_3, reshape2_op_4, concat_op_1,
concat_op_2, box_coder_op
]
program_config = ProgramConfig(
ops=ops,
weights={},
inputs={
"density_prior_box_input_data_1":
TensorConfig(data_gen=partial(generate_density_prior_box1)),
"density_prior_box_input_data_2":
TensorConfig(data_gen=partial(generate_density_prior_box2)),
"density_prior_box_input_image":
TensorConfig(data_gen=partial(generate_image)),
"targetbox_data": TensorConfig(
data_gen=partial(generate_targetbox), lod=lod_data),
},
outputs=["outputbox_data"])
return program_config
else:
#image params
batch_size = draw(st.integers(min_value=1, max_value=4))
image_channels = 3
image_w = draw(st.integers(min_value=40, max_value=50))
image_h = draw(st.integers(min_value=40, max_value=50))
density_prior_box_layer1_channels = draw(
st.integers(
min_value=30, max_value=40))
density_prior_box_layer1_w = draw(
st.integers(
min_value=30, max_value=80))
density_prior_box_layer1_h = draw(
st.integers(
min_value=30, max_value=80))
density_prior_box_layer2_channels = draw(
st.integers(
min_value=30, max_value=40))
density_prior_box_layer2_w = draw(
st.integers(
min_value=30, max_value=80))
density_prior_box_layer2_h = draw(
st.integers(
min_value=30, max_value=80))
def generate_image(*args, **kwargs):
return np.random.random((batch_size, image_channels, image_w,
image_h)).astype('float32')
def generate_density_prior_box1(*args, **kwargs):
return np.random.random(
(batch_size, density_prior_box_layer1_channels,
density_prior_box_layer1_w,
density_prior_box_layer1_h)).astype('float32')
def generate_density_prior_box2(*args, **kwargs):
return np.random.random(
(batch_size, density_prior_box_layer2_channels,
density_prior_box_layer2_w,
density_prior_box_layer2_h)).astype('float32')
min_sizes = [2.0, 4.0]
max_sizes = [5.0, 10.0]
aspect_ratios = [2.0, 3.0]
variances = [0.1, 0.1, 0.2, 0.2]
flip = draw(st.sampled_from([True, False]))
clip = draw(st.sampled_from([True, False]))
min_max_aspect_ratios_order = draw(st.sampled_from([True, False]))
value = draw(st.floats(min_value=1, max_value=1))
step_h_1 = float(image_h) / float(density_prior_box_layer1_h)
step_w_1 = float(image_w) / float(density_prior_box_layer1_w)
step_h_2 = float(image_h) / float(density_prior_box_layer2_h)
step_w_2 = float(image_w) / float(density_prior_box_layer2_w)
offset_1 = 0.5 #common value
offset_2 = 0.5 #common value
#reshape2 params
reshape2_w = draw(st.integers(min_value=4, max_value=4))
#density_prior_box InferShape
output_aspect_ratior = []
prior_box_expand_aspect_ratios(
aspect_ratios, flip, output_aspect_ratior) #compute output size
num_priors_1 = len(output_aspect_ratior) * len(
min_sizes) #3 need compute
num_priors_1 += len(max_sizes)
density_prior_box_out1_shape = [
density_prior_box_layer1_h, density_prior_box_layer1_w,
num_priors_1, 4
] #4 is a common value
num_priors_2 = len(output_aspect_ratior) * len(min_sizes)
num_priors_2 += len(max_sizes)
density_prior_box_out2_shape = [
density_prior_box_layer2_h, density_prior_box_layer2_w,
num_priors_2, 4
] #4 is a common value
density_prior_box_layer1_length = density_prior_box_layer1_h * density_prior_box_layer1_w * num_priors_1
density_prior_box_layer2_length = density_prior_box_layer2_h * density_prior_box_layer2_w * num_priors_2
priorbox_shape = [
density_prior_box_layer1_length + density_prior_box_layer2_length,
4
]
#box_coder params
code_type = draw(st.sampled_from(["decode_center_size"]))
axis = draw(st.sampled_from([0, 1]))
box_normalized = draw(st.booleans())
variance = draw(st.sampled_from([[0.1, 0.2, 0.3, 0.4], []]))
lod_data = [[1, 1, 1, 1, 1]]
if code_type == "encode_center_size":
targetbox_shape = draw(st.sampled_from([[30, 4], [80, 4]]))
else:
num0 = 1
num1 = 1
num2 = 1
if axis == 0:
num1 = priorbox_shape[0]
num0 = np.random.randint(1, 100)
else:
num0 = priorbox_shape[0]
num1 = np.random.randint(1, 100)
num2 = priorbox_shape[1]
targetbox_shape = draw(st.sampled_from([[num0, num1, num2]]))
print(targetbox_shape)
def generate_targetbox(*args, **kwargs):
return np.random.random(targetbox_shape).astype(np.float32)
density_prior_box_op_1 = OpConfig(
type="prior_box",
inputs={
"Input": ["density_prior_box_input_data_1"],
"Image": ["density_prior_box_input_image"]
},
outputs={
"Boxes": ["density_prior_box_output_boxes_1"],
"Variances": ["density_prior_box_output_variances_1"]
},
attrs={
"flip": flip,
"clip": clip,
"value": value,
"min_max_aspect_ratios_order": min_max_aspect_ratios_order,
"variances": variances,
"step_h": step_h_1,
"step_w": step_w_1,
"offset": offset_1,
"min_sizes": min_sizes,
"max_sizes": max_sizes,
"aspect_ratios": aspect_ratios,
"flatten_to_2d": False
})
density_prior_box_op_2 = OpConfig(
type="prior_box",
inputs={
"Input": ["density_prior_box_input_data_2"],
"Image": ["density_prior_box_input_image"]
},
outputs={
"Boxes": ["density_prior_box_output_boxes_2"],
"Variances": ["density_prior_box_output_variances_2"]
},
attrs={
"flip": flip,
"clip": clip,
"value": value,
"min_max_aspect_ratios_order": min_max_aspect_ratios_order,
"variances": variances,
"step_h": step_h_2,
"step_w": step_w_2,
"offset": offset_2,
"min_sizes": min_sizes,
"max_sizes": max_sizes,
"aspect_ratios": aspect_ratios,
"flatten_to_2d": False
})
reshape2_op_1 = OpConfig(
type="reshape2",
inputs={"X": ["density_prior_box_output_boxes_1"]},
outputs={
"Out": ["reshape2_out_1"],
"XShape": ["reshape2_xshape_1"]
},
attrs={"shape": [-1, reshape2_w]})
reshape2_op_2 = OpConfig(
type="reshape2",
inputs={"X": ["density_prior_box_output_boxes_2"]},
outputs={
"Out": ["reshape2_out_2"],
"XShape": ["reshape2_xshape_2"]
},
attrs={"shape": [-1, reshape2_w]})
reshape2_op_3 = OpConfig(
type="reshape2",
inputs={"X": ["density_prior_box_output_variances_1"]},
outputs={
"Out": ["reshape2_out_3"],
"XShape": ["reshape2_xshape_3"]
},
attrs={"shape": [-1, reshape2_w]})
reshape2_op_4 = OpConfig(
type="reshape2",
inputs={"X": ["density_prior_box_output_variances_2"]},
outputs={
"Out": ["reshape2_out_4"],
"XShape": ["reshape2_xshape_4"]
},
attrs={"shape": [-1, reshape2_w]})
axis_1 = draw(st.sampled_from([0]))
axis_2 = draw(st.sampled_from([0]))
concat_op_1 = OpConfig(
type="concat",
inputs={"X": ["reshape2_out_1", "reshape2_out_2"]},
outputs={"Out": ["concat_out_1"]},
attrs={"axis": axis_1})
concat_op_2 = OpConfig(
type="concat",
inputs={"X": ["reshape2_out_3", "reshape2_out_4"]},
outputs={"Out": ["concat_out_2"]},
attrs={"axis": axis_2})
box_coder_op = OpConfig(
type="box_coder",
inputs={
"PriorBox": ["concat_out_1"],
"TargetBox": ["targetbox_data"],
"PriorBoxVar": ["concat_out_2"]
},
outputs={"OutputBox": ["outputbox_data"]},
attrs={
"code_type": code_type,
"box_normalized": box_normalized,
"axis": axis,
"variance": []
})
ops = [
density_prior_box_op_1, density_prior_box_op_2, reshape2_op_1,
reshape2_op_2, reshape2_op_3, reshape2_op_4, concat_op_1,
concat_op_2, box_coder_op
]
program_config = ProgramConfig(
ops=ops,
weights={},
inputs={
"density_prior_box_input_data_1":
TensorConfig(data_gen=partial(generate_density_prior_box1)),
"density_prior_box_input_data_2":
TensorConfig(data_gen=partial(generate_density_prior_box2)),
"density_prior_box_input_image":
TensorConfig(data_gen=partial(generate_image)),
"targetbox_data": TensorConfig(
data_gen=partial(generate_targetbox), lod=lod_data)
},
outputs=["outputbox_data"])
return program_config
def sample_program_configs(self, draw):
#conv param or conv_transpose param
in_shape = draw(
st.lists(st.integers(min_value=2, max_value=128),
min_size=3,
max_size=3))
in_shape = [draw(st.integers(min_value=1, max_value=4))] + in_shape
weight_shape = draw(
st.lists(st.integers(min_value=1, max_value=8),
min_size=2,
max_size=2))
weight_shape = weight_shape + [1, 1]
paddings = draw(
st.lists(st.integers(min_value=0, max_value=2),
min_size=2,
max_size=2))
dilations = draw(st.sampled_from([[1, 1], [2, 2]]))
groups = draw(st.sampled_from([1, 2, in_shape[1]]))
padding_algorithm = draw(st.sampled_from(["VALID", "SAME"]))
strides = draw(st.sampled_from([[1, 1], [2, 2]]))
output_padding = draw(
st.sampled_from([[],
draw(
st.lists(st.integers(min_value=0,
max_value=16),
min_size=2,
max_size=2))]))
scale_in = draw(st.floats(min_value=0.001, max_value=0.1))
scale_out = draw(st.floats(min_value=0.001, max_value=0.1))
conv_out_shape = []
paddings_, dilations_ = UpdatePaddingAndDilation(
in_shape, weight_shape, paddings, dilations, groups,
padding_algorithm, strides)
self.depthwise = in_shape[1] == weight_shape[1] and in_shape[
1] == groups
assume(in_shape[1] == weight_shape[1] * groups)
assume(weight_shape[0] % groups == 0)
conv_out_shape = [in_shape[0], weight_shape[0]]
oh, ow = ConvOutputSize(in_shape, weight_shape, dilations_, paddings_,
strides)
conv_out_shape = conv_out_shape + [oh, ow]
assume(oh > 0 and ow > 0)
conv_type = "conv2d"
conv_attrs = {
"data_format": 'nchw',
"dilations": dilations,
"padding_algorithm": padding_algorithm,
"groups": groups,
"paddings": paddings,
"strides": strides,
"Scale_in": scale_in,
"Scale_out": scale_out
}
conv_op = OpConfig(type=conv_type,
inputs={
"Input": ["input_data"],
"Filter": ["filter_data"]
},
outputs={"Output": ["conv_output_data"]},
attrs=conv_attrs)
elementwise_add_op = OpConfig(type="elementwise_add",
inputs={
"X": ["add_input_data"],
"Y": ["conv_output_data"]
},
outputs={"Out": ["output_data"]},
attrs={"axis": -1})
ops = [conv_op, elementwise_add_op]
self.ops = ops
program_config = ProgramConfig(
ops=ops,
weights={"filter_data": TensorConfig(shape=weight_shape)},
inputs={
"input_data": TensorConfig(shape=in_shape),
"add_input_data": TensorConfig(shape=conv_out_shape)
},
outputs=["output_data"])
return program_config
def sample_program_configs(draw):
min_sizes = [2.0, 4.0]
max_sizes = [5.0, 10.0]
aspect_ratios = [2.0, 3.0]
variances = [0.1, 0.1, 0.2, 0.2]
flip = True
clip = True
layer_w = draw(st.integers(min_value=30, max_value=40))
layer_h = draw(st.integers(min_value=30, max_value=40))
image_w = draw(st.integers(min_value=40, max_value=50))
image_h = draw(st.integers(min_value=40, max_value=50))
step_w = float(image_w) / float(layer_w)
step_h = float(image_h) / float(layer_h)
input_channels = 2
image_channels = 3
batch_size = 10
offset = 0.5
min_max_aspect_ratios_order = draw(st.sampled_from([True, False]))
def generate_input(*args, **kwargs):
return np.random.random(
(batch_size, image_channels, image_w, image_h)).astype('float32')
def generate_image(*args, **kwargs):
return np.random.random(
(batch_size, input_channels, layer_w, layer_h)).astype('float32')
ops_config = OpConfig(
type="prior_box",
inputs={
"Input": ["intput_data"],
"Image": ["intput_image"]
},
outputs={
"Boxes": ["output_boxes"],
"Variances": ["variances"]
},
attrs={
"min_sizes": min_sizes,
"max_sizes": max_sizes,
"aspect_ratios": aspect_ratios,
"variances": variances,
"flip": flip,
"clip": clip,
"step_w": step_w,
"step_h": step_h,
"offset": offset,
"min_max_aspect_ratios_order": min_max_aspect_ratios_order,
},
)
program_config = ProgramConfig(
ops=[ops_config],
weights={},
inputs={
"intput_data": TensorConfig(data_gen=partial(generate_input)),
"intput_image": TensorConfig(data_gen=partial(generate_image)),
},
outputs=["output_boxes", "variances"])
return program_config
def sample_program_configs(self, draw):
in_shape = draw(
st.lists(st.integers(min_value=6, max_value=64),
min_size=4,
max_size=4))
idx_shape = draw(
st.lists(st.integers(min_value=1, max_value=5),
min_size=1,
max_size=1))
dim_data = draw(st.sampled_from([1, 2, 3]))
type_str = draw(
st.sampled_from(
["type_float", "type_int", "type_short", "type_char"]))
def generate_input1(*args, **kwargs):
return np.random.random(in_shape).astype(np.float32)
def generate_input2(*args, **kwargs):
return np.random.randint(low=1, high=100,
size=in_shape).astype(np.int32)
def generate_input3(*args, **kwargs):
return np.random.randint(low=1, high=100,
size=in_shape).astype(np.int16)
def generate_input4(*args, **kwargs):
return np.random.randint(low=1, high=100,
size=in_shape).astype(np.int8)
def generate_idx(*args, **kwargs):
return np.random.randint(low=1, high=5,
size=idx_shape).astype(np.int64)
build_ops = OpConfig(type="index_select",
inputs={
"X": ["input_data"],
"Index": ["idx"]
},
outputs={
"Out": ["output_data"],
},
attrs={
"dim": dim_data,
})
tmp_input = {}
if type_str == "type_float":
tmp_input = {
"input_data": TensorConfig(data_gen=partial(generate_input1)),
"idx": TensorConfig(data_gen=partial(generate_idx)),
}
elif type_str == "type_int":
build_ops.outputs_dtype = {"output_data": np.int32}
tmp_input = {
"input_data": TensorConfig(data_gen=partial(generate_input2)),
"idx": TensorConfig(data_gen=partial(generate_idx)),
}
elif type_str == "type_short":
build_ops.outputs_dtype = {"output_data": np.int16}
tmp_input = {
"input_data": TensorConfig(data_gen=partial(generate_input3)),
"idx": TensorConfig(data_gen=partial(generate_idx)),
}
elif type_str == "type_char":
build_ops.outputs_dtype = {"output_data": np.int8}
tmp_input = {
"input_data": TensorConfig(data_gen=partial(generate_input4)),
"idx": TensorConfig(data_gen=partial(generate_idx)),
}
program_config = ProgramConfig(ops=[build_ops],
weights={},
inputs=tmp_input,
outputs=["output_data"])
return program_config
def sample_program_configs(self, draw):
def judge_update_shape(ref_shape, index_shape):
update_shape = []
for i in range(len(index_shape) - 1):
update_shape.append(index_shape[i])
for i in range(index_shape[-1], len(ref_shape), 1):
update_shape.append(ref_shape[i])
return update_shape
input_type = draw(st.sampled_from(["int32", "int64", "float32"]))
index_type = draw(st.sampled_from(["int32", "int64"]))
out_dtype_dict = {
"int32": np.int32,
"int64": np.int64,
"float32": np.float32
}
in_shape = draw(
st.lists(st.integers(min_value=2, max_value=8),
min_size=3,
max_size=7))
index_np = np.vstack([
np.random.randint(0, s, size=100) for s in in_shape
]).T.astype(index_type)
update_shape = judge_update_shape(in_shape, index_np.shape)
assume(index_np.shape[-1] <= len(in_shape))
def generate_data(*args, **kwargs):
if kwargs["type"] == "int32":
return np.random.randint(kwargs["low"], kwargs["high"],
kwargs["shape"]).astype(np.int32)
elif kwargs["type"] == "int64":
return np.random.randint(kwargs["low"], kwargs["high"],
kwargs["shape"]).astype(np.int64)
elif kwargs["type"] == "float32":
return kwargs["high"] * np.random.random(
kwargs["shape"]).astype(np.float32) + kwargs["low"]
def generate_index_data(*args, **kwargs):
return index_np
scatter_nd_add_op = OpConfig(
type="scatter_nd_add",
inputs={
"X": ["input_data"],
"Index": ["index"],
"Updates": ["updates"]
},
outputs={"Out": ["output_data"]},
outputs_dtype={"output_data": out_dtype_dict[input_type]},
attrs={})
program_config = ProgramConfig(
ops=[scatter_nd_add_op],
weights={},
inputs={
"input_data":
TensorConfig(data_gen=partial(generate_data,
type=input_type,
low=-10,
high=10,
shape=in_shape)),
"index":
TensorConfig(data_gen=partial(generate_index_data)),
"updates":
TensorConfig(data_gen=partial(generate_data,
type=input_type,
low=-10,
high=10,
shape=update_shape)),
},
outputs=["output_data"])
return program_config
def sample_program_configs(self, draw):
def generate_input(*args, **kwargs):
if kwargs["type"] == "int32":
return np.random.randint(kwargs["low"], kwargs["high"],
kwargs["shape"]).astype(np.int32)
elif kwargs["type"] == "int64":
return np.random.randint(kwargs["low"], kwargs["high"],
kwargs["shape"]).astype(np.int64)
elif kwargs["type"] == "float32":
return (kwargs["high"] - kwargs["low"]) * np.random.random(
kwargs["shape"]).astype(np.float32) + kwargs["low"]
def generate_lod(seq_num, max_len):
seq_offset = []
sum = 0
seq_offset.append(sum)
for i in range(seq_num):
sum += np.random.randint(0, max_len) + 1
seq_offset.append(sum)
return [seq_offset]
input_type = draw(st.sampled_from(["float32", "int32", "int64"]))
max_len = draw(st.integers(min_value=1, max_value=5))
ref_level_data = draw(st.integers(min_value=-1, max_value=4))
seq_num = draw(st.integers(min_value=1, max_value=7))
in_shape = draw(
st.lists(st.integers(min_value=1, max_value=10),
min_size=2,
max_size=8))
lod_x = generate_lod(seq_num, max_len)
lod_y = generate_lod(seq_num, max_len)
in_shape[0] = lod_x[0][-1]
x_lod_len = lod_x[0][-1]
y_lod_len = lod_y[0][-1]
assume(lod_x[0][0] == lod_y[0][0])
# x lod level is <= 1; y lod level is > 0
assume((np.array(lod_x)).shape[0] <= 1)
assume((np.array(lod_y)).shape[0] > 0)
assume(ref_level_data == -1
or (ref_level_data >= 0 and ref_level_data <
(np.array(lod_y)).shape[0]))
assume((np.array(lod_x)).shape[0] == 1
and x_lod_len == (len(lod_y[ref_level_data])))
# ! The input data type defined in Paddle can be float32, int32, int64.
# There is only Host implementention which only support float32.
assume(input_type == "float32")
sequence_expand_op = OpConfig(type="sequence_expand",
inputs={
"X": ["x_data"],
"Y": ["y_data"]
},
outputs={"Out": ["output_data"]},
attrs={"ref_level": ref_level_data})
program_config = ProgramConfig(
ops=[sequence_expand_op],
weights={},
inputs={
"x_data":
TensorConfig(data_gen=partial(generate_input,
type=input_type,
low=-10,
high=10,
shape=in_shape),
lod=lod_x),
"y_data":
TensorConfig(data_gen=partial(generate_input,
type=input_type,
low=-10,
high=10,
shape=in_shape),
lod=lod_y)
},
outputs=["output_data"])
return program_config
def sample_program_configs(self, draw):
has_relu = draw(st.sampled_from([True, False]))
mul_x_in_shape = draw(
st.lists(
st.integers(
min_value=5, max_value=10), min_size=2, max_size=5))
x_num_col_dims_data = draw(
st.integers(
min_value=1, max_value=len(mul_x_in_shape) - 1))
x0 = 1
x1 = 1
for i in range(0, x_num_col_dims_data):
x0 = x0 * mul_x_in_shape[i]
for i in range(x_num_col_dims_data, len(mul_x_in_shape)):
x1 = x1 * mul_x_in_shape[i]
#lite not check fuse condition : bias[0]=1 bias[1]=weight[1]
add_x_data_shape = draw(
st.sampled_from([[
1, draw(st.integers(
min_value=5, max_value=10))
], [draw(st.integers(
min_value=5, max_value=10))]]))
y_dims = 2
y_num_col_dims = 1
mul_out_shape = x_num_col_dims_data + y_dims - y_num_col_dims
axis = mul_out_shape - len(add_x_data_shape)
y1 = add_x_data_shape[0]
if len(add_x_data_shape) == 2:
y1 = add_x_data_shape[1]
mul_op = OpConfig(
type="mul",
inputs={"X": ["mul_x_data"],
"Y": ["mul_y_data"]},
outputs={"Out": ["mul_output_data"]},
attrs={
"x_num_col_dims": x_num_col_dims_data,
"y_num_col_dims": 1
})
elementwise_add_op = OpConfig(
type="elementwise_add",
inputs={"X": ["mul_output_data"],
"Y": ["add_x_data"]},
outputs={"Out": ["elementwise_add_output_data"]},
attrs={"axis": axis})
active_op = OpConfig(
type="relu",
inputs={"X": ["elementwise_add_output_data"]},
outputs={"Out": ["output_data"]},
attrs={})
ops = [mul_op, elementwise_add_op]
output_data = "elementwise_add_output_data"
if has_relu:
ops.append(active_op)
output_data = "output_data"
program_config = ProgramConfig(
ops=ops,
weights={"add_x_data": TensorConfig(shape=add_x_data_shape)},
inputs={
"mul_x_data": TensorConfig(shape=mul_x_in_shape),
"mul_y_data": TensorConfig(shape=[x1, y1])
},
outputs=[output_data])
return program_config
def sample_program_configs(self, draw):
if self.get_target() == "OpenCL":
in_shape = draw(
st.lists(st.integers(min_value=1, max_value=8),
min_size=4,
max_size=4))
else:
in_shape = draw(
st.lists(st.integers(min_value=1, max_value=8),
min_size=2,
max_size=4))
expand_shape = draw(
st.lists(st.integers(min_value=1, max_value=4),
min_size=len(in_shape),
max_size=len(in_shape)))
with_tensor = draw(st.sampled_from([True, False]))
def generate_shape(*args, **kwargs):
return np.array(expand_shape).astype(np.int32)
def generate_input(*args, **kwargs):
if kwargs["type"] == "int32":
return np.random.randint(kwargs["low"], kwargs["high"],
kwargs["shape"]).astype(np.int32)
elif kwargs["type"] == "int64":
return np.random.randint(kwargs["low"], kwargs["high"],
kwargs["shape"]).astype(np.int64)
elif kwargs["type"] == "float32":
return (kwargs["high"] - kwargs["low"]) * np.random.random(
kwargs["shape"]).astype(np.float32) + kwargs["low"]
input_type = draw(st.sampled_from(["float32", "int32", "int64"]))
def gnerate_inputs(with_tensor):
inputs1 = {}
inputs2 = {}
if (with_tensor):
inputs1 = {"X": ["input_data"], "ExpandTimes": ["expand_data"]}
inputs2 = {
"input_data":
TensorConfig(data_gen=partial(generate_input,
type=input_type,
low=-10,
high=10,
shape=in_shape)),
"expand_data":
TensorConfig(data_gen=partial(generate_shape))
}
else:
inputs1 = {"X": ["input_data"]}
inputs2 = {
"input_data":
TensorConfig(data_gen=partial(generate_input,
type=input_type,
low=-10,
high=10,
shape=in_shape))
}
return [inputs1, inputs2]
attr_shape = draw(
st.lists(st.integers(min_value=1, max_value=8),
min_size=len(in_shape),
max_size=len(in_shape)))
if self.get_target() == "OpenCL":
with_tensor = False
attr_shape[1] = 1
inputs = gnerate_inputs(with_tensor)
expand_op = OpConfig(type="expand",
inputs=inputs[0],
outputs={"Out": ["output_data"]},
attrs={"expand_times": attr_shape})
program_config = ProgramConfig(ops=[expand_op],
weights={},
inputs=inputs[1],
outputs=["output_data"])
return program_config
def sample_program_configs(self, draw):
target_str = self.get_target()
if target_str == "OpenCL":
shape0 = draw(st.integers(min_value=1, max_value=4)) * 4
shape1 = draw(st.integers(min_value=1, max_value=4)) * 4
shape2 = draw(st.integers(min_value=1, max_value=4)) * 4
batch0 = draw(st.integers(min_value=1, max_value=4)) * 4
batch1 = draw(st.integers(min_value=1, max_value=4)) * 4
if target_str == "ARM" or target_str == "X86":
shape0 = draw(st.integers(min_value=1, max_value=64))
shape1 = draw(st.integers(min_value=1, max_value=64))
shape2 = draw(st.integers(min_value=1, max_value=64))
batch0 = draw(st.integers(min_value=1, max_value=64))
batch1 = draw(st.integers(min_value=1, max_value=64))
transpose_X = draw(st.booleans())
transpose_Y = draw(st.booleans())
if ((not transpose_X) and (not transpose_Y)):
X_shape = [batch0, 1, shape0, shape1]
Y_shape = [batch0, shape1, shape2]
if ((transpose_X) and (not transpose_Y)):
X_shape = [batch1, 1, shape1, shape0]
Y_shape = [batch1, 1, shape1, shape2]
if ((not transpose_X) and (transpose_Y)):
X_shape = [batch0, shape0, shape1]
Y_shape = [batch0, shape2, shape1]
if ((transpose_X) and (transpose_Y)):
X_shape = [batch0, shape1, shape0]
Y_shape = [batch0, shape2, shape1]
alpha = draw(st.sampled_from([0.1, 1.0, 1.1, -1.5]))
fused_reshape_X = draw(st.sampled_from([[]]))
fused_reshape_Y = draw(st.sampled_from([[]]))
fused_transpose_X = draw(st.sampled_from([[]]))
fused_transpose_Y = draw(st.sampled_from([[]]))
fused_reshape_Out = draw(st.sampled_from([[]]))
fused_transpose_Out = draw(st.sampled_from([[]]))
Scale_x = draw(st.floats(min_value=0.1, max_value=10.0))
Scale_y = draw(st.floats(min_value=0.1, max_value=10.0))
Scale_out = draw(st.floats(min_value=0.1, max_value=10.0))
# not use for lite
head_number = draw(st.integers(min_value=1, max_value=1))
force_fp32_output = draw(st.booleans())
matmul_op = OpConfig(
type="matmul",
inputs={"X": ["input_data_x"],
"Y": ["input_data_y"]},
outputs={"Out": ["output_data"]},
attrs={
"transpose_X": transpose_X,
"transpose_Y": transpose_Y,
"alpha": alpha,
"fused_reshape_X": fused_reshape_X,
"fused_reshape_Y": fused_reshape_Y,
"fused_transpose_X": fused_transpose_X,
"fused_transpose_Y": fused_transpose_Y,
"fused_reshape_Out": fused_reshape_Out,
"fused_transpose_Out": fused_transpose_Out,
"Scale_x": Scale_x,
"Scale_y": Scale_y,
"Scale_out": Scale_out,
"head_number": head_number,
"force_fp32_output": force_fp32_output
})
program_config = ProgramConfig(
ops=[matmul_op],
weights={},
inputs={
"input_data_x": TensorConfig(shape=X_shape),
"input_data_y": TensorConfig(shape=Y_shape)
},
outputs={"output_data"})
return program_config
def sample_program_configs(self, draw):
shape0 = draw(st.integers(min_value=1, max_value=64))
shape1 = draw(st.sampled_from([4, 8, 16, 24, 32]))
shape2 = draw(st.integers(min_value=1, max_value=64))
shape3 = draw(st.integers(min_value=1, max_value=64))
X_shape = [shape0, shape2, shape1] #[N, M, 4x]
Y_shape = [shape0, shape3, shape2] #[N, C, M]
background_label = draw(st.sampled_from([1, 0]))
score_threshold = draw(st.floats(min_value=0.1, max_value=1.0))
nms_threshold = draw(st.floats(min_value=0.1, max_value=0.1))
nms_eta = draw(st.floats(min_value=1.0, max_value=10.0))
nms_top_k = draw(st.integers(min_value=1, max_value=64))
keep_top_k = draw(st.integers(min_value=1, max_value=64))
normalized = draw(st.booleans())
test_case = draw(st.sampled_from(["two_input", "three_input"]))
def generate_input():
return np.random.randint(low=1, high=64,
size=[shape0]).astype(np.int32)
if test_case == "two_input":
multiclass_nms3_op = OpConfig(type="multiclass_nms3",
inputs={
"BBoxes": ["input_data_BBoxes"],
"Scores": ["input_data_Scores"]
},
outputs={
"Out": ["output_data"],
"Index": ["Index"],
"NmsRoisNum": ["NmsRoisNum"]
},
attrs={
"background_label":
background_label,
"score_threshold":
score_threshold,
"nms_threshold": nms_threshold,
"nms_top_k": nms_top_k,
"keep_top_k": keep_top_k,
"normalized": normalized,
"nms_eta": nms_eta
})
else:
multiclass_nms3_op = OpConfig(type="multiclass_nms3",
inputs={
"BBoxes": ["input_data_BBoxes"],
"Scores": ["input_data_Scores"],
"RoisNum":
["input_data_roisnum"]
},
outputs={
"Out": ["output_data"],
"Index": ["Index"],
"NmsRoisNum": ["NmsRoisNum"]
},
attrs={
"background_label":
background_label,
"score_threshold":
score_threshold,
"nms_threshold": nms_threshold,
"nms_top_k": nms_top_k,
"keep_top_k": keep_top_k,
"normalized": normalized,
"nms_eta": nms_eta
})
program_config = ProgramConfig(
ops=[multiclass_nms3_op],
weights={},
inputs={
"input_data_BBoxes": TensorConfig(shape=X_shape),
"input_data_Scores": TensorConfig(shape=Y_shape),
"input_data_roisnum": TensorConfig(data_gen=generate_input)
},
outputs={"output_data"})
return program_config
def sample_program_config(self, draw):
data_format = draw(st.sampled_from(["NCHW", "NHWC"]))
dilations = draw(st.sampled_from([[1, 1], [2, 2], [1, 2]]))
padding_algorithm = draw(st.sampled_from(["EXPLICIT", "SAME",
"VALID"]))
groups = draw(st.sampled_from([1, 2, 4]))
paddings = draw(st.sampled_from([[0, 3], [1, 2, 3, 4]]))
strides = draw(st.sampled_from([[1, 1], [2, 2], [1, 2]]))
batch_size = draw(st.integers(min_value=1, max_value=4))
def generate_input():
if data_format == "NCHW":
return np.random.random([batch_size, 48, 64,
64]).astype(np.float32)
else:
return np.random.random([batch_size, 64, 64,
48]).astype(np.float32)
def generate_weight():
return np.random.random([16, int(48 / groups), 3,
3]).astype(np.float32)
ops_config = [{
"op_type": "conv2d",
"op_inputs": {
"Input": ["input_data"],
"Filter": ["input_weight"]
},
"op_outputs": {
"Output": ["conv_output"]
},
"op_attrs": {
"data_format": data_format,
"dilations": dilations,
"padding_algorithm": padding_algorithm,
"groups": groups,
"paddings": paddings,
"strides": strides
}
}, {
"op_type": "mish",
"op_inputs": {
"X": ["conv_output"]
},
"op_outputs": {
"Out": ["mish_output"]
},
"op_attrs": {},
}]
ops = self.generate_op_config(ops_config)
program_config = ProgramConfig(
ops=ops,
weights={
"input_weight": TensorConfig(data_gen=partial(generate_weight))
},
inputs={
"input_data": TensorConfig(data_gen=partial(generate_input)),
},
outputs=["mish_output"])
return program_config
def sample_program_configs(self, draw):
num = draw(st.integers(min_value=1, max_value=4))
cin = draw(st.integers(min_value=1, max_value=128))
cout = draw(st.integers(min_value=1, max_value=128))
height = draw(st.integers(min_value=1, max_value=128))
width = draw(st.integers(min_value=1, max_value=128))
cout = draw(st.integers(min_value=1, max_value=128))
kw = np.random.randint(1, 5)
kh = np.random.randint(1, 5)
groups = draw(st.integers(min_value=1, max_value=128))
scale_in = draw(st.floats(min_value=0.001, max_value=0.1))
scale_out = draw(st.floats(min_value=0.001, max_value=0.1))
assume(cin % groups == 0)
assume(cout % groups == 0)
w_cin = (int)(cin / groups)
in_shape = [num, cin, height, width]
weight_shape = [cout, w_cin, kh, kw]
assume(in_shape[2] >= weight_shape[2])
assume(in_shape[3] >= weight_shape[3])
paddings = draw(
st.lists(st.integers(min_value=0, max_value=2),
min_size=2,
max_size=2))
dilations = draw(st.sampled_from([[1, 1]]))
padding_algorithm = draw(st.sampled_from(["VALID", "SAME"]))
strides = draw(st.sampled_from([[1, 1], [2, 2]]))
data_format = "NCHW"
use_mkldnn = False
if self.target[0] == "X86":
use_mkldnn = True
def generate_input(*args, **kwargs):
return np.random.random(in_shape).astype(np.float32)
def generate_filter(*args, **kwargs):
return np.random.random(weight_shape).astype(np.float32)
def generate_bias(*args, **kwargs):
return np.random.random([cout]).astype(np.float32)
inputs_data = {
"input_data": TensorConfig(data_gen=partial(generate_input))
}
inputs_type = {"Input": ["input_data"], "Filter": ["filter_data"]}
if use_mkldnn:
inputs_data["bias_data"] = TensorConfig(
data_gen=partial(generate_bias))
inputs_type["Bias"] = ["bias_data"]
conv_op = OpConfig(type="conv2d",
inputs=inputs_type,
outputs={"Output": ["output_data"]},
attrs={
"strides": strides,
"paddings": paddings,
"use_mkldnn": use_mkldnn,
"padding_algorithm": padding_algorithm,
"groups": groups,
"dilations": dilations,
"Scale_in": scale_in,
"Scale_out": scale_out,
"data_format": data_format
})
program_config = ProgramConfig(
ops=[conv_op],
weights={
"filter_data": TensorConfig(data_gen=partial(generate_filter))
},
inputs=inputs_data,
outputs=["output_data"])
return program_config
def sample_program_configs(draw):
blank = draw(st.integers(min_value=0, max_value=10))
merge_repeated = draw(st.booleans())
padding_value = draw(st.integers(min_value=0, max_value=10))
is_input_lod_tensor = draw(st.booleans())
input_output_data_type = draw(st.sampled_from([np.int32, np.int64]))
# LoD tensor need
sequence_num = draw(st.integers(min_value=1, max_value=20))
max_sequence_length = draw(st.integers(min_value=10, max_value=10))
def gen_lod_data(sequence_num, max_sequence_length):
sequence_length_list = [
np.random.randint(1, max_sequence_length + 1)
for i in range(sequence_num)
]
lod_data_init_list = sequence_length_list
lod_data_init_list.insert(0, 0)
lod_data_init_array = np.array(lod_data_init_list)
lod_data = np.cumsum(lod_data_init_array)
return [lod_data.tolist()]
if is_input_lod_tensor:
input_lod_data = gen_lod_data(sequence_num, max_sequence_length)
else:
input_lod_data = None
input_2d_tensor_shape = draw(
st.lists(
st.integers(
min_value=1, max_value=6), min_size=2, max_size=2))
def gen_input_data():
if is_input_lod_tensor:
total_sequence_length_of_mini_batch = input_lod_data[-1][-1]
input_data = np.random.randint(
0,
10,
size=(total_sequence_length_of_mini_batch, 1),
dtype=input_output_data_type)
return input_data
else:
return np.random.randint(
0,
10,
size=input_2d_tensor_shape,
dtype=input_output_data_type)
def gen_input_length():
input_length_data = []
for i in range(input_2d_tensor_shape[0]):
random_data = np.random.randint(
0, input_2d_tensor_shape[1], dtype=input_output_data_type)
input_length_data.append(random_data)
return np.array(input_length_data).reshape(-1, 1)
def gen_op_inputs_outputs_attrs():
#inputs
inputs = {'Input': ['input_data']}
inputs_tensor = {
'input_data': TensorConfig(
data_gen=partial(gen_input_data), lod=input_lod_data)
}
if not is_input_lod_tensor:
inputs['InputLength'] = ["input_length_data"]
inputs_tensor['input_length_data'] = TensorConfig(
data_gen=partial(gen_input_length))
# attrs
attrs = {
'blank': blank,
'merge_repeated': merge_repeated,
'padding_value': padding_value
}
# output
outputs_tensor_name_list = ['output']
outputs = {'Output': ['output']}
outputs_dtype = {'Output': input_output_data_type}
if not is_input_lod_tensor:
outputs['OutputLength'] = ['output_length']
outputs_tensor_name_list.append('output_length')
outputs_dtype['OutputLength'] = input_output_data_type
return inputs, attrs, outputs, inputs_tensor, outputs_tensor_name_list, outputs_dtype
inputs, attrs, outputs, inputs_tensor, outputs_tensor_name_list, outputs_dtype = gen_op_inputs_outputs_attrs(
)
ctc_align_op = OpConfig(
type="ctc_align",
inputs=inputs,
outputs=outputs,
attrs=attrs,
outputs_dtype=outputs_dtype)
program_config = ProgramConfig(
ops=[ctc_align_op],
weights={},
inputs=inputs_tensor,
outputs=outputs_tensor_name_list)
return program_config
def sample_program_configs(self):
def generate_input1(attrs: List[Dict[str, Any]], batch):
if self.dims == 4:
return np.ones([batch, 3, 24, 24]).astype(np.float32)
elif self.dims == 3:
return np.ones([batch, 3, 24]).astype(np.float32)
elif self.dims == 2:
return np.ones([batch, 24]).astype(np.float32)
elif self.dims == 1:
return np.ones([24]).astype(np.float32)
def generate_input2(attrs: List[Dict[str, Any]], batch):
if self.dims == 4:
return np.ones([batch, 3, 24, 24]).astype(np.float32)
elif self.dims == 3:
return np.ones([batch, 3, 24]).astype(np.float32)
elif self.dims == 2:
return np.ones([batch, 24]).astype(np.float32)
elif self.dims == 1:
return np.ones([24]).astype(np.float32)
def generate_input3(attrs: List[Dict[str, Any]], batch):
if self.dims == 4:
return np.ones([batch, 3, 24, 24]).astype(np.float32)
elif self.dims == 3:
return np.ones([batch, 3, 24]).astype(np.float32)
elif self.dims == 2:
return np.ones([batch, 24]).astype(np.float32)
elif self.dims == 1:
return np.ones([24]).astype(np.float32)
def generate_weight1(attrs: List[Dict[str, Any]]):
return np.zeros([1]).astype(np.int32)
for dims in [1, 2, 3, 4]:
for num_input in [0, 1]:
for batch in [1, 2, 4]:
for axis in [-1, 0, 1, 2, 3]:
self.num_input = num_input
self.dims = dims
dics = [{"axis": axis}, {}]
dics_intput = [{
"X": [
"concat_input1", "concat_input2",
"concat_input3"
],
"AxisTensor": ["AxisTensor"],
}, {
"X": [
"concat_input1", "concat_input2",
"concat_input3"
]
}]
dics_inputs = [{
"concat_input1":
TensorConfig(data_gen=partial(
generate_input1, dics, batch)),
"concat_input2":
TensorConfig(data_gen=partial(
generate_input2, dics, batch)),
"concat_input3":
TensorConfig(data_gen=partial(
generate_input3, dics, batch)),
"AxisTensor":
TensorConfig(
data_gen=partial(generate_weight1, dics))
}, {
"concat_input1":
TensorConfig(data_gen=partial(
generate_input1, dics, batch)),
"concat_input2":
TensorConfig(data_gen=partial(
generate_input2, dics, batch)),
"concat_input3":
TensorConfig(
data_gen=partial(generate_input3, dics, batch))
}]
ops_config = [{
"op_type": "concat",
"op_inputs": dics_intput[num_input],
"op_outputs": {
"Out": ["concat_output"]
},
"op_attrs": dics[0]
}]
ops = self.generate_op_config(ops_config)
program_config = ProgramConfig(
ops=ops,
weights={},
inputs=dics_inputs[num_input],
outputs=["concat_output"])
yield program_config
def sample_program_configs(self, draw):
in_num = draw(
st.lists(st.integers(min_value=1, max_value=4),
min_size=1,
max_size=1))
in_c_h_w = draw(
st.lists(st.integers(min_value=1, max_value=64),
min_size=3,
max_size=3))
X_shape = in_num + in_c_h_w
align_corners = draw(st.booleans())
scale1 = draw(st.floats(min_value=0.1, max_value=10.0))
scale2 = draw(st.floats(min_value=0.1, max_value=10.0))
interp_method = draw(st.sampled_from(["nearest"]))
out_w = draw(st.integers(min_value=1, max_value=32))
out_h = draw(st.integers(min_value=1, max_value=32))
data_layout = draw(st.sampled_from(["NCHW"]))
test_case = draw(st.sampled_from([1, 2, 3]))
def generate_input1(*args, **kwargs):
return np.random.normal(0.0, 1.0, X_shape).astype(np.float32)
def generate_scale(*args, **kwargs):
tmp = np.random.normal(0.1, 10.0, 2).astype(np.float32)
assume(tmp[0] * X_shape[2] > 1.0)
assume(tmp[0] * X_shape[3] > 1.0)
assume(tmp[1] * X_shape[2] > 1.0)
assume(tmp[1] * X_shape[3] > 1.0)
return tmp
def generate_input2(*args, **kwargs):
return np.random.randint(1, 32, 2).astype(np.int32)
def generate_input1_fp16(*args, **kwargs):
return np.random.normal(0.0, 1.0, X_shape).astype(np.float16)
assume(scale1 * X_shape[2] > 1.0)
assume(scale1 * X_shape[3] > 1.0)
assume(scale2 * X_shape[2] > 1.0)
assume(scale2 * X_shape[3] > 1.0)
assume(test_case != 2)
nnadapter_device_name = self.get_nnadapter_device_name()
if nnadapter_device_name == "nvidia_tensorrt":
nearest_interp_v2 = OpConfig(type="nearest_interp_v2",
inputs={"X": ["input_data_x"]},
outputs={"Out": ["output_data"]},
attrs={
"data_layout": data_layout,
"scale": [scale1, scale2],
"out_w": out_w,
"out_h": out_h,
"interp_method": interp_method,
"align_corners": False
})
program_config = ProgramConfig(
ops=[nearest_interp_v2],
weights={},
inputs={
"input_data_x": TensorConfig(data_gen=generate_input1)
},
outputs={"output_data"})
return program_config
if test_case == 1:
nearest_interp_v2 = OpConfig(type="nearest_interp_v2",
inputs={
"X": ["input_data_x"],
"Scale": ["Scale"]
},
outputs={"Out": ["output_data"]},
attrs={
"data_layout": data_layout,
"scale": [scale1, scale2],
"out_w": out_w,
"out_h": out_h,
"interp_method": interp_method,
"align_corners": align_corners
})
program_config = ProgramConfig(
ops=[nearest_interp_v2],
weights={},
inputs={
"input_data_x": TensorConfig(data_gen=generate_input1),
"Scale": TensorConfig(data_gen=generate_scale)
},
outputs={"output_data"})
elif test_case == 2:
nearest_interp_v2 = OpConfig(type="nearest_interp_v2",
inputs={
"X": ["input_data_x"],
"Scale": ["Scale"],
"OutSize": ["OutSize"]
},
outputs={"Out": ["output_data"]},
attrs={
"data_layout": data_layout,
"scale": [scale1, scale2],
"out_w": out_w,
"out_h": out_h,
"interp_method": interp_method,
"align_corners": align_corners
})
program_config = ProgramConfig(
ops=[nearest_interp_v2],
weights={},
inputs={
"input_data_x": TensorConfig(data_gen=generate_input1),
"Scale": TensorConfig(data_gen=generate_scale),
"OutSize": TensorConfig(data_gen=generate_input2)
},
outputs={"output_data"})
else:
nearest_interp_v2 = OpConfig(type="nearest_interp_v2",
inputs={"X": ["input_data_x"]},
outputs={"Out": ["output_data"]},
attrs={
"data_layout": data_layout,
"scale": [scale1, scale2],
"out_w": out_w,
"out_h": out_h,
"interp_method": interp_method,
"align_corners": align_corners
})
program_config = ProgramConfig(
ops=[nearest_interp_v2],
weights={},
inputs={
"input_data_x": TensorConfig(data_gen=generate_input1)
},
outputs={"output_data"})
return program_config
def sample_program_configs(self, draw):
in_shape_x = draw(
st.lists(st.integers(min_value=3, max_value=10),
min_size=3,
max_size=4))
axis = draw(st.sampled_from([-1, 0, 1, 2]))
op_type_str = draw(st.sampled_from(["greater_equal", "greater_than"]))
process_type = draw(
st.sampled_from(["type_int64", "type_float", "type_int32"]))
if axis == -1:
in_shape_y = in_shape_x
else:
in_shape_y = in_shape_x[axis:]
def generate_data(type, size_list):
if type == "type_int32":
return np.random.randint(low=0, high=100,
size=size_list).astype(np.int32)
elif type == "type_int64":
return np.random.randint(low=0, high=100,
size=size_list).astype(np.int64)
elif type == "type_float":
return np.random.random(size=size_list).astype(np.float32)
def generate_input_x():
return generate_data(process_type, in_shape_x)
def generate_input_y():
return generate_data(process_type, in_shape_y)
build_ops = OpConfig(type=op_type_str,
inputs={
"X": ["data_x"],
"Y": ["data_y"]
},
outputs={
"Out": ["output_data"],
},
attrs={
"axis": axis,
"force_cpu": True
},
outputs_dtype={"output_data": np.bool_})
cast_out = OpConfig(type="cast",
inputs={
"X": ["output_data"],
},
outputs={
"Out": ["cast_data_out"],
},
attrs={
"in_dtype": int(0),
"out_dtype": int(2)
},
outputs_dtype={"cast_data_out": np.int32})
program_config = ProgramConfig(
ops=[build_ops, cast_out],
weights={},
inputs={
"data_x": TensorConfig(data_gen=partial(generate_input_x)),
"data_y": TensorConfig(data_gen=partial(generate_input_y)),
},
outputs=["cast_data_out"])
return program_config
def sample_program_configs(draw):
in_shape = draw(
st.lists(st.integers(min_value=1, max_value=10),
min_size=1,
max_size=4))
tensor_shape = draw(
st.lists(st.integers(min_value=1, max_value=10),
min_size=1,
max_size=4))
dtype = draw(st.sampled_from([2, 3, 5]))
with_value_tensor = draw(st.sampled_from([True, False]))
with_shape_tensor = draw(st.sampled_from([True, False]))
def generate_shape_tensor(*args, **kwargs):
return np.array(tensor_shape).astype(np.int32)
def generate_input_bool(*args, **kwargs):
return np.random.random([1]).astype(np.bool)
def generate_input_int8(*args, **kwargs):
return np.random.random([1]).astype(np.int8)
def generate_input_int32(*args, **kwargs):
return np.random.random([1]).astype(np.int32)
def generate_input_int64(*args, **kwargs):
return np.random.random([1]).astype(np.int64)
def generate_input_float32(*args, **kwargs):
return np.random.random([1]).astype(np.float32)
if dtype == 0:
value_data = generate_input_bool
elif dtype == 2:
value_data = generate_input_int32
elif dtype == 3:
value_data = generate_input_int64
elif dtype == 5:
value_data = generate_input_float32
else:
value_data = generate_input_int8
value = draw(st.floats(min_value=-10, max_value=10))
op_inputs = {}
program_inputs = {}
#ShapeTensorList not support now
if (with_value_tensor and with_shape_tensor):
op_inputs = {
"ValueTensor": ["value_data"],
"ShapeTensor": ["shape_data"]
}
program_inputs = {
"value_data": TensorConfig(data_gen=partial(value_data)),
"shape_data": TensorConfig(data_gen=partial(generate_shape_tensor))
}
elif ((not with_value_tensor) and with_shape_tensor):
op_inputs = {"ShapeTensor": ["shape_data"]}
program_inputs = {
"shape_data": TensorConfig(data_gen=partial(generate_shape_tensor))
}
elif (with_value_tensor and (not with_shape_tensor)):
op_inputs = {"ValueTensor": ["value_data"]}
program_inputs = {
"value_data": TensorConfig(data_gen=partial(value_data))
}
fill_constant_op = OpConfig(
type="fill_constant",
inputs=op_inputs,
outputs={"Out": ["output_data"]},
attrs={
"dtype": dtype,
"shape": in_shape,
"value": value,
"force_cpu": False
#"place_type" : -1
})
program_config = ProgramConfig(ops=[fill_constant_op],
weights={},
inputs=program_inputs,
outputs=["output_data"])
return program_config
def sample_program_config(self, draw):
data_format = draw(st.sampled_from(["NCHW", "NHWC"]))
dilations = draw(st.sampled_from([[1, 1], [2, 2], [1, 2]]))
padding_algorithm = draw(st.sampled_from(["EXPLICIT", "SAME", "VALID"]))
groups = draw(st.sampled_from([1, 2, 4, 8]))
paddings = draw(st.sampled_from([[0, 3], [1, 2, 3, 4]]))
strides = draw(st.sampled_from([[1, 1], [2, 2], [1, 2]]))
axis = draw(st.sampled_from([1]))
batch_size = draw(st.integers(min_value=1, max_value=4))
def generate_input():
if data_format == "NCHW":
return np.random.random(
[batch_size, 16, 64, 64]).astype(np.float32)
else:
return np.random.random(
[batch_size, 64, 64, 16]).astype(np.float32)
def generate_weight1():
return np.random.random([16, 16, 3, 3]).astype(np.float32)
def generate_weight2():
return np.random.random([16 * groups]).astype(np.float32)
conv2d_op = OpConfig(
type="conv2d_transpose",
inputs={"Input": ["input_data"],
"Filter": ["conv2d_weight"]},
outputs={"Output": ["conv_output"]},
attrs={
"data_format": data_format,
"dilations": dilations,
"padding_algorithm": padding_algorithm,
"groups": groups,
"paddings": paddings,
"strides": strides,
"output_size": [],
"output_padding": [],
"is_test": True
})
elt_op = OpConfig(
type="elementwise_add",
inputs={"X": ["conv_output"],
"Y": ["elementwise_weight"]},
outputs={"Out": ["elementwise_output"]},
attrs={'axis': axis})
model_net = [conv2d_op, elt_op]
program_config = ProgramConfig(
ops=model_net,
weights={
"conv2d_weight":
TensorConfig(data_gen=partial(generate_weight1)),
"elementwise_weight":
TensorConfig(data_gen=partial(generate_weight2))
},
inputs={
"input_data": TensorConfig(data_gen=partial(generate_input))
},
outputs=["elementwise_output"])
return program_config
def sample_program_configs(self, draw):
num_pri = draw(st.integers(min_value=10, max_value=100))
priorbox_shape = [num_pri, 4]
code_type = draw(
st.sampled_from(["encode_center_size", "decode_center_size"]))
axis = draw(st.sampled_from([0, 1]))
box_normalized = draw(st.booleans())
variance = draw(st.sampled_from([[0.1, 0.2, 0.3, 0.4], []]))
lod_data = [[1, 1, 1, 1, 1]]
if code_type == "encode_center_size":
targetbox_shape = draw(st.sampled_from([[30, 4], [80, 4]]))
else:
num0 = 1
num1 = 1
num2 = 1
if axis == 0:
num1 = priorbox_shape[0]
num0 = np.random.randint(1, 100)
else:
num0 = priorbox_shape[0]
num1 = np.random.randint(1, 100)
num2 = priorbox_shape[1]
targetbox_shape = draw(st.sampled_from([[num0, num1, num2]]))
def generate_priorbox(*args, **kwargs):
return np.random.random(priorbox_shape).astype(np.float32)
def generate_priorbox_var(*args, **kwargs):
return np.random.random(priorbox_shape).astype(np.float32)
def generate_targetbox(*args, **kwargs):
return np.random.random(targetbox_shape).astype(np.float32)
input_type_dict = {}
input_data_dict = {}
input_type_dict["PriorBox"] = ["priorbox_data"]
input_type_dict["TargetBox"] = ["targetbox_data"]
input_data_dict["priorbox_data"] = TensorConfig(
data_gen=partial(generate_priorbox), lod=lod_data)
input_data_dict["targetbox_data"] = TensorConfig(
data_gen=partial(generate_targetbox), lod=lod_data)
if len(variance) == 0:
input_type_dict["PriorBoxVar"] = ["priorbox_var_data"]
input_data_dict["priorbox_var_data"] = TensorConfig(
data_gen=partial(generate_priorbox_var))
box_coder_op = OpConfig(type="box_coder",
inputs=input_type_dict,
outputs={"OutputBox": ["outputbox_data"]},
attrs={
"code_type": code_type,
"box_normalized": box_normalized,
"axis": axis,
"variance": variance
})
program_config = ProgramConfig(ops=[box_coder_op],
weights={},
inputs=input_data_dict,
outputs=["outputbox_data"])
return program_config
def sample_program_configs(self, draw):
in_shape = draw(
st.lists(st.integers(min_value=1, max_value=7),
min_size=2,
max_size=6))
update_shape = in_shape
assume(
len(update_shape) == len(in_shape)
and update_shape[1:] == in_shape[1:])
index_shape = draw(
st.lists(st.integers(min_value=1, max_value=len(update_shape)),
min_size=1,
max_size=1))
index_shape[0] = in_shape[0]
assume(
len(index_shape) == 1
or (len(index_shape) == 2 and index_shape[1] == 1))
index_type = draw(st.sampled_from(["int32", "int64"]))
overwrite = draw(st.booleans())
def generate_data(*args, **kwargs):
low, high = -10, 10
dtype = "float32"
shape = kwargs["shape"]
if "low" in kwargs:
low = kwargs["low"]
if "high" in kwargs:
high = kwargs["high"]
if "dtype" in kwargs:
dtype = kwargs["dtype"]
if dtype == "int32":
if low == high:
return low * np.ones(shape).astype(np.int32)
else:
return np.random.randint(low, high, shape).astype(np.int32)
elif dtype == "int64":
if low == high:
return low * np.ones(shape).astype(np.int64)
else:
return np.random.randint(low, high, shape).astype(np.int64)
elif dtype == "float32":
return (high - low) * np.random.random(shape).astype(
np.float32) + low
def generate_index(*args, **kwargs):
index_np = np.ones(index_shape).astype(np.int64)
for i in range(index_shape[0]):
index_np[i] = i
if kwargs["dtype"] == "int32":
index_np = index_np.astype(np.int32)
return index_np
scatter_op = OpConfig(type="scatter",
inputs={
"X": ["input_data"],
"Ids": ["index"],
"Updates": ["updates"]
},
outputs={"Out": ["output_data"]},
attrs={"overwrite": overwrite})
program_config = ProgramConfig(
ops=[scatter_op],
weights={},
inputs={
"input_data":
TensorConfig(data_gen=partial(generate_data, shape=in_shape)),
"index":
TensorConfig(
data_gen=partial(generate_index, dtype=index_type)),
"updates":
TensorConfig(
data_gen=partial(generate_data, shape=update_shape))
},
outputs=["output_data"])
return program_config
def sample_program_configs(self, draw):
input_n = draw(st.integers(min_value=1, max_value=4))
input_c = draw(st.integers(min_value=1, max_value=128))
input_h = draw(st.integers(min_value=1, max_value=128))
input_w = draw(st.integers(min_value=1, max_value=128))
filter_m = input_c
filter_c = 1
filter_h = draw(st.integers(min_value=1, max_value=7))
filter_w = draw(st.integers(min_value=1, max_value=7))
scale_in = draw(st.floats(min_value=0.001, max_value=0.1))
scale_out = draw(st.floats(min_value=0.001, max_value=0.1))
assume(input_h >= filter_h)
assume(input_w >= filter_w)
groups = input_c
paddings = draw(
st.lists(st.integers(min_value=0, max_value=20),
min_size=2,
max_size=2))
dilations = draw(
st.lists(st.integers(min_value=1, max_value=10),
min_size=2,
max_size=2))
padding_algorithm = draw(st.sampled_from(["VALID", "SAME"]))
strides = draw(
st.lists(st.integers(min_value=1, max_value=10),
min_size=2,
max_size=2))
data_format = "NCHW"
use_mkldnn = False
if self.get_target() == "X86":
use_mkldnn = True
def calc_output_size():
if padding_algorithm == "SAME":
output_h = input_h
output_w = input_w
elif padding_algorithm == "VALID":
output_h = (input_h - (dilations[0] *
(filter_h - 1) + 1)) / strides[0] + 1
output_w = (input_w - (dilations[1] *
(filter_w - 1) + 1)) / strides[1] + 1
else:
output_h = (input_h + 2 * paddings[0] -
(dilations[0] *
(filter_h - 1) + 1)) / strides[0] + 1
output_w = (input_w + 2 * paddings[1] -
(dilations[1] *
(filter_w - 1) + 1)) / strides[1] + 1
return output_h, output_w
output_h, output_w = calc_output_size()
assume(output_h >= 1)
assume(output_w >= 1)
in_shape = [input_n, input_c, input_h, input_w]
weight_shape = [filter_m, filter_c, filter_h, filter_w]
def generate_input(*args, **kwargs):
return np.random.random(in_shape).astype(np.float32)
def generate_filter(*args, **kwargs):
return np.random.random(weight_shape).astype(np.float32)
def generate_bias(*args, **kwargs):
return np.random.random([filter_m]).astype(np.float32)
inputs_type = {"Input": ["input_data"], "Filter": ["filter_data"]}
inputs_data = {
"input_data": TensorConfig(data_gen=partial(generate_input))
}
weights_data = {
"filter_data": TensorConfig(data_gen=partial(generate_filter))
}
if use_mkldnn:
has_bias = draw(st.booleans())
if has_bias:
inputs_type["Bias"] = ["bias_data"]
weights_data['bias_data'] = TensorConfig(
data_gen=partial(generate_bias))
depthwise_conv2d_op = OpConfig(type="depthwise_conv2d",
inputs=inputs_type,
outputs={"Output": ["output_data"]},
attrs={
"strides": strides,
"paddings": paddings,
"use_mkldnn": use_mkldnn,
"padding_algorithm":
padding_algorithm,
"groups": groups,
"dilations": dilations,
"Scale_in": scale_in,
"Scale_out": scale_out,
"data_format": data_format,
})
program_config = ProgramConfig(ops=[depthwise_conv2d_op],
weights=weights_data,
inputs=inputs_data,
outputs=["output_data"])
return program_config
def sample_program_configs(self, draw):
in_shape = draw(st.sampled_from([[1, 1, 1], [2, 1, 4]]))
Shape = draw(st.sampled_from([[2, 4, 4], [3, 2, 3, 4]]))
expand_shape = draw(st.sampled_from([[2, 5, 4], [2, 3, 4]]))
with_Shape = draw(st.sampled_from([True, False]))
#todo daming5432 input vector tensor
with_expand_shape = draw(st.booleans())
def generate_shape(*args, **kwargs):
return np.array(Shape).astype(np.int32)
def generate_expand_shape(i, *args, **kwargs):
return np.array([expand_shape[i]]).astype(np.int32)
def generate_input(*args, **kwargs):
if kwargs["type"] == "int32":
return np.random.randint(kwargs["low"], kwargs["high"],
kwargs["shape"]).astype(np.int32)
elif kwargs["type"] == "int64":
return np.random.randint(kwargs["low"], kwargs["high"],
kwargs["shape"]).astype(np.int64)
elif kwargs["type"] == "float32":
return (kwargs["high"] - kwargs["low"]) * np.random.random(
kwargs["shape"]).astype(np.float32) + kwargs["low"]
input_type = draw(st.sampled_from(["float32", "int64", "int32"]))
def gnerate_inputs(with_Shape, with_expand_shape):
inputs1 = {}
inputs2 = {}
# with_Shape has a higher priority than expand_shapes_tensor
if (with_Shape):
inputs1 = {
"X": ["input_data"],
"Shape": ["shape_data"],
}
inputs2 = {
"input_data":
TensorConfig(data_gen=partial(generate_input,
type=input_type,
low=-10,
high=10,
shape=in_shape)),
"shape_data":
TensorConfig(data_gen=partial(generate_shape))
}
elif ((not with_Shape) and with_expand_shape):
inputs1 = {
"X": ["input_data"],
"expand_shapes_tensor":
["expand_data0", "expand_data1", "expand_data2"]
}
inputs2 = {
"input_data":
TensorConfig(data_gen=partial(generate_input,
type=input_type,
low=-10,
high=10,
shape=in_shape)),
"expand_data0":
TensorConfig(data_gen=partial(generate_expand_shape, 0)),
"expand_data1":
TensorConfig(data_gen=partial(generate_expand_shape, 1)),
"expand_data2":
TensorConfig(data_gen=partial(generate_expand_shape, 2))
}
elif (with_Shape and (not with_expand_shape)):
inputs1 = {"X": ["input_data"], "Shape": ["shape_data"]}
inputs2 = {
"input_data":
TensorConfig(data_gen=partial(generate_input,
type=input_type,
low=-10,
high=10,
shape=in_shape)),
"shape_data":
TensorConfig(data_gen=partial(generate_shape))
}
else:
inputs1 = {"X": ["input_data"]}
inputs2 = {
"input_data":
TensorConfig(data_gen=partial(generate_input,
type=input_type,
low=-10,
high=10,
shape=in_shape))
}
return [inputs1, inputs2]
attr_shape = draw(
st.sampled_from([[2, 3, 4], [2, 4, 4], [2, 2, 3, 4], [3, 2, 5,
4]]))
inputs = gnerate_inputs(with_Shape, with_expand_shape)
expand_v2_op = OpConfig(type="expand_v2",
inputs=inputs[0],
outputs={"Out": ["output_data"]},
attrs={"shape": attr_shape})
expand_v2_op.outputs_dtype = {"output_data": input_type}
program_config = ProgramConfig(ops=[expand_v2_op],
weights={},
inputs=inputs[1],
outputs=["output_data"])
return program_config
def sample_program_configs(draw):
Transpose = draw(st.sampled_from([True]))
in_shape = draw(
st.lists(st.integers(min_value=1, max_value=64),
min_size=4,
max_size=4))
weight_shape = draw(
st.lists(st.integers(min_value=1, max_value=8), min_size=4,
max_size=4))
paddings = draw(
st.sampled_from([[1, 2], [4, 2], [1, 1], [0, 0], [1, 0], [1, 1]]))
dilations = draw(st.sampled_from([[1, 1], [2, 2]]))
groups = draw(st.sampled_from([1, 2]))
padding_algorithm = draw(st.sampled_from(["VALID", "SAME"]))
strides = draw(st.sampled_from([[1, 1], [2, 2]]))
threshold = draw(st.floats(min_value=0, max_value=1))
alpha = draw(st.floats(min_value=0, max_value=1))
scale = draw(st.floats(min_value=0.5, max_value=5))
offset = draw(st.floats(min_value=0, max_value=1))
output_padding = draw(
st.sampled_from([[],
draw(
st.lists(st.integers(min_value=0, max_value=16),
min_size=2,
max_size=2))]))
elementwise_bias_shape = draw(
st.sampled_from([[weight_shape[1] * groups], [1]]))
paddings_, dilations_ = UpdatePaddingAndDilation(in_shape, weight_shape,
paddings, dilations,
groups, padding_algorithm,
strides)
assume(in_shape[1] == weight_shape[0])
if len(output_padding):
assume(output_padding[0] < max(strides[0], dilations_[0]))
assume(output_padding[1] < max(strides[1], dilations_[1]))
conv_out_shape = [in_shape[0], weight_shape[1] * groups]
oh, ow = ConvTransposeOutputSize(in_shape, weight_shape, dilations_,
paddings_, strides)
if len(output_padding):
oh = oh + output_padding[0]
ow = ow + output_padding[1]
conv_out_shape = conv_out_shape + [oh, ow]
#assume(oh > 0 and ow > 0)????
Alpha_shape = []
mode_data = draw(st.sampled_from(["all", "channel", "element"]))
if mode_data == "all":
Alpha_shape = [1]
elif mode_data == "channel":
Alpha_shape = [conv_out_shape[1]]
elif mode_data == "element":
Alpha_shape = conv_out_shape
act_type = draw(
st.sampled_from(['relu', 'relu6', 'leaky_relu', 'hard_swish',
'prelu']))
def generate_act_attrs(act_type_str):
attrs = {}
if act_type_str == 'relu6':
attrs = {"threshold": threshold}
if act_type_str == 'leaky_relu':
attrs = {"alpha": alpha}
if act_type_str == 'hard_swish':
attrs = {"threshold": threshold, "scale": scale, "offset": offset}
if act_type_str == "prelu":
attrs = {"mode": mode_data, "data_format": "NCHW"}
return attrs
conv_op = OpConfig(type="conv2d_transpose",
inputs={
"Input": ["input_data"],
"Filter": ["weight_data"]
},
outputs={"Output": ["conv_output_data"]},
attrs={
"data_format": 'nchw',
"dilations": dilations,
"padding_algorithm": padding_algorithm,
"groups": groups,
"paddings": paddings,
"strides": strides,
"output_size": [],
"output_padding": output_padding
})
active_op_input = {}
inputs_data = {}
if act_type == "prelu":
active_op_input = {"X": ["conv_output_data"], "Alpha": ["alpha_data"]}
inputs_data = {
"input_data": TensorConfig(shape=in_shape),
"alpha_data": TensorConfig(shape=Alpha_shape)
}
else:
active_op_input = {"X": ["conv_output_data"]}
inputs_data = {"input_data": TensorConfig(shape=in_shape)}
elementwise_add_op = OpConfig(type="elementwise_add",
inputs={
"X": ["conv_output_data"],
"Y": ["add_bias_data"]
},
outputs={"Out": ["output_data"]},
attrs={"axis": 1})
ops = [conv_op, elementwise_add_op]
program_config = ProgramConfig(
ops=ops,
weights={
"weight_data": TensorConfig(shape=weight_shape),
"add_bias_data": TensorConfig(shape=elementwise_bias_shape)
},
inputs=inputs_data,
outputs=["output_data"])
return program_config
def sample_program_configs(draw):
in_shape = draw(
st.lists(st.integers(min_value=10, max_value=20),
min_size=4,
max_size=4))
lod_data = draw(
st.sampled_from([[0, 3, 5, in_shape[0]], [0, 4, 7, in_shape[0]],
[0, 4, in_shape[0]], [0, 7, in_shape[0]]]))
lod_data1 = draw(
st.sampled_from([[0, 3, 5, in_shape[0]], [0, 4, 7, in_shape[0]],
[0, 4, in_shape[0]], [0, 7, in_shape[0]]]))
lod_data2 = draw(
st.sampled_from([[0, 3, 5, in_shape[0]], [0, 4, 7, in_shape[0]],
[0, 4, in_shape[0]], [0, 7, in_shape[0]]]))
case_num = draw(st.sampled_from([0, 1]))
def generate_input_x(*args, **kwargs):
return np.random.random(in_shape).astype(np.float32)
def generate_input_y(*args, **kwargs):
return np.array(lod_data1).astype(np.int32)
if case_num == 0:
build_ops = OpConfig(type="lod_reset",
inputs={
"X": ["input_data_x"],
"Y": []
},
outputs={
"Out": ["output_data"],
},
attrs={
"target_lod": lod_data,
'append': True
})
program_config = ProgramConfig(
ops=[build_ops],
weights={},
inputs={
"input_data_x":
TensorConfig(
data_gen=partial(generate_input_x, lod=list(lod_data2))),
},
outputs=["output_data"])
elif case_num == 1:
build_ops = OpConfig(type="lod_reset",
inputs={
"X": ["input_data_x"],
"Y": ["input_data_y"]
},
outputs={
"Out": ["output_data"],
},
attrs={
"target_lod": [],
'append': True
})
program_config = ProgramConfig(
ops=[build_ops],
weights={},
inputs={
"input_data_x":
TensorConfig(
data_gen=partial(generate_input_x, lod=list(lod_data2))),
"input_data_y":
TensorConfig(data_gen=partial(generate_input_y)),
},
outputs=["output_data"])
return program_config
