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"]
in_shape = draw(
st.lists(st.integers(min_value=1, max_value=8),
min_size=4,
max_size=4))
tan_op = OpConfig(type="tan",
inputs={"X": ["input_data"]},
outputs={"Out": ["output_data"]},
attrs={})
program_config = ProgramConfig(
ops=[tan_op],
weights={},
inputs={
"input_data":
TensorConfig(data_gen=partial(generate_input,
type="float32",
low=-0.9,
high=0.9,
shape=in_shape))
},
outputs=["output_data"])
return 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=128),
min_size=1,
max_size=3))
in_shape = in_num + in_c_h_w
axis = draw(st.sampled_from([-1, 0, 1, 2, 3]))
epsilon = draw(st.sampled_from([0, 1e-6]))
keepdim = draw(st.booleans())
asvector = draw(st.booleans())
p_norm_op = OpConfig(
type="p_norm",
inputs={"X": ["input_data"]},
outputs={"Out": ["output_data"]},
attrs={
"axis": axis,
"epsilon": epsilon,
"keepdim": keepdim,
"asvector": asvector
})
program_config = ProgramConfig(
ops=[p_norm_op],
weights={},
inputs={"input_data": TensorConfig(shape=in_shape)},
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=1,
max_size=3))
in_shape.insert(0, 10)
lod_data = draw(
st.sampled_from([[[0, 0, 10]], [[2, 0, 10]], [[1, 0, 10]],
[[0, 1, 0, 10]]]))
def generate_input(*args, **kwargs):
return np.random.uniform(0.1, 1, in_shape).astype('float32')
ops_config = OpConfig(type="sequence_reverse",
inputs={"X": ["input_data"]},
outputs={"Y": ["output_data"]},
attrs={})
program_config = ProgramConfig(ops=[ops_config],
weights={},
inputs={
"input_data":
TensorConfig(
data_gen=partial(generate_input),
lod=lod_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=64), min_size=1, max_size=4))
input_axis = draw(st.sampled_from([0, 1, 2, 3, -1]))
assume(input_axis < len(in_shape))
def generate_input(*args, **kwargs):
return np.random.normal(0.0, 1.0, in_shape).astype(np.float32)
ops_config = OpConfig(
type="softmax",
inputs={"X": ["input_data"]},
outputs={"Out": ["output_data"]},
attrs={"axis": input_axis})
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), min_size=1,
max_size=4))
abs_op = OpConfig(type="assign",
inputs={"X": ["input_data"]},
outputs={"Out": ["abs_output_data"]},
attrs={})
scale_op = OpConfig(type="scale",
inputs={"X": ["abs_output_data"]},
outputs={"Out": ["output_data"]},
attrs={
"scale": 1.0,
"bias": 0.0,
"bias_after_scale": True
})
ops = [abs_op, scale_op]
program_config = ProgramConfig(
ops=ops,
weights={},
inputs={"input_data": TensorConfig(shape=in_shape)},
outputs=["output_data"])
return program_config
def sample_program_configs(draw):
in_shape = draw(
st.lists(st.integers(min_value=1, max_value=10),
min_size=2,
max_size=4))
shape = draw(
st.lists(st.integers(min_value=1, max_value=10),
min_size=2,
max_size=4))
dtype = draw(st.sampled_from([2, 3, 5]))
input_dim_idx = draw(
st.integers(min_value=0, max_value=(len(in_shape) - 1)))
out_dim_idx = draw(st.integers(min_value=0, max_value=(len(shape) - 1)))
value = draw(st.floats(min_value=-10, max_value=10))
fill_constant_batch_size_like_op = OpConfig(
type="fill_constant_batch_size_like",
inputs={"Input": ["input_data"]},
outputs={"Out": ["output_data"]},
attrs={
"dtype": dtype,
"shape": shape,
"value": value,
"force_cpu": False,
"input_dim_idx": input_dim_idx,
"output_dim_idx": out_dim_idx
})
program_config = ProgramConfig(
ops=[fill_constant_batch_size_like_op],
weights={},
inputs={"input_data": TensorConfig(shape=in_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))
axis = draw(st.sampled_from([0, [1], [0, 1]]))
if isinstance(axis, int):
axis = [axis]
def generate_input(*args, **kwargs):
return np.random.random(in_shape).astype(np.float32)
build_ops = OpConfig(type="reverse",
inputs={
"X": ["input_data"],
},
outputs={
"Out": ["output_data"],
},
attrs={
"axis": axis,
})
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=10),
min_size=4,
max_size=4))
def generate_input(*args, **kwargs):
return np.random.random(in_shape).astype(np.float32)
build_ops = OpConfig(type="print",
inputs={
"In": ["input_data"],
},
outputs={
"Out": ["output_data"],
},
attrs={
"first_n": 10,
"summarize": 20,
"message": "",
})
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(self, draw):
in_shape = draw(
st.lists(st.integers(min_value=1, max_value=32),
min_size=1,
max_size=4))
input_type = draw(st.sampled_from(["float32", "int32", "int64"]))
input_axis = draw(st.sampled_from([[0, 1, 2, 3]]))
assume(len(input_axis) <= len(in_shape))
if len(input_axis) > 0:
for num in input_axis:
num = num if num >= 0 else num + len(in_shape)
assume(num < len(in_shape))
def generate_input(*args, **kwargs):
if input_type == "float32":
return np.random.normal(1.0, 6.0, in_shape).astype(np.float32)
elif input_type == "int32":
return np.random.normal(1.0, 6.0, in_shape).astype(np.int32)
elif input_type == "int64":
return np.random.normal(1.0, 6.0, in_shape).astype(np.int64)
ops_config = OpConfig(type="squeeze",
inputs={"X": ["input_data"]},
outputs={"Out": ["output_data"]},
attrs={"axes": input_axis})
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):
lod_data = draw(
st.lists(st.integers(min_value=0, max_value=32),
min_size=0,
max_size=3))
lod_data.append(12)
new_dim = draw(st.sampled_from([12]))
input_type = draw(st.sampled_from(["float32", "int64"]))
def generate_input(*args, **kwargs):
if input_type == "float32":
return np.random.normal(0.0, 6.0, [12, 12]).astype(np.float32)
elif input_type == "int64":
return np.random.normal(0.0, 6.0, [12, 12]).astype(np.int64)
ops_config = OpConfig(type="sequence_reshape",
inputs={"X": ["input_data"]},
outputs={"Out": ["output_data"]},
attrs={"new_dim": new_dim})
program_config = ProgramConfig(
ops=[ops_config],
weights={},
inputs={
"input_data":
TensorConfig(data_gen=partial(generate_input), lod=[lod_data])
},
outputs=["output_data"])
return program_config
def sample_program_configs(self):
def generate_input(shape):
return np.random.random(shape).astype(np.float32)
for batch in [1, 2, 4]:
for shape in [[batch, 64], [batch, 32, 64], [batch, 64, 32, 128]]:
self.input_dim = len(shape)
for slope in [0.1, 0.5]:
for offset in [0.2, 0.7]:
dics = [{"slope": slope, "offset": offset}]
ops_config = [{
"op_type": "hard_sigmoid",
"op_inputs": {
"X": ["input_data"],
},
"op_outputs": {
"Out": ["output_data"]
},
"op_attrs": dics[0]
}]
ops = self.generate_op_config(ops_config)
program_config = ProgramConfig(
ops=ops,
weights={},
inputs={
"input_data":
TensorConfig(
data_gen=partial(generate_input, shape))
},
outputs=["output_data"])
yield program_config
def sample_program_configs(self, draw):
N = draw(st.integers(min_value=2, max_value=4))
C = draw(st.integers(min_value=2, max_value=128))
H = draw(st.integers(min_value=2, max_value=128))
W = draw(st.integers(min_value=2, max_value=128))
in_shape = draw(st.sampled_from([[N, C, H, W]]))
# host only register float32 and int64
in_dtype = draw(st.sampled_from([np.float32, np.int64]))
def generate_X_data():
return np.random.normal(0.0, 5.0, in_shape).astype(in_dtype)
axis_data = draw(st.integers(min_value=1, max_value=3))
output_string = ["out"] * in_shape[axis_data]
for i in range(in_shape[axis_data]):
output_string[i] += str(i)
unbind_op = OpConfig(type="unbind",
inputs={"X": ["input_data"]},
outputs={"Out": output_string},
attrs={"axis": axis_data})
program_config = ProgramConfig(
ops=[unbind_op],
weights={},
inputs={
"input_data": TensorConfig(data_gen=partial(generate_X_data)),
},
outputs=output_string)
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_max",
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):
in_shape = draw(
st.lists(
st.integers(
min_value=1, max_value=8), min_size=1, max_size=4))
axis = draw(st.integers(min_value=-1, max_value=3))
keepdims = draw(st.booleans())
dtype = draw(st.sampled_from([-1, 2, 3]))
assume(axis < len(in_shape))
arg_max_op = OpConfig(
type="arg_max",
inputs={"X": ["input_data"]},
outputs={"Out": ["output_data"]},
attrs={
"axis": axis,
"keepdims": keepdims,
"dtype": dtype,
"flatten": False
})
program_config = ProgramConfig(
ops=[arg_max_op],
weights={},
inputs={"input_data": TensorConfig(shape=in_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=8),
min_size=1,
max_size=4))
threshold = 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))
hard_swish_op = OpConfig(type="hard_swish",
inputs={"X": ["input_data"]},
outputs={"Out": ["hard_swish_output_data"]},
attrs={
"threshold": threshold,
"scale": scale,
"offset": offset
})
scale_op = OpConfig(type="scale",
inputs={"X": ["hard_swish_output_data"]},
outputs={"Out": ["output_data"]},
attrs={
"scale": 1.0,
"bias": 0.0,
"bias_after_scale": True
})
ops = [hard_swish_op, scale_op]
program_config = ProgramConfig(
ops=ops,
weights={},
inputs={"input_data": TensorConfig(shape=in_shape)},
outputs=["output_data"])
return program_config
def sample_program_configs(self, draw):
in_shape = draw(
st.lists(st.integers(min_value=3, max_value=64),
min_size=2,
max_size=4))
def generate_input(*args, **kwargs):
return np.random.random(in_shape).astype(np.float32)
build_ops = OpConfig(type="log",
inputs={
"X": ["input_data"],
},
outputs={
"Out": ["output_data"],
},
attrs={})
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(self, draw):
in_shape = draw(
st.lists(
st.integers(
min_value=1, max_value=64), min_size=1, max_size=4))
input_type = draw(st.sampled_from(["float32", "int32", "int64"]))
def generate_input(*args, **kwargs):
if input_type == "float32":
return np.random.normal(1.0, 6.0, in_shape).astype(np.float32)
elif input_type == "int32":
return np.random.normal(1.0, 6.0, in_shape).astype(np.int32)
elif input_type == "int64":
return np.random.normal(1.0, 6.0, in_shape).astype(np.int64)
ops_config = OpConfig(
type="shape",
inputs={"Input": ["input_data"]},
outputs={"Out": ["output_data"]},
attrs={})
program_config = ProgramConfig(
ops=[ops_config],
weights={},
inputs={
"input_data": TensorConfig(
data_gen=partial(generate_input), lod=[[0, 2]])
},
outputs=["output_data"])
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))
beta = draw(st.sampled_from([1, 2, 3]))
threshold = draw(st.integers(min_value=10, max_value=20))
def generate_input(*args, **kwargs):
return np.random.normal(1.0, 1.0, in_shape).astype(np.float32)
ops_config = OpConfig(type="softplus",
inputs={"X": ["input_data"]},
outputs={"Out": ["output_data"]},
attrs={
"beta": beta,
"threshold": threshold
})
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=2, max_value=10),
min_size=2,
max_size=4))
input_type = draw(st.sampled_from(["type_float"]))
assume(len(in_shape) == 4)
assume(in_shape[1] % 2 == 0)
def generate_input(*args, **kwargs):
return (np.random.random(kwargs['tensor_shape']).astype(np.float32)
- 0.5) * 2
build_op = OpConfig(type="polygon_box_transform",
inputs={"Input": ["input_data"]},
outputs={"Output": ["output_data"]},
attrs={})
program_config = ProgramConfig(
ops=[build_op],
weights={},
inputs={
"input_data":
TensorConfig(
data_gen=partial(generate_input, tensor_shape=in_shape))
},
outputs=["output_data"])
return program_config
def sample_program_configs(self, draw):
input_data_x_shape = draw(
st.lists(st.integers(min_value=1, max_value=8),
min_size=1,
max_size=8))
x_dims_size = len(input_data_x_shape)
flatten = draw(st.booleans())
axis = draw(
st.integers(min_value=-x_dims_size, max_value=x_dims_size - 1))
if flatten:
axis = -1
exclusive = draw(st.booleans())
reverse = draw(st.booleans())
cumsum_op = OpConfig(type="cumsum",
inputs={"X": ["input_data_x"]},
outputs={"Out": ["output_data"]},
attrs={
"axis": axis,
"flatten": flatten,
"exclusive": exclusive,
"reverse": reverse
})
program_config = ProgramConfig(
ops=[cumsum_op],
weights={},
inputs={
"input_data_x": TensorConfig(shape=input_data_x_shape),
},
outputs=["output_data"])
return program_config
def sample_program_configs(self):
def generate_input(batch):
return np.random.random([2, batch, 4, 8, 3]).astype(np.float32)
for batch in [1, 2, 4]:
for start_axis in range(5):
for stop_axis in range(start_axis, 5):
type = "flatten_contiguous_range"
op_outputs = {
"Out": ["output_data"],
"XShape": ["xshape_data"]
}
ops_config = [{
"op_type": type,
"op_inputs": {
"X": ["input_data"]
},
"op_outputs": op_outputs,
"op_attrs": {
"start_axis": start_axis,
"stop_axis": stop_axis,
}
}]
ops = self.generate_op_config(ops_config)
program_config = ProgramConfig(
ops=ops,
weights={},
inputs={
"input_data":
TensorConfig(
data_gen=partial(generate_input, batch))
},
outputs=["output_data"])
yield program_config
def sample_program_configs(self):
def generate_input():
return np.ones([1, 3, 32, 32]).astype(np.float32)
ops_config = [{
"op_type": "nearest_interp_v2",
"op_inputs": {
"X": ["input_data"]
},
"op_outputs": {
"Out": ["interp_output_data"]
},
"op_attrs": {
"data_layout": "NCHW",
"interp_method": "nearest",
"align_corners": False,
"scale": [2., 2.],
"out_h": 0,
"out_w": 0
}
}]
ops = self.generate_op_config(ops_config)
program_config = ProgramConfig(
ops=ops,
weights={},
inputs={"input_data": TensorConfig(data_gen=generate_input)},
outputs=["interp_output_data"])
yield program_config
def sample_program_configs(self, draw):
in_shape = draw(
st.lists(st.integers(min_value=1, max_value=64),
min_size=3,
max_size=3))
batch = draw(st.integers(min_value=1, max_value=10))
in_shape.insert(0, batch)
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(1.0, 6.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(self, draw):
in_shape = draw(
st.lists(st.integers(min_value=3, max_value=64),
min_size=0,
max_size=3))
batch = draw(st.integers(min_value=1, max_value=3))
in_shape.insert(0, batch)
axis = draw(st.integers(min_value=-1, max_value=3))
keepdims = draw(st.booleans())
dtype = draw(st.sampled_from([-1, 2, 3]))
assume(axis < len(in_shape))
arg_max_op = OpConfig(type="arg_max",
inputs={"X": ["input_data"]},
outputs={"Out": ["output_data"]},
attrs={
"axis": axis,
"keepdims": keepdims,
"dtype": dtype,
"flatten": False
})
if dtype == 2:
arg_max_op.outputs_dtype = {"output_data": np.int32}
else:
arg_max_op.outputs_dtype = {"output_data": np.int64}
program_config = ProgramConfig(
ops=[arg_max_op],
weights={},
inputs={"input_data": TensorConfig(shape=in_shape)},
outputs=["output_data"])
return 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=128),
min_size=1,
max_size=3))
in_shape = in_num + in_c_h_w
axis = draw(st.sampled_from([-1, 0, 1, 2, 3]))
epsilon = draw(st.sampled_from([0.9, 1., 1.1, 1e-5]))
norm_op = OpConfig(
type="norm",
inputs={"X": ["input_data"]},
outputs={"Out": ["output_data"],
"Norm": ["Norm"]},
attrs={"axis": axis,
"epsilon": epsilon,
"is_test": 1})
program_config = ProgramConfig(
ops=[norm_op],
weights={},
inputs={"input_data": TensorConfig(shape=in_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))
attr_shape = draw(
st.lists(
st.integers(
min_value=1, max_value=max(in_shape)),
min_size=1,
max_size=len(in_shape)))
assume(
reduce(lambda x, y: x * y, attr_shape) == reduce(
lambda x, y: x * y, in_shape))
with_shape = draw(st.sampled_from([True, False]))
def generate_input(*args, **kwargs):
return np.random.random(in_shape).astype(np.float32)
build_ops = OpConfig(
type="reshape",
inputs={"X": ["input_data"], },
outputs={"Out": ["output_data"], },
attrs={"shape": attr_shape, })
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(self, draw):
n = draw(st.integers(min_value=1, max_value=32))
p = draw(st.integers(min_value=1, max_value=32))
q = draw(st.integers(min_value=1, max_value=32))
def generate_input_data_in_shape(*args, **kwargs):
return np.arange(n).reshape(n, 1).astype('int32')
def generate_mask_data_in_shape(*args, **kwargs):
return np.expand_dims(np.random.rand(n).astype('bool'), axis=1)
def generate_in_true_data_in_shape(*args, **kwargs):
return np.expand_dims(np.random.rand(p).astype('int32'), axis=1)
def generate_in_false_data_in_shape(*args, **kwargs):
return np.expand_dims(np.random.rand(q).astype('int32'), axis=1)
use_merge_lod_infer = draw(st.booleans())
match_matrix_tensor_op = OpConfig(type="merge_lod_tensor",
inputs={
"X": ["input_data_x"],
"Mask": ["Mask"],
"InTrue": ["InTrue"],
"InFalse": ["InFalse"]
},
outputs={"Out": ["output_data"]},
attrs={
"level":
0,
"use_merge_lod_infer":
["use_merge_lod_infer"]
})
program_config = ProgramConfig(
ops=[match_matrix_tensor_op],
weights={},
inputs={
"input_data_x":
TensorConfig(data_gen=partial(generate_input_data_in_shape)),
"Mask":
TensorConfig(data_gen=partial(generate_mask_data_in_shape)),
"InTrue":
TensorConfig(data_gen=generate_in_true_data_in_shape),
"InFalse":
TensorConfig(data_gen=generate_in_false_data_in_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]))
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]
Y_shape = [shape1, shape3, shape2]
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())
multiclass_nms2_op = OpConfig(type="multiclass_nms2",
inputs={
"BBoxes": ["input_data_BBoxes"],
"Scores": ["input_data_Scores"]
},
outputs={
"Out": ["output_data"],
"Index": ["Index"]
},
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_nms2_op],
weights={},
inputs={
"input_data_BBoxes":
TensorConfig(shape=X_shape),
"input_data_Scores":
TensorConfig(shape=Y_shape)
},
outputs={"output_data", "Index"})
x_shape = list(program_config.inputs["input_data_BBoxes"].shape)
y_shape = list(program_config.inputs["input_data_Scores"].shape)
assume(x_shape[0] > y_shape[0])
return program_config
def sample_program_configs(draw):
in_shape = draw(
st.lists(st.integers(min_value=4, max_value=8), min_size=3,
max_size=4))
value0 = draw(st.integers(min_value=0, max_value=in_shape[0] - 1))
value1 = draw(st.integers(min_value=0, max_value=in_shape[1] - 1))
value2 = draw(st.integers(min_value=0, max_value=in_shape[2] - 1))
index = draw(
st.sampled_from([[value0], [value0, value1], [value0, value1,
value2]]))
index_type = draw(st.sampled_from(["int32", "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 = {"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_nd_op = OpConfig(type="gather_nd",
inputs=op_inputs,
outputs={"Out": ["output_data"]},
attrs={"axis": 1})
program_config = ProgramConfig(ops=[gather_nd_op],
weights={},
inputs=program_inputs,
outputs=["output_data"])
return program_config
def sample_program_configs(self, draw):
in_shape = draw(
st.lists(st.integers(min_value=1, max_value=64),
min_size=3,
max_size=3))
in_shape.insert(0, draw(st.integers(min_value=1, max_value=16)))
epsilon = draw(st.floats(min_value=0.0001, max_value=0.0005))
begin_norm_axis = draw(st.sampled_from([1, 2]))
def generate_input(*args, **kwargs):
return np.random.normal(0.0, 1.0, in_shape).astype(np.float32)
channel_dim = 1
for dim in range(begin_norm_axis, 4):
channel_dim = channel_dim * in_shape[dim]
def generate_scale(*args, **kwargs):
return np.random.random([channel_dim]).astype(np.float32)
def generate_bias(*args, **kwargs):
return np.random.random([channel_dim]).astype(np.float32)
run_op = OpConfig(type="layer_norm",
inputs={
"X": ["input_data"],
"Scale": ["scale_data"],
"Bias": ["bias_data"]
},
outputs={
"Y": ["output_data"],
"Mean": ["mean_data"],
"Variance": ["variance_data"],
},
attrs={
"epsilon": epsilon,
"begin_norm_axis": begin_norm_axis
})
program_config = ProgramConfig(
ops=[run_op],
weights={},
inputs={
"input_data": TensorConfig(data_gen=partial(generate_input)),
"scale_data": TensorConfig(data_gen=partial(generate_scale)),
"bias_data": TensorConfig(data_gen=partial(generate_bias)),
},
outputs=["output_data", "mean_data", "variance_data"])
return program_config
