def sample_program_configs(draw):
in_shape1 = draw(
st.lists(st.integers(min_value=1, max_value=10),
min_size=1,
max_size=4))
in_shape2 = draw(
st.lists(st.integers(min_value=1, max_value=10),
min_size=1,
max_size=4))
axis = draw(st.sampled_from([-1, 0, 1, 2, 3]))
def generate_input1(*args, **kwargs):
return np.random.random(in_shape1).astype(np.float32)
def generate_input2(*args, **kwargs):
return np.random.random(in_shape2).astype(np.float32)
def generate_axis(*args, **kwargs):
return np.array([axis]).astype("int32")
concat_op = OpConfig(type="concat",
inputs={
"X": ["input_data1", "input_data2"],
"AxisTensor": ["axis_tensor_data"]
},
outputs={"Out": ["output_data"]},
attrs={"axis": axis})
program_config = ProgramConfig(
ops=[concat_op],
weights={},
inputs={
"input_data1": TensorConfig(data_gen=partial(generate_input1)),
"input_data2": TensorConfig(data_gen=partial(generate_input2)),
"axis_tensor_data": TensorConfig(data_gen=partial(generate_axis)),
},
outputs=["output_data"])
return program_config
def sample_program_configs(self, draw):
in_shape = draw(
st.lists(
st.integers(
min_value=1, max_value=10), min_size=4, max_size=4))
mode_data = draw(st.sampled_from(["channel", "element"]))
alpha_shape = [1]
if mode_data == "channel":
alpha_shape = [1, in_shape[1], 1, 1]
elif mode_data == 'element':
alpha_shape = [1] + list(in_shape)[1:]
def generate_input(*args, **kwargs):
return np.random.random(kwargs['tensor_shape']).astype(np.float32)
def generate_alpha(*args, **kwargs):
return np.random.random(alpha_shape).astype(np.float32)
build_ops = OpConfig(
type="prelu",
inputs={
"X": ["input_data"],
"Alpha": ['alpha_data'],
},
outputs={"Out": ["output_data"], },
attrs={"mode": mode_data, })
program_config = ProgramConfig(
ops=[build_ops],
weights={},
inputs={
"input_data": TensorConfig(data_gen=partial(
generate_input, tensor_shape=in_shape)),
"alpha_data": TensorConfig(data_gen=partial(
generate_input, tensor_shape=alpha_shape)),
},
outputs=["output_data"])
return program_config
def sample_program_configs(self, draw):
in_shape = draw(
st.lists(st.integers(min_value=1, max_value=10),
min_size=4,
max_size=4))
keep_dim = draw(st.booleans())
axis = draw(st.integers(min_value=-1, max_value=3))
assume(axis < len(in_shape))
if isinstance(axis, int):
axis = [axis]
reduce_all_data = True if axis == None or axis == [] else False
def generate_input(*args, **kwargs):
return np.random.random(in_shape).astype(np.float32)
build_ops = OpConfig(type="reduce_mean",
inputs={
"X": ["input_data"],
},
outputs={
"Out": ["output_data"],
},
attrs={
"dim": axis,
"keep_dim": keep_dim,
"reduce_all": reduce_all_data,
})
program_config = ProgramConfig(
ops=[build_ops],
weights={},
inputs={
"input_data": TensorConfig(data_gen=partial(generate_input)),
},
outputs=["output_data"])
return program_config
def sample_program_configs(draw):
input_shape = draw(
st.lists(
st.integers(
min_value=2, max_value=8), min_size=2, max_size=4))
cos_sim_op = OpConfig(
type="cos_sim",
inputs={"X": ["input1"],
"Y": ["input2"]},
outputs={
"Out": ["output"],
"XNorm": ["output_xnorm"],
"YNorm": ["output_ynorm"]
},
attrs={})
program_config = ProgramConfig(
ops=[cos_sim_op],
weights={},
inputs={
"input1": TensorConfig(shape=input_shape),
"input2": TensorConfig(shape=input_shape)
},
outputs=["output", "output_xnorm", "output_ynorm"])
return program_config
def sample_program_configs(self, draw):
in_shape = draw(
st.lists(
st.integers(
min_value=1, max_value=64), min_size=1, max_size=4))
def generate_input(*args, **kwargs):
return np.random.uniform(-1, 1, in_shape).astype(np.float32)
ops_config = OpConfig(
type="softsign",
inputs={"X": ["input_data"]},
outputs={"Out": ["output_data"]},
attrs={})
program_config = ProgramConfig(
ops=[ops_config],
weights={},
inputs={
"input_data": TensorConfig(data_gen=partial(generate_input))
},
outputs=["output_data"])
return program_config
def sample_program_configs(self, draw):
in_shape = draw(
st.lists(st.integers(min_value=1, max_value=10),
min_size=4,
max_size=4))
keep_dim = draw(st.booleans())
axis_list = draw(
st.sampled_from([[-1], [-2], [-3], [-4], [-2, -1], [-3, -2], [0],
[1], [2], [3], [0, 1], [1, 2], [2, 3]]))
reduce_all_data = True if axis_list == None or axis_list == [] else False
def generate_input(*args, **kwargs):
return np.random.random(in_shape).astype(np.float32)
build_ops = OpConfig(type="reduce_sum",
inputs={
"X": ["input_data"],
},
outputs={
"Out": ["output_data"],
},
attrs={
"dim": axis_list,
"keep_dim": keep_dim,
"reduce_all": reduce_all_data,
"out_dtype": 5,
})
program_config = ProgramConfig(
ops=[build_ops],
weights={},
inputs={
"input_data": TensorConfig(data_gen=partial(generate_input)),
},
outputs=["output_data"])
return program_config
def sample_program_configs(draw):
in_shape = draw(
st.lists(st.integers(min_value=1, max_value=64),
min_size=4,
max_size=4))
group = draw(st.integers(min_value=1, max_value=10))
assume(in_shape[1] % group == 0)
def generate_input(*args, **kwargs):
return np.random.normal(0.0, 1.0, in_shape).astype(np.float32)
ops_config = OpConfig(type="shuffle_channel",
inputs={"X": ["input_data"]},
outputs={"Out": ["output_data"]},
attrs={"group": group})
program_config = ProgramConfig(
ops=[ops_config],
weights={},
inputs={"input_data": TensorConfig(data_gen=partial(generate_input))},
outputs=["output_data"])
return program_config
def sample_program_configs(draw):
in_shape = draw(st.lists(st.integers(min_value=1, max_value=8),
max_size=1))
sub_block = draw(st.integers(min_value=1, max_value=8))
is_scalar_condition = draw(st.booleans())
def generate_input(*args, **kwargs):
return np.random.random(in_shape).astype(np.float32)
def generate_cond(*args, **kwargs):
return np.random.random(in_shape).astype(np.bool)
conditional_block_op = OpConfig(type="conditional_block",
inputs={
"Input": ["input_data"],
"Cond": ["cond_data"],
},
outputs={
"Out": ["output_data"],
"Scope": ["scope_data"]
},
attrs={
"is_scalar_condition":
is_scalar_condition,
"sub_block": sub_block
})
program_config = ProgramConfig(
ops=[conditional_block_op],
weights={},
inputs={
"input_data": TensorConfig(data_gen=partial(generate_input)),
"cond_data": TensorConfig(data_gen=partial(generate_cond))
},
outputs=["output_data", "scope_data"])
return program_config
def sample_program_configs(self, draw):
in_shape = draw(
st.lists(st.integers(min_value=1, max_value=8),
min_size=1,
max_size=4))
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"]))
fill_zeros_like_op = OpConfig(type="fill_zeros_like",
inputs={"X": ["input_data"]},
outputs={"Out": ["output_data"]},
attrs={})
program_config = ProgramConfig(
ops=[fill_zeros_like_op],
weights={},
inputs={
"input_data":
TensorConfig(data_gen=partial(generate_input,
type=input_type,
low=-10,
high=10,
shape=in_shape))
},
outputs=["output_data"])
return program_config
def sample_program_configs(draw):
rois_shape = draw(st.sampled_from([[30, 4], [80, 4], [70, 4], [66, 4]]))
scores_shape = draw(st.sampled_from([[30, 1], [65, 1], [70, 1]]))
post_nms_topN = draw(st.integers(min_value=1, max_value=10))
lod_data = [[1, 1, 1, 1]]
def generate_rois(*args, **kwargs):
return np.random.random(rois_shape).astype(np.float32)
def generate_scores(*args, **kwargs):
return np.random.random(scores_shape).astype(np.float32)
collect_fpn_proposals_op = OpConfig(
type="collect_fpn_proposals",
inputs={
"MultiLevelRois": ["multi_level_rois_data"],
"MultiLevelScores": ["multi_level_scores_data"],
"RoisNum": ["rois_num_data"]
},
outputs={
"FpnRois": ["fpn_rois_data"],
"MultiLevelRoIsNum": ["multi_level_rois_num_data"]
},
attrs={"post_nms_topN": post_nms_topN})
program_config = ProgramConfig(
ops=[collect_fpn_proposals_op],
weights={},
inputs={
"multi_level_rois_data":
TensorConfig(data_gen=partial(generate_rois)),
"multi_level_scores_data":
TensorConfig(data_gen=partial(generate_scores)),
"rois_num_data": TensorConfig(data_gen=partial(generate_rois))
},
outputs=["fpn_rois_data", "multi_level_rois_num_data"])
return program_config
def sample_program_configs(draw):
in_shape = draw(
st.lists(st.integers(min_value=1, max_value=8), min_size=2,
max_size=4))
def generate_input_int32(*args, **kwargs):
return np.random.random(in_shape).astype(np.int32)
def generate_input_int64(*args, **kwargs):
return np.random.random(in_shape).astype(np.int64)
def generate_input_float32(*args, **kwargs):
return np.random.random(in_shape).astype(np.float32)
input_type = draw(
st.sampled_from([
generate_input_int32, generate_input_int64, generate_input_float32
]))
axis = draw(st.integers(min_value=0, max_value=len(in_shape) - 1))
flatten2_op = OpConfig(type="flatten2",
inputs={"X": ["input_data"]},
outputs={
"Out": ["output_data"],
"XShape": ["xshape_data"]
},
attrs={"axis": axis})
program_config = ProgramConfig(
ops=[flatten2_op],
weights={"xshape_data": TensorConfig(shape=in_shape)},
inputs={"input_data": TensorConfig(data_gen=partial(input_type))},
outputs=["output_data", "xshape_data"])
return program_config
def sample_program_configs(self, 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(*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"]
if dtype == 2:
input_type = "int32"
elif dtype == 3:
input_type = "int64"
else:
input_type = "float32"
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(generate_input,
type=input_type,
low=-10,
high=10,
shape=[1])),
"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(generate_input,
type=input_type,
low=-10,
high=10,
shape=[1]))
}
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
})
program_config = ProgramConfig(ops=[fill_constant_op],
weights={},
inputs=program_inputs,
outputs=["output_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=4, max_size=4))
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.integers(
min_value=0,
max_value=max(strides[0], dilations[0]) - 1)), draw(
st.integers(
min_value=0,
max_value=max(strides[1], dilations[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))
scale = draw(st.floats(min_value=0.5, max_value=5))
scale_bias = draw(st.floats(min_value=0.0, max_value=1.0))
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)
use_mkldnn = False
if self.target[0] == "X86":
use_mkldnn = True
use_mkldnn = True
inputs_type = {"Input": ["input_data"], "Filter": ["filter_data"]}
weights_data = {"filter_data": TensorConfig(shape=weight_shape)}
if use_mkldnn:
inputs_type["Bias"] = ["bias_data"]
weights_data["bias_data"] = TensorConfig(shape=[weight_shape[0]])
conv_type = "conv2d"
conv_attrs = {
"data_format": 'nchw',
"dilations": dilations,
"use_mkldnn": use_mkldnn,
"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=inputs_type,
outputs={"Output": ["conv_output_data"]},
attrs=conv_attrs)
scale_op = OpConfig(
type="scale",
inputs={"X": ["conv_output_data"]},
outputs={"Out": ["output_data"]},
attrs={
"scale": scale,
"bias": scale_bias,
"bias_after_scale": True
})
ops = [conv_op, scale_op]
self.ops = ops
program_config = ProgramConfig(
ops=ops,
weights=weights_data,
inputs={"input_data": TensorConfig(shape=in_shape)},
outputs=["output_data"])
return program_config
def sample_program_config(self, draw):
x_col = draw(st.sampled_from([1]))
y_col = draw(st.sampled_from([1]))
activation = draw(st.sampled_from(['sigmoid', 'tanh']))
is_reverse = draw(st.booleans())
has_origin_mode = draw(st.booleans())
origin_mode = False
gate_activation = draw(st.sampled_from(['sigmoid', 'tanh']))
batch_size = draw(st.integers(min_value=1, max_value=40))
def generate_input():
shape = [batch_size, 128, 6, 120]
return np.full(shape, 0.001).astype(np.float32)
def generate_weight(shape):
return np.full(shape, 0.0001).astype(np.float32)
im2sequence_op = OpConfig(type="im2sequence",
inputs={"X": ["input_data"]},
outputs={"Out": ["seq_out"]},
attrs={
"kernels": [6, 1],
"out_stride": [1, 1],
"paddings": [0, 0, 0, 0],
"strides": [1, 1]
})
mul_op = OpConfig(type="mul",
inputs={
"X": ["seq_out"],
"Y": ["mul_weight"]
},
outputs={"Out": ["mul_out"]},
attrs={
"x_num_col_dims": x_col,
"y_num_col_dims": y_col
})
if has_origin_mode:
gru_op = OpConfig(type="gru",
inputs={
"Input": ["mul_out"],
"Weight": ["gru_weight"],
"Bias": ["gru_bias"]
},
outputs={
"BatchGate": ["batch_gate"],
"BatchHidden": ["batch_hidden"],
"BatchResetHiddenPrev": ["batch_reset"],
"Hidden": ["hidden"]
},
attrs={
'activation': activation,
'is_reverse': is_reverse,
'gate_activation': gate_activation,
'is_test': True,
'origin_mode': origin_mode
})
else:
gru_op = OpConfig(type="gru",
inputs={
"Input": ["mul_out"],
"Weight": ["gru_weight"],
"Bias": ["gru_bias"]
},
outputs={
"BatchGate": ["batch_gate"],
"BatchHidden": ["batch_hidden"],
"BatchResetHiddenPrev": ["batch_reset"],
"Hidden": ["hidden"]
},
attrs={
'activation': activation,
'is_reverse': is_reverse,
'gate_activation': gate_activation,
'is_test': True
})
model_net = [im2sequence_op, mul_op, gru_op]
program_config = ProgramConfig(
ops=model_net,
weights={
"mul_weight":
TensorConfig(data_gen=partial(generate_weight, [768, 600])),
"gru_weight":
TensorConfig(data_gen=partial(generate_weight, [200, 600])),
"gru_bias":
TensorConfig(data_gen=partial(generate_weight, [1, 600]))
},
inputs={
"input_data": TensorConfig(data_gen=partial(generate_input))
},
outputs=["hidden"])
return program_config
def sample_program_configs(self, draw):
in_shape = draw(
st.lists(
st.integers(
min_value=4, max_value=4), min_size=2, max_size=2))
axis = draw(st.integers(min_value=0, max_value=len(in_shape) - 1))
index = draw(
st.sampled_from([[0], [2], [3], [1, 2], [1, 2, 3], [
in_shape[axis] - 1
], [in_shape[axis] - 2, in_shape[axis] - 1]]))
axis_type = draw(st.sampled_from(["int32", "int64"]))
index_type = draw(st.sampled_from(["int32", "int64"]))
with_tenor_axis = draw(st.booleans())
input_type = draw(st.sampled_from(["float32", "int64", "int32"]))
if self.get_target() == "OpenCL":
axis_type = "int32"
index_type = "int32"
input_type = "float32"
with_tenor_axis = True
def generate_axis(*args, **kwargs):
if axis_type == "int32":
return np.array([axis]).astype(np.int32)
else:
return np.array([axis]).astype(np.int64)
def generate_index(*args, **kwargs):
if index_type == "int32":
return np.array(index).astype(np.int32)
else:
return np.array(index).astype(np.int64)
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"]
op_inputs = {}
program_inputs = {}
if (with_tenor_axis):
op_inputs = {
"X": ["input_data"],
"Index": ["index_data"],
"Axis": ["axis_data"]
}
program_inputs = {
"input_data": TensorConfig(data_gen=partial(
generate_input,
type=input_type,
low=-10,
high=10,
shape=in_shape)),
"index_data": TensorConfig(data_gen=partial(generate_index)),
"axis_data": TensorConfig(data_gen=partial(generate_axis))
}
else:
op_inputs = {"X": ["input_data"], "Index": ["index_data"]}
program_inputs = {
"input_data": TensorConfig(data_gen=partial(
generate_input,
type=input_type,
low=-10,
high=10,
shape=in_shape)),
"index_data": TensorConfig(data_gen=partial(generate_index))
}
gather_op = OpConfig(
type="gather",
inputs=op_inputs,
outputs={"Out": ["output_data"]},
attrs={"axis": axis})
gather_op.outputs_dtype = {"output_data": input_type}
program_config = ProgramConfig(
ops=[gather_op],
weights={},
inputs=program_inputs,
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))]))
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=conv_type,
inputs={
"Input": ["input_data"],
"Filter": ["weight_data"]
},
outputs={"Output": ["conv_output_data"]},
attrs=conv_attrs)
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)}
active_op = OpConfig(type="conv2d_transpose",
inputs={
"data_format": 'nchw',
"dilations": dilations,
"padding_algorithm": padding_algorithm,
"groups": groups,
"paddings": paddings,
"strides": strides,
"output_size": [],
"output_padding": output_padding
},
outputs={"Out": ["output_data"]},
attrs=generate_act_attrs(act_type))
ops = [conv_op, active_op]
program_config = ProgramConfig(
ops=ops,
weights={"weight_data": TensorConfig(shape=weight_shape)},
inputs=inputs_data,
outputs=["output_data"])
return program_config
def sample_program_configs(self, draw):
in_shape = draw(
st.lists(st.integers(min_value=1, max_value=8),
min_size=1,
max_size=6))
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(["int32", "int64", "float32"]))
has_scale_tensor = False # 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
input_dict = {"X": ["input_data"]}
input_data_dict = {
"input_data":
TensorConfig(data_gen=partial(
generate_data, dtype=input_type, shape=in_shape))
}
if has_scale_tensor:
input_dict["ScaleTensor"] = "scale_tensor_data"
input_data_dict["scale_tensor_data"] = TensorConfig(shape=[
1,
])
scale_op = OpConfig(type="scale",
inputs=input_dict,
outputs={"Out": ["output_data"]},
attrs={
"bias": bias,
"bias_after_scale": bias_after_scale,
"scale": scale
})
program_config = ProgramConfig(ops=[scale_op],
weights={},
inputs=input_data_dict,
outputs=["output_data"])
return program_config
def sample_program_configs(self, draw):
in_shape = draw(
st.lists(st.integers(min_value=16, max_value=32),
min_size=4,
max_size=4))
in_shape[0] = 1
anchor_sizes = draw(
st.sampled_from([[32.0], [32.0, 64.0], [64.0, 128.0],
[32.0, 64.0, 128.0]]))
aspect_ratios = draw(
st.sampled_from([[1.0], [1.0, 2.0], [0.5, 1.0, 2.0]]))
variances = draw(
st.lists(st.floats(min_value=0.5, max_value=1.5),
min_size=4,
max_size=4))
stride = draw(
st.sampled_from([[16.0, 16.0], [24.0, 24.0], [16.0, 24.0]]))
pixel_offset = draw(st.booleans())
num_anchors = len(anchor_sizes) * len(aspect_ratios)
anchor_generator_op = OpConfig(type="anchor_generator",
inputs={"Input": ["input_data"]},
outputs={
"Anchors": ["anchors_data"],
"Variances": ["variance_data"]
},
attrs={
"anchor_sizes": anchor_sizes,
"aspect_ratios": aspect_ratios,
"stride": stride,
"variances": variances,
"offset": 0.5
})
scores_shape = [in_shape[0], num_anchors, in_shape[2], in_shape[3]]
bbox_delta_shape = [
scores_shape[0], scores_shape[1] * 4, scores_shape[2],
scores_shape[3]
]
pre_nms_topN = draw(st.integers(min_value=2000, max_value=8000))
post_nms_topN = draw(st.integers(min_value=1000, max_value=1500))
nms_thresh = draw(st.floats(min_value=0.5, max_value=0.8))
min_size = draw(st.floats(min_value=2, max_value=4))
eta = draw(st.floats(min_value=0.5, max_value=1.5))
def generate_im_shape(*args, **kwargs):
return np.array(
[[in_shape[2] * stride[0],
in_shape[3] * stride[1]]]).astype(np.float32)
generate_proposals_v2_op = OpConfig(type="generate_proposals_v2",
inputs={
"Scores": ["scores_data"],
"BboxDeltas":
["bbox_delta_data"],
"ImShape": ["im_shape_data"],
"Anchors": ["anchors_data"],
"Variances": ["variance_data"]
},
outputs={
"RpnRois": ["rpn_rois_data"],
"RpnRoiProbs":
["rpn_rois_probs_data"],
"RpnRoisNum":
["rpn_rois_num_data"]
},
attrs={
"pre_nms_topN": pre_nms_topN,
"post_nms_topN": post_nms_topN,
"nms_thresh": nms_thresh,
"min_size": min_size,
"eta": eta,
"pixel_offset": pixel_offset
})
program_config = ProgramConfig(
ops=[anchor_generator_op, generate_proposals_v2_op],
weights={},
inputs={
"input_data": TensorConfig(shape=in_shape),
"scores_data": TensorConfig(shape=scores_shape),
"bbox_delta_data": TensorConfig(shape=bbox_delta_shape),
"im_shape_data":
TensorConfig(data_gen=partial(generate_im_shape))
},
outputs=[
"rpn_rois_data", "rpn_rois_probs_data", "rpn_rois_num_data"
])
return program_config
def sample_program_configs(draw):
in_shape = draw(
st.lists(
st.integers(
min_value=5, max_value=8), min_size=4, max_size=4))
starts_data = draw(
st.lists(
st.integers(
min_value=0, max_value=2), min_size=1, max_size=4))
ends_data = draw(
st.lists(
st.integers(
min_value=3, max_value=4), min_size=1, max_size=4))
strides_data = draw(
st.lists(
st.integers(
min_value=1, max_value=1), min_size=1, max_size=4))
axes_data = draw(
st.lists(
st.integers(
min_value=0, max_value=3), min_size=1, max_size=4))
# whether this axis for runtime calculations
infer_flags_data = draw(
st.lists(
st.integers(
min_value=1, max_value=1), min_size=1, max_size=4))
assume(len(starts_data) == len(ends_data))
assume(len(ends_data) == len(strides_data))
assume(len(strides_data) == len(axes_data))
assume(len(axes_data) == len(infer_flags_data))
def generate_StartsTensorList_data():
return np.array(starts_data).astype("int32")
def generate_EndsTensorList_data():
return np.array(ends_data).astype("int32")
def generate_StridesTensorList_data():
return np.array(strides_data).astype("int32")
def generate_StartsTensor_data():
return np.array(starts_data).astype("int32")
def generate_EndsTensor_data():
return np.array(ends_data).astype("int32")
def generate_StridesTensor_data():
return np.array(strides_data).astype("int32")
strideslice_op = OpConfig(
type="strided_slice",
inputs={"Input": ["input_data"]},
outputs={"Out": ["output_data"]},
attrs={
"starts": starts_data,
"ends": ends_data,
"strides": strides_data,
"axes": axes_data,
"infer_flags": infer_flags_data,
"decrease_axis": []
})
program_config = ProgramConfig(
ops=[strideslice_op],
weights={},
inputs={
"input_data": TensorConfig(shape=in_shape),
"StartsTensorList_data":
TensorConfig(data_gen=partial(generate_EndsTensorList_data)),
"EndsTensorList_data":
TensorConfig(data_gen=partial(generate_StartsTensorList_data)),
"StridesTensorList_data":
TensorConfig(data_gen=partial(generate_StridesTensorList_data)),
"StartsTensor_data":
TensorConfig(data_gen=partial(generate_EndsTensor_data)),
"EndsTensor_data":
TensorConfig(data_gen=partial(generate_StartsTensor_data)),
"StridesTensor_data":
TensorConfig(data_gen=partial(generate_StridesTensor_data)),
},
outputs=["output_data"])
return program_config
def sample_program_configs(draw, interp_type):
interpolate_type = draw(
st.sampled_from(['interpolate_type_1', 'interpolate_type_2']))
if interpolate_type == "interpolate_type_1":
#shape params
shape_op_input_shape = draw(
st.lists(st.integers(min_value=2, max_value=10),
min_size=4,
max_size=4)) #min_value=1, Output has nan
#slice params
axes = [0]
starts = [2]
ends = [4]
infer_flags = [1]
#cast params
cast_op_in_dtype = draw(st.sampled_from([2, 3])) #float type has diff
cast_op_out_dtype = draw(st.sampled_from(
[2])) #bilinear_interp's OutSize must be int
#fill_constant_op params
fill_constant_in_shape = draw(
st.lists(st.integers(min_value=1, max_value=2),
min_size=1,
max_size=1))
fill_constant_value = draw(st.integers(
min_value=3, max_value=3)) #1 2 3 is ok, other has diff
#bilinear_interp params
scale = draw(st.floats(min_value=0.1, max_value=0.9))
align_corners = draw(st.booleans())
align_mode = draw(st.sampled_from([0, 1]))
if interp_type == "bilinear_interp":
interp_method = "bilinear"
else:
interp_method = "nearest"
def generate_input(*args, **kwargs):
return np.random.random(shape_op_input_shape).astype(np.float32)
shape_op = OpConfig(type="shape",
inputs={"Input": ["input_data"]},
outputs={"Out": ["shape_out"]},
attrs={})
slice_op = OpConfig(type="slice",
inputs={"Input": ["shape_out"]},
outputs={"Out": ["slice_out"]},
attrs={
"axes": axes,
"starts": starts,
"ends": ends,
"decrease_axis": [],
"infer_flags": infer_flags
})
cast_op = OpConfig(type="cast",
inputs={"X": ["slice_out"]},
outputs={"Out": ["cast_out"]},
attrs={
"in_dtype": cast_op_in_dtype,
"out_dtype": cast_op_out_dtype
})
fill_constant_op = OpConfig(
type="fill_constant",
inputs={}, #Only when the input is empty can the fusion succeed
outputs={"Out": ["fill_constant_output"]},
attrs={
"dtype": cast_op_out_dtype,
"shape": fill_constant_in_shape,
"value": float(
fill_constant_value
), #The value of the floating point number must be an integer, otherwise out has diff
"force_cpu": False
})
elementwise_mul_op = OpConfig(type="elementwise_mul",
inputs={
"X": ["fill_constant_output"],
"Y": ["cast_out"]
},
outputs={"Out": ["elementwise_mul_out"]},
attrs={"axis": -1})
interpolate_op = OpConfig(
type=interp_type,
inputs={
"X": ["input_data"],
"OutSize": ["elementwise_mul_out"]
}, #OutSize's dimension[0] must be 2
outputs={"Out": ["output_data"]},
attrs={
"data_layout": "NCHW",
"scale": scale,
"interp_method": interp_method,
"align_corners": align_corners,
"align_mode": align_mode
})
ops = [
fill_constant_op, shape_op, slice_op, cast_op, elementwise_mul_op,
interpolate_op
]
program_config = ProgramConfig(
ops=ops,
weights={},
inputs={
"input_data": TensorConfig(data_gen=partial(generate_input))
},
outputs=["output_data"])
return program_config
else:
#shape params
shape_op_input_shape = draw(
st.lists(st.integers(min_value=2, max_value=10),
min_size=4,
max_size=4)) #min_value=1, Output has nan
#slice params
axes = [0]
starts = [2]
ends = [4]
infer_flags = [1]
#cast params
cast_op_in_dtype = draw(st.sampled_from([2, 3])) #float type has diff
cast_op_out_dtype = draw(st.sampled_from(
[2])) #bilinear_interp's OutSize must be int
#scale op params
scale = draw(st.floats(min_value=3,
max_value=3)) #1 2 3 is ok, other has diff
bias = draw(st.floats(min_value=0, max_value=1))
bias_after_scale = draw(st.sampled_from([False])) #required in pass
#bilinear_interp params
# scale = draw(st.floats(min_value=0.1, max_value=0.9))
align_corners = draw(st.booleans())
align_mode = draw(st.sampled_from([0, 1]))
if interp_type == "bilinear_interp":
interp_method = "bilinear"
else:
interp_method = "nearest"
def generate_input(*args, **kwargs):
return np.random.random(shape_op_input_shape).astype(np.float32)
shape_op = OpConfig(type="shape",
inputs={"Input": ["input_data"]},
outputs={"Out": ["shape_out"]},
attrs={})
slice_op = OpConfig(type="slice",
inputs={"Input": ["shape_out"]},
outputs={"Out": ["slice_out"]},
attrs={
"axes": axes,
"starts": starts,
"ends": ends,
"decrease_axis": [],
"infer_flags": infer_flags
})
cast_op = OpConfig(type="cast",
inputs={"X": ["slice_out"]},
outputs={"Out": ["cast_out"]},
attrs={
"in_dtype": cast_op_in_dtype,
"out_dtype": cast_op_out_dtype
})
scale_op = OpConfig(type="scale",
inputs={"X": ["cast_out"]},
outputs={"Out": ["scale_output"]},
attrs={
"scale": scale,
"bias": bias,
"bias_after_scale": bias_after_scale
})
interpolate_op = OpConfig(
type=interp_type,
inputs={
"X": ["input_data"],
"OutSize": ["scale_output"]
}, #OutSize's dimension[0] must be 2
outputs={"Out": ["output_data"]},
attrs={
"data_layout": "NCHW",
"scale":
scale, #only interpolate_scale == scale_op_scale, out is ok, else out has diff
"interp_method": interp_method,
"align_corners": align_corners,
"align_mode": align_mode
})
ops = [shape_op, slice_op, cast_op, scale_op, interpolate_op]
program_config = ProgramConfig(
ops=ops,
weights={},
inputs={
"input_data": TensorConfig(data_gen=partial(generate_input))
},
outputs=["output_data"])
return program_config
def sample_program_configs(self, draw):
N = draw(st.integers(min_value=1, max_value=4))
C = draw(st.integers(min_value=1, max_value=128))
H = draw(st.integers(min_value=1, max_value=128))
W = draw(st.integers(min_value=1, max_value=128))
in_shape = draw(st.sampled_from([[N, C, H, W]]))
in_dtype = np.float32
target = self.get_target()
if (target in ["X86", "ARM"]):
in_dtype = draw(st.sampled_from([np.float32, np.int32, np.int64]))
elif (target in ["OpenCL", "Metal"]):
in_dtype = draw(st.sampled_from([np.float32]))
def generate_X_data():
return np.random.normal(0.0, 5.0, in_shape).astype(in_dtype)
axes_data = draw(
st.lists(st.integers(min_value=0, max_value=3),
min_size=1,
max_size=2))
inputs = {"X": ["X_data"]}
choose_axes = draw(
st.sampled_from(["axes", "AxesTensor", "AxesTensorList"]))
def generate_AxesTensor_data():
if (choose_axes == "AxesTensor"):
inputs["AxesTensor"] = ["AxesTensor_data"]
return np.array(axes_data).astype(np.int32)
else:
return np.random.randint(1, 5, []).astype(np.int32)
def generate_AxesTensorList_data():
if (choose_axes == "AxesTensorList"):
#inputs["AxesTensorList"] = ["AxesTensorList_data"]
return np.array(axes_data).astype(np.int32)
else:
return np.random.randint(1, 5, []).astype(np.int32)
def generate_XShape_data():
return np.random.random([6]).astype(np.float32)
unsqueeze2_op = OpConfig(type="unsqueeze2",
inputs=inputs,
outputs={
"Out": ["Out_data"],
"XShape": ["XShape_data"]
},
attrs={
"axes": axes_data,
})
unsqueeze2_op.outputs_dtype = {"Out_data": in_dtype}
program_config = ProgramConfig(
ops=[unsqueeze2_op],
weights={
"XShape_data":
TensorConfig(data_gen=partial(generate_XShape_data))
},
inputs={
"X_data":
TensorConfig(data_gen=partial(generate_X_data)),
"AxesTensor_data":
TensorConfig(data_gen=partial(generate_AxesTensor_data)),
"AxesTensorList_data":
TensorConfig(data_gen=partial(generate_AxesTensorList_data))
},
outputs=["Out_data"])
# OpenCL Check failed so remove "XShape_data"
return program_config
def sample_program_configs(draw):
priorbox_shape = draw(st.sampled_from([[30, 4], [80, 4], [70, 4], [66,
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)
box_coder_op = OpConfig(type="box_coder",
inputs={
"PriorBox": ["priorbox_data"],
"TargetBox": ["targetbox_data"],
"PriorBoxVar": ["priorbox_var_data"]
},
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={
"priorbox_data":
TensorConfig(data_gen=partial(generate_priorbox), lod=lod_data),
"priorbox_var_data":
TensorConfig(data_gen=partial(generate_priorbox_var)),
"targetbox_data":
TensorConfig(data_gen=partial(generate_targetbox), lod=lod_data),
},
outputs=["outputbox_data"])
return program_config
def sample_program_config(self, draw):
# 1. Generate shape of input:X of conv2d
x_shape = draw(
st.lists(st.integers(min_value=1, max_value=100),
min_size=4,
max_size=4))
x_shape[1] = draw(st.integers(min_value=1, max_value=10))
# 2. Generate legal attr:data_format of conv2d
data_format = draw(st.sampled_from(["NCHW", "NHWC"]))
# 3. Generate legal shape of input:Y of conv2d
f_shape = draw(
st.lists(st.integers(min_value=1, max_value=7),
min_size=4,
max_size=4))
if data_format == "NCHW":
f_shape[1] = x_shape[1]
else:
f_shape[1] = x_shape[3]
# 4. Generate legal attr:strides of conv2d
strides = draw(
st.lists(st.integers(min_value=1, max_value=5),
min_size=2,
max_size=2))
# 5. Generate legal attr:padding_algorithm of conv2d
padding_algorithm = draw(st.sampled_from(["EXPLICIT", "SAME",
"VALID"]))
# 6. Generate legal attr:padding of conv2d
padding = draw(
st.lists(st.integers(min_value=1, max_value=5),
min_size=4,
max_size=4))
# 7. Generate legal attr:groups of conv2d
groups = draw(st.integers(min_value=1, max_value=3))
# 8. Generate legal attr:dilations of conv2d
dilations = draw(
st.lists(st.integers(min_value=1, max_value=5),
min_size=2,
max_size=2))
# 9. Generate legal input:ResidualData of conv2d
res_shape = []
if draw(st.booleans()):
res_shape = draw(
st.lists(st.integers(min_value=1, max_value=100),
min_size=4,
max_size=4))
# 10. Generate legal shape of input:bias of elementwise_add
bias_shape = [f_shape[0]]
# 11. Generate legal attr:axis of elementwise_add
axis = 1
conv2d_op = OpConfig("conv2d",
inputs={
"Input": ["input_x"],
"Filter": ["filter"],
"ResidualData": ["residualdata"]
},
outputs={"Output": ["conv2d_out"]},
strides=strides,
padding_algorithm=padding_algorithm,
paddings=padding,
groups=groups,
dilations=dilations,
data_format=data_format)
add_op = OpConfig("elementwise_add",
inputs={
"X": ["conv2d_out"],
"Y": ["bias"]
},
outputs={"Out": ["add_out"]},
axis=axis)
relu_op = OpConfig("relu",
inputs={"X": ["add_out"]},
outputs={"Out": ["relu_out"]})
ops = [conv2d_op, add_op, relu_op]
program_config = ProgramConfig(
ops=ops,
weights={
"filter": TensorConfig(shape=f_shape),
"bias": TensorConfig(shape=bias_shape),
},
inputs={
"input_x": TensorConfig(shape=x_shape),
"residualdata": TensorConfig(shape=res_shape)
},
outputs=ops[-1].outputs["Out"],
)
return program_config
def sample_program_configs(self, draw):
in_shape = draw(
st.lists(st.integers(min_value=1, max_value=64),
min_size=4,
max_size=4))
kw = np.random.randint(1, 9)
kh = np.random.randint(1, 9)
cout = np.random.randint(1, 128)
cin = np.random.randint(1, 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))
weight_shape = [cout, cin, kh, kw]
groups = draw(st.sampled_from([1, 2, cin]))
val = in_shape[1] * groups
assume(val == cin)
assume(in_shape[1] == weight_shape[1])
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"
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)
conv_op = OpConfig(type="conv2d",
inputs={
"Input": ["input_data"],
"Filter": ["filter_data"],
"Bias": ["bias_data"]
},
outputs={"Output": ["output_data"]},
attrs={
"strides": strides,
"paddings": paddings,
"use_mkldnn": True,
"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)),
"bias_data": TensorConfig(data_gen=partial(generate_bias))
},
inputs={
"input_data": TensorConfig(data_gen=partial(generate_input))
},
outputs=["output_data"])
return program_config
def sample_program_configs(draw):
density_prior_box_or_prior_box_op = draw(
st.sampled_from(["prior_box", "density_prior_box"]))
reshape_or_flatten_op_type = draw(
st.sampled_from(["reshape2", "flatten", "flatten2"]))
#image params
batch_size = draw(st.integers(min_value=1, max_value=4))
image_channels = draw(st.integers(min_value=1, max_value=10))
image_w = draw(st.integers(min_value=1, max_value=160))
image_h = draw(st.integers(min_value=1, max_value=160))
density_prior_box_layer1_channels = draw(
st.integers(min_value=1, max_value=32))
density_prior_box_layer1_w = draw(st.integers(min_value=1, max_value=40))
density_prior_box_layer1_h = draw(st.integers(min_value=1, max_value=40))
density_prior_box_layer2_channels = draw(
st.integers(min_value=1, max_value=64))
density_prior_box_layer2_w = draw(st.integers(min_value=1, max_value=32))
density_prior_box_layer2_h = draw(st.integers(min_value=1, max_value=32))
assume(density_prior_box_layer1_h < image_h)
assume(density_prior_box_layer2_h < image_h)
assume(density_prior_box_layer1_w < image_w)
assume(density_prior_box_layer2_w < image_w)
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]))
flip = draw(st.sampled_from([True, False]))
clip = draw(st.sampled_from([True, False]))
variances = draw(
st.lists(st.floats(min_value=0.001, max_value=1),
min_size=4,
max_size=4))
value = draw(st.floats(min_value=0, 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 = draw(st.floats(min_value=0, max_value=1))
offset_2 = draw(st.floats(min_value=0, max_value=1))
if density_prior_box_or_prior_box_op == "prior_box":
# min_sizes = [2.0, 4.0]
# max_sizes = [5.0, 10.0]
# aspect_ratios = [2.0, 3.0]
min_sizes_int = draw(
st.lists(st.integers(min_value=1, max_value=4),
min_size=1,
max_size=4))
max_sizes_int = draw(
st.lists(st.integers(min_value=5, max_value=10),
min_size=1,
max_size=4))
assume(len(min_sizes_int) == len(max_sizes_int))
min_sizes = []
max_sizes = []
for i in min_sizes_int:
min_sizes.append(float(i))
for i in max_sizes_int:
max_sizes.append(float(i))
aspect_ratios = draw(
st.lists(st.floats(min_value=0.1, max_value=3),
min_size=1,
max_size=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)
num_priors_2 = len(output_aspect_ratior) * len(min_sizes)
num_priors_2 += len(max_sizes)
else:
fixed_sizes_1 = draw(
st.lists(st.floats(min_value=2, max_value=32),
min_size=3,
max_size=3))
densities_1 = draw(
st.lists(st.integers(min_value=1, max_value=2),
min_size=3,
max_size=3))
fixed_ratios_1 = draw(
st.lists(st.floats(min_value=1, max_value=1),
min_size=1,
max_size=1))
fixed_sizes_2 = draw(
st.lists(st.floats(min_value=2, max_value=32),
min_size=2,
max_size=2))
densities_2 = draw(
st.lists(st.integers(min_value=1, max_value=2),
min_size=2,
max_size=2))
fixed_ratios_2 = draw(
st.lists(st.floats(min_value=1, max_value=1),
min_size=1,
max_size=1))
#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))
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_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
]
#reshape2 params
reshape2_w = draw(st.integers(min_value=4, max_value=4))
#box_coder params
code_type = draw(
st.sampled_from(["decode_center_size", "encode_center_size"])) #must
axis = draw(st.sampled_from([0, 1])) #must 0, else has diff
box_normalized = True #box coder opencl kernel required
variance = draw(st.sampled_from([[0.1, 0.2, 0.3, 0.4], []]))
lod_data = [[1, 1, 1, 1, 1]]
assume(priorbox_shape[0] < 16384)
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)
if density_prior_box_or_prior_box_op == "prior_box":
density_prior_box_or_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_or_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
})
else:
density_prior_box_or_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,
"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_or_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,
"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
})
if reshape_or_flatten_op_type == "reshape2":
reshape_or_flatten_op_1 = OpConfig(
type="reshape2",
inputs={"X": ["density_prior_box_output_boxes_1"]},
outputs={
"Out": ["reshape_or_flatten_out_1"],
"XShape": ["reshape2_xshape_1"]
},
attrs={"shape": [-1, reshape2_w]})
reshape_or_flatten_op_2 = OpConfig(
type="reshape2",
inputs={"X": ["density_prior_box_output_boxes_2"]},
outputs={
"Out": ["reshape_or_flatten_out_2"],
"XShape": ["reshape2_xshape_2"]
},
attrs={"shape": [-1, reshape2_w]})
reshape_or_flatten_op_3 = OpConfig(
type="reshape2",
inputs={"X": ["density_prior_box_output_variances_1"]},
outputs={
"Out": ["reshape_or_flatten_out_3"],
"XShape": ["reshape2_xshape_3"]
},
attrs={"shape": [-1, reshape2_w]})
reshape_or_flatten_op_4 = OpConfig(
type="reshape2",
inputs={"X": ["density_prior_box_output_variances_2"]},
outputs={
"Out": ["reshape_or_flatten_out_4"],
"XShape": ["reshape2_xshape_4"]
},
attrs={"shape": [-1, reshape2_w]})
elif reshape_or_flatten_op_type == "flatten":
reshape_or_flatten_op_1 = OpConfig(
type="flatten",
inputs={"X": ["density_prior_box_output_boxes_1"]},
outputs={"Out": ["reshape_or_flatten_out_1"]},
attrs={
"axis": 3,
})
reshape_or_flatten_op_2 = OpConfig(
type="flatten",
inputs={"X": ["density_prior_box_output_boxes_2"]},
outputs={"Out": ["reshape_or_flatten_out_2"]},
attrs={
"axis": 3,
})
reshape_or_flatten_op_3 = OpConfig(
type="flatten",
inputs={"X": ["density_prior_box_output_variances_1"]},
outputs={"Out": ["reshape_or_flatten_out_3"]},
attrs={
"axis": 3,
})
reshape_or_flatten_op_4 = OpConfig(
type="flatten",
inputs={"X": ["density_prior_box_output_variances_2"]},
outputs={"Out": ["reshape_or_flatten_out_4"]},
attrs={
"axis": 3,
})
else:
reshape_or_flatten_op_1 = OpConfig(
type="flatten2",
inputs={"X": ["density_prior_box_output_boxes_1"]},
outputs={
"Out": ["reshape_or_flatten_out_1"],
"XShape": ["reshape_or_flatten_xshape_1"]
},
attrs={
"axis": 3,
})
reshape_or_flatten_op_2 = OpConfig(
type="flatten2",
inputs={"X": ["density_prior_box_output_boxes_2"]},
outputs={
"Out": ["reshape_or_flatten_out_2"],
"XShape": ["reshape_or_flatten_xshape_2"]
},
attrs={
"axis": 3,
})
reshape_or_flatten_op_3 = OpConfig(
type="flatten2",
inputs={"X": ["density_prior_box_output_variances_1"]},
outputs={
"Out": ["reshape_or_flatten_out_3"],
"XShape": ["reshape_or_flatten_xshape_3"]
},
attrs={
"axis": 3,
})
reshape_or_flatten_op_4 = OpConfig(
type="flatten2",
inputs={"X": ["density_prior_box_output_variances_2"]},
outputs={
"Out": ["reshape_or_flatten_out_4"],
"XShape": ["reshape_or_flatten_xshape_4"]
},
attrs={
"axis": 3,
})
axis_1 = draw(st.sampled_from([0]))
axis_2 = draw(st.sampled_from([0]))
concat_op_1 = OpConfig(
type="concat",
inputs={"X": ["reshape_or_flatten_out_1", "reshape_or_flatten_out_2"]},
outputs={"Out": ["concat_out_1"]},
attrs={"axis": axis_1})
concat_op_2 = OpConfig(
type="concat",
inputs={"X": ["reshape_or_flatten_out_3", "reshape_or_flatten_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_or_prior_box_op_1,
density_prior_box_or_prior_box_op_2, reshape_or_flatten_op_1,
reshape_or_flatten_op_2, reshape_or_flatten_op_3,
reshape_or_flatten_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):
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
channels = draw(st.integers(min_value=1, max_value=64))
batch = draw(st.integers(min_value=1, max_value=4))
if target_str == "ARM" or target_str == "X86" or target_str == "NNAdapter":
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))
channels = draw(st.integers(min_value=1, max_value=64))
batch = draw(st.integers(min_value=1, max_value=4))
if target_str == "Metal":
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))
channels = draw(st.integers(min_value=1, max_value=64))
batch = draw(st.integers(min_value=1, max_value=4))
transpose_X = draw(st.booleans())
transpose_Y = draw(st.booleans())
len_X = draw(st.integers(min_value=1, max_value=4))
len_Y = draw(st.integers(min_value=1, max_value=4))
assume((len_X == 1 and len_Y == 1) or (len_X == 2 and len_Y == 2)
or (len_X == 4 and len_Y == 4) or (len_X == 4 and len_Y == 2)
or (len_X == 4 and len_Y == 1) or (len_X == 3 and len_Y == 3)
or (len_X == 3 and len_Y == 2) or (len_X == 3 and len_Y == 1))
if (len_X == 1 and len_Y == 1):
X_shape = [shape0]
Y_shape = [shape0]
assume(transpose_X == transpose_Y)
if (len_X == 2 and len_Y == 2):
if ((not transpose_X) and (not transpose_Y)):
X_shape = [shape0, shape1]
Y_shape = [shape1, shape2]
if ((transpose_X) and (not transpose_Y)):
X_shape = [shape1, shape0]
Y_shape = [shape1, shape2]
if ((not transpose_X) and (transpose_Y)):
X_shape = [shape0, shape1]
Y_shape = [shape2, shape1]
if ((transpose_X) and (transpose_Y)):
X_shape = [shape1, shape0]
Y_shape = [shape2, shape1]
if (len_X == 4 and len_Y == 4):
if ((not transpose_X) and (not transpose_Y)):
X_shape = [batch, channels, shape0, shape1]
Y_shape = [batch, channels, shape1, shape2]
if ((transpose_X) and (not transpose_Y)):
X_shape = [batch, channels, shape1, shape0]
Y_shape = [batch, channels, shape1, shape2]
if ((not transpose_X) and (transpose_Y)):
X_shape = [batch, channels, shape0, shape1]
Y_shape = [batch, channels, shape2, shape1]
if ((transpose_X) and (transpose_Y)):
X_shape = [batch, channels, shape1, shape0]
Y_shape = [batch, channels, shape2, shape1]
if (len_X == 4 and len_Y == 2):
if ((not transpose_X) and (not transpose_Y)):
X_shape = [batch, channels, shape0, shape1]
Y_shape = [shape1, shape2]
if ((transpose_X) and (not transpose_Y)):
X_shape = [batch, channels, shape1, shape0]
Y_shape = [shape1, shape2]
if ((not transpose_X) and (transpose_Y)):
X_shape = [batch, channels, shape0, shape1]
Y_shape = [shape2, shape1]
if ((transpose_X) and (transpose_Y)):
X_shape = [batch, channels, shape1, shape0]
Y_shape = [shape2, shape1]
if (len_X == 4 and len_Y == 1):
assume(transpose_X == transpose_Y == False)
X_shape = [batch, channels, shape0, shape1]
Y_shape = [shape1]
if (len_X == 3 and len_Y == 3):
if ((not transpose_X) and (not transpose_Y)):
X_shape = [channels, shape0, shape1]
Y_shape = [channels, shape1, shape2]
if ((transpose_X) and (not transpose_Y)):
X_shape = [channels, shape1, shape0]
Y_shape = [channels, shape1, shape2]
if ((not transpose_X) and (transpose_Y)):
X_shape = [channels, shape0, shape1]
Y_shape = [channels, shape2, shape1]
if ((transpose_X) and (transpose_Y)):
X_shape = [channels, shape1, shape0]
Y_shape = [channels, shape2, shape1]
if (len_X == 3 and len_Y == 2):
if ((not transpose_X) and (not transpose_Y)):
X_shape = [channels, shape0, shape1]
Y_shape = [shape1, shape2]
if ((transpose_X) and (not transpose_Y)):
X_shape = [channels, shape1, shape0]
Y_shape = [shape1, shape2]
if ((not transpose_X) and (transpose_Y)):
X_shape = [channels, shape0, shape1]
Y_shape = [shape2, shape1]
if ((transpose_X) and (transpose_Y)):
X_shape = [channels, shape1, shape0]
Y_shape = [shape2, shape1]
if (len_X == 3 and len_Y == 1):
assume(transpose_X == transpose_Y == False)
X_shape = [channels, shape0, shape1]
Y_shape = [shape1]
matmul_v2_op = OpConfig(type="matmul_v2",
inputs={
"X": ["input_data_x"],
"Y": ["input_data_y"]
},
outputs={"Out": ["output_data"]},
attrs={
"trans_x": transpose_X,
"trans_y": transpose_Y
})
program_config = ProgramConfig(ops=[matmul_v2_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):
#conv or conv_transpose
Transpose = draw(st.sampled_from([True, False]))
#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=4, max_size=4))
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.integers(
min_value=0,
max_value=max(strides[0], dilations[0]) - 1)), draw(
st.integers(
min_value=0,
max_value=max(strides[1], dilations[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))
#active param
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))
slope = draw(st.floats(min_value=0.7, max_value=0.9))
conv_out_shape = []
paddings_, dilations_ = UpdatePaddingAndDilation(
in_shape, weight_shape, paddings, dilations, groups,
padding_algorithm, strides)
self.depthwise = False
if Transpose:
assume(in_shape[1] == weight_shape[0])
assume(in_shape[1] % groups == 0) #TODO
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 + [int(oh), int(ow)]
assume(oh > 0 and ow > 0)
if len(output_padding):
conv_output_h = (oh + output_padding[0] + paddings[0] +
paddings[1] -
(dilations[0] *
(weight_shape[2] - 1) + 1)) / strides[0] + 1
conv_output_w = (oh + output_padding[1] + paddings[0] +
paddings[1] -
(dilations[1] *
(weight_shape[3] - 1) + 1)) / strides[1] + 1
assume(in_shape[2] == conv_output_h)
assume(in_shape[3] == conv_output_w)
else:
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 + [int(oh), int(ow)]
assume(oh > 0 and ow > 0)
#bn param
epsilon = draw(st.floats(min_value=0.00001, max_value=0.001))
momentum = draw(st.floats(min_value=0.1, max_value=0.9))
def generate_scale(*args, **kwargs):
return np.random.random(
[conv_out_shape[1]]).astype(np.float32) + 0.5
def generate_bias(*args, **kwargs):
return np.random.random([conv_out_shape[1]]).astype(np.float32)
def generate_mean(*args, **kwargs):
return np.random.random([conv_out_shape[1]]).astype(np.float32)
def generate_variance(*args, **kwargs):
return np.random.random([conv_out_shape[1]]).astype(np.float32)
conv_type = ""
conv_attrs = {}
if Transpose:
conv_type = "conv2d_transpose"
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,
"output_size": [],
"output_padding": output_padding
}
else:
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)
bn_op = OpConfig(
type="batch_norm",
inputs={
"X": ["conv_output_data"],
"Scale": ["scale_data"],
"Bias": ["bias_data"],
"Mean": ["mean_data"],
"Variance": ["variance_data"]
},
outputs={
"Y": ["output_data"],
"MeanOut": ["mean_data"],
"VarianceOut": ["variance_data"],
"SavedMean": ["saved_mean"],
"SavedVariance": ["saved_variance"]
},
attrs={
"is_test": True,
"trainable_statistics": False,
"data_layout": "NCHW",
"use_global_stats": False,
"epsilon": epsilon,
"momentum": momentum
})
ops = [conv_op, bn_op]
self.ops = ops
program_config = ProgramConfig(
ops=ops,
weights={
"filter_data": TensorConfig(shape=weight_shape),
"scale_data": TensorConfig(data_gen=partial(generate_scale)),
"bias_data": TensorConfig(data_gen=partial(generate_bias)),
"mean_data": TensorConfig(data_gen=partial(generate_mean)),
"variance_data":
TensorConfig(data_gen=partial(generate_variance)),
},
inputs={"input_data": TensorConfig(shape=in_shape)},
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(self, draw):
batch = draw(st.integers(min_value=1, max_value=4))
channel = draw(st.integers(min_value=1, max_value=32))
height = draw(st.integers(min_value=3, max_value=100))
width = draw(st.integers(min_value=3, max_value=100))
in_shape = [batch, channel, height, width]
out_size_shape = draw(st.sampled_from([[1, 2]]))
align_corners = draw(st.booleans())
align_mode = draw(st.sampled_from([0, 1]))
out_h = draw(st.integers(min_value=3, max_value=10))
out_w = draw(st.integers(min_value=3, max_value=10))
scale = draw(
st.lists(st.floats(min_value=0.1, max_value=0.9),
min_size=2,
max_size=2))
def generate_input(*args, **kwargs):
return np.random.random(in_shape).astype(np.float32)
def generate_out_size(*args, **kwargs):
return np.random.randint(1, 100, size=out_size_shape)
def generate_size_tensor(*args, **kwargs):
return np.random.randint(1, 100, [1]).astype(np.int32)
def generate_scale(*args, **kwargs):
return np.random.random([1]).astype(np.int32)
bilinear_interp_v2_op = OpConfig(
type="bilinear_interp_v2",
inputs={
"X": ["input_data"],
"OutSize": ["out_size_data"],
"SizeTensor": ["size_tensor_data1", "size_tensor_data2"],
"Scale": ["scale_data"]
},
outputs={"Out": ["output_data"]},
attrs={
"data_layout": "NCHW",
"out_d": 0,
"out_h": out_h,
"out_w": out_w,
"scale": scale,
"interp_method": "bilinear",
"align_corners": align_corners,
"align_mode": align_mode
})
program_config = ProgramConfig(
ops=[bilinear_interp_v2_op],
weights={},
inputs={
"input_data":
TensorConfig(data_gen=partial(generate_input)),
"out_size_data":
TensorConfig(data_gen=partial(generate_out_size)),
"size_tensor_data1":
TensorConfig(data_gen=partial(generate_size_tensor)),
"size_tensor_data2":
TensorConfig(data_gen=partial(generate_size_tensor)),
"scale_data":
TensorConfig(data_gen=partial(generate_scale))
},
outputs=["output_data"])
return program_config
def sample_program_configs(self, draw):
in_shape = draw(
st.lists(st.integers(min_value=4, max_value=8),
min_size=3,
max_size=4))
axis = draw(st.integers(min_value=0, max_value=len(in_shape) - 1))
index = draw(
st.sampled_from([[0], [2], [3], [1, 2], [1, 2, 3],
[in_shape[axis] - 1],
[in_shape[axis] - 2, in_shape[axis] - 1]]))
axis_type = draw(st.sampled_from(["int32", "int64"]))
index_type = draw(st.sampled_from(["int32", "int64"]))
with_tenor_axis = draw(st.sampled_from([True, False]))
def generate_axis(*args, **kwargs):
if axis_type == "int32":
return np.array([axis]).astype(np.int32)
else:
return np.array([axis]).astype(np.int64)
def generate_index(*args, **kwargs):
if index_type == "int32":
return np.array(index).astype(np.int32)
else:
return np.array(index).astype(np.int64)
def generate_input_int32(*args, **kwargs):
return np.random.random(in_shape).astype(np.int32)
def generate_input_int64(*args, **kwargs):
return np.random.random(in_shape).astype(np.int64)
def generate_input_float32(*args, **kwargs):
return np.random.random(in_shape).astype(np.float32)
generate_input = draw(
st.sampled_from([
generate_input_int32, generate_input_int64,
generate_input_float32
]))
op_inputs = {}
program_inputs = {}
if (with_tenor_axis):
op_inputs = {
"X": ["input_data"],
"Index": ["index_data"],
"Axis": ["axis_data"]
}
program_inputs = {
"input_data": TensorConfig(data_gen=partial(generate_input)),
"index_data": TensorConfig(data_gen=partial(generate_index)),
"axis_data": TensorConfig(data_gen=partial(generate_axis))
}
else:
op_inputs = {"X": ["input_data"], "Index": ["index_data"]}
program_inputs = {
"input_data": TensorConfig(data_gen=partial(generate_input)),
"index_data": TensorConfig(data_gen=partial(generate_index))
}
gather_op = OpConfig(type="gather",
inputs=op_inputs,
outputs={"Out": ["output_data"]},
attrs={"axis": axis})
program_config = ProgramConfig(ops=[gather_op],
weights={},
inputs=program_inputs,
outputs=["output_data"])
return program_config
