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_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(*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"]))
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_nd_op = OpConfig(type="gather_nd",
inputs=op_inputs,
outputs={"Out": ["output_data"]},
attrs={"axis": 1})
if input_type == "int64":
gather_nd_op.outputs_dtype = {"output_data": np.int64}
elif input_type == "int32":
gather_nd_op.outputs_dtype = {"output_data": np.int32}
program_config = ProgramConfig(ops=[gather_nd_op],
weights={},
inputs=program_inputs,
outputs=["output_data"])
return program_config
def sample_program_configs(self, draw):
#The number of elements in Input(X) should be 1
in_shape = draw(
st.lists(st.integers(min_value=1, max_value=1),
min_size=1,
max_size=1))
step_data = draw(st.floats(min_value=0.1, max_value=0.5))
input_type = draw(
st.sampled_from(["type_int", "type_int64", "type_float"]))
def generate_input1(*args, **kwargs):
return np.random.random(in_shape).astype(np.float32)
def generate_input2(*args, **kwargs):
return np.random.randint(in_shape).astype(np.int32)
def generate_input3(*args, **kwargs):
return np.random.randint(in_shape).astype(np.int64)
build_ops = OpConfig(type="increment",
inputs={
"X": ["input_data"],
},
outputs={
"Out": ["output_data"],
},
attrs={
"step": step_data,
})
if input_type == "type_int":
build_ops.outputs_dtype = {"output_data": np.int32}
program_config = ProgramConfig(
ops=[build_ops],
weights={},
inputs={
"input_data":
TensorConfig(data_gen=partial(generate_input2)),
},
outputs=["output_data"])
elif input_type == "type_int64":
build_ops.outputs_dtype = {"output_data": np.int64}
program_config = ProgramConfig(
ops=[build_ops],
weights={},
inputs={
"input_data":
TensorConfig(data_gen=partial(generate_input3)),
},
outputs=["output_data"])
elif input_type == "type_float":
program_config = ProgramConfig(
ops=[build_ops],
weights={},
inputs={
"input_data":
TensorConfig(data_gen=partial(generate_input1)),
},
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=3,
max_size=4))
process_type = draw(
st.sampled_from(["type_int32", "type_int64", "type_float"]))
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)
build_ops = OpConfig(type="is_empty",
inputs={"X": ["data_x"]},
outputs={
"Out": ["output_data"],
},
attrs={})
build_ops.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)
})
cast_out.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))
},
outputs=["cast_data_out"])
return program_config
def sample_program_configs(self, draw):
in_shape = draw(
st.lists(st.integers(min_value=1, max_value=50),
min_size=1,
max_size=1))
in_dtype = draw(st.sampled_from([np.float32, np.int32, np.int64]))
def generate_X_data():
return np.random.normal(0.0, 5.0, in_shape).astype(in_dtype)
def generate_Condition_data():
return np.random.choice([0, 1], in_shape,
replace=True).astype(np.int32)
cast_op = OpConfig(
type="cast",
inputs={"X": ["Condition_data"]},
outputs={"Out": ["middle_data"]},
attrs={
"in_dtype": 2, #int32
"out_dtype": 0, # bool
})
cast_op.outputs_dtype = {"middle_data": np.bool}
where_op = OpConfig(type="where",
inputs={
"X": ["X_data"],
"Y": ["Y_data"],
"Condition": ["middle_data"]
},
outputs={"Out": ["Out_data"]},
attrs={})
where_op.outputs_dtype = {"Out_data": in_dtype}
program_config = ProgramConfig(
ops=[cast_op, where_op],
weights={},
inputs={
"X_data":
TensorConfig(data_gen=partial(generate_X_data)),
"Y_data":
TensorConfig(data_gen=partial(generate_X_data)),
"Condition_data":
TensorConfig(data_gen=partial(generate_Condition_data))
},
outputs=["Out_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=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.randint(
low=0, high=1, size=in_shape).astype(np.int32)
cast_x = OpConfig(
type="cast",
inputs={"X": ["input_data_x"], },
outputs={"Out": ["cast_data_x"], },
attrs={"in_dtype": int(2),
"out_dtype": int(0)})
cast_x.outputs_dtype = {"cast_data_x": np.bool_}
build_ops = OpConfig(
type="reduce_all",
inputs={"X": ["cast_data_x"], },
outputs={"Out": ["output_data"], },
attrs={
"dim": axis,
"keep_dim": keep_dim,
"reduce_all": reduce_all_data,
})
cast_out = OpConfig(
type="cast",
inputs={"X": ["output_data"], },
outputs={"Out": ["cast_data_out"], },
attrs={"in_dtype": int(0),
"out_dtype": int(2)})
cast_out.outputs_dtype = {"cast_data_out": np.int32}
program_config = ProgramConfig(
ops=[cast_x, build_ops, cast_out],
weights={},
inputs={
"input_data_x": TensorConfig(data_gen=partial(generate_input)),
},
outputs=["cast_data_out"])
return program_config
def sample_program_configs(self, draw):
in_shape = draw(
st.lists(st.integers(min_value=1, max_value=8),
min_size=2,
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"]))
start_axis = draw(st.integers(min_value=0,
max_value=len(in_shape) - 1))
stop_axis = draw(
st.integers(min_value=start_axis, max_value=len(in_shape) - 1))
outputs_ = ["output_data", "xshape_data"]
target_str = self.get_target()
if target_str == "NNAdapter":
if "nvidia_tensorrt" in self.get_nnadapter_device_name():
assume(input_type != "int64")
if self.get_nnadapter_device_name() in [
"nvidia_tensorrt", "intel_openvino"
]:
outputs_ = ["output_data"]
flatten_contiguous_range_op = OpConfig(type="flatten_contiguous_range",
inputs={"X": ["input_data"]},
outputs={
"Out": ["output_data"],
"XShape": ["xshape_data"]
},
attrs={
"start_axis": start_axis,
"stop_axis": stop_axis
})
flatten_contiguous_range_op.outputs_dtype = {"output_data": input_type}
program_config = ProgramConfig(
ops=[flatten_contiguous_range_op],
weights={"xshape_data": TensorConfig(shape=in_shape)},
inputs={
"input_data":
TensorConfig(data_gen=partial(generate_input,
type=input_type,
low=-10,
high=10,
shape=in_shape))
},
outputs=outputs_)
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)
unsqueeze_op = OpConfig(type="unsqueeze",
inputs=inputs,
outputs={"Out": ["Out_data"]},
attrs={
"axes": axes_data,
})
unsqueeze_op.outputs_dtype = {"Out_data": in_dtype}
program_config = ProgramConfig(
ops=[unsqueeze_op],
weights={},
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"])
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], [N, H, W]]))
in_dtype = draw(st.sampled_from([0, 1, 2, 3]))
def generate_Condition_data():
if (in_dtype == 0):
return np.random.normal(0.0, 1.0, in_shape).astype(np.float32)
elif (in_dtype == 1):
return np.random.randint(1, 500, in_shape).astype(np.int32)
elif (in_dtype == 2):
return np.random.randint(1, 500, in_shape).astype(np.int64)
elif (in_dtype == 3):
return np.random.choice([True, False], in_shape, replace=True)
where_index_op = OpConfig(type="where_index",
inputs={"Condition": ["Condition_data"]},
outputs={"Out": ["Out_data"]},
attrs={})
where_index_op.outputs_dtype = {"Out_data": np.int64}
program_config = ProgramConfig(
ops=[where_index_op],
weights={},
inputs={
"Condition_data":
TensorConfig(data_gen=partial(generate_Condition_data))
},
outputs=["Out_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(["int64", "int32", "float32"]))
input_axis = draw(
st.sampled_from([[0, 1, 2, 3], [-1, 2, 3], [], [-1], [1], [2], [3],
[-1, 0, 1]]))
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))
# "nvidia_tensorrt" must satisfies theses
if self.get_nnadapter_device_name() == "nvidia_tensorrt":
for i in range(len(input_axis)):
in_shape[input_axis[i]] = 1
input_type = "float32"
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)
def generate_xshape(*args, **kwargs):
return np.random.normal(1.0, 1.0, in_shape).astype(np.float32)
ops_config = OpConfig(type="squeeze2",
inputs={"X": ["input_data"]},
outputs={
"Out": ["output_data"],
"XShape": ["squeeze2_xshape"]
},
attrs={"axes": input_axis})
ops_config.outputs_dtype = {"output_data": input_type}
program_config = ProgramConfig(
ops=[ops_config],
weights={
"squeeze2_xshape":
TensorConfig(data_gen=partial(generate_xshape))
},
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]]))
target = self.get_target()
use_mkldnn_data = False
in_dtype = np.float32
if (target == "X86"):
use_mkldnn_data = True
in_dtype = draw(st.sampled_from([np.float32]))
elif (target == "ARM"):
in_dtype = draw(
st.sampled_from([np.float32, np.int32, np.int64, np.int8]))
# ToDo :
# fp16 can not be verified
elif (target in ["OpenCL", "Metal"]):
in_dtype = draw(st.sampled_from([np.float32]))
# ToDo :
# fp16 can not be verified
def generate_X_data():
return np.random.normal(0.0, 5.0, in_shape).astype(in_dtype)
axis_int32_data = draw(
st.lists(st.integers(min_value=0, max_value=3),
min_size=4,
max_size=4))
assume(sorted(axis_int32_data) == [0, 1, 2, 3])
transpose2_op = OpConfig(type="transpose2",
inputs={"X": ["X_data"]},
outputs={
"Out": ["output_data"],
"XShape": ["XShape_data"]
},
attrs={
"axis": axis_int32_data,
"data_format": "AnyLayout",
"use_mkldnn": use_mkldnn_data,
})
transpose2_op.outputs_dtype = {"output_data": in_dtype}
program_config = ProgramConfig(
ops=[transpose2_op],
weights={"XShape_data": TensorConfig(shape=[4])},
inputs={
"X_data": TensorConfig(data_gen=partial(generate_X_data)),
},
outputs=["output_data", "XShape_data"])
return program_config
def sample_program_configs(self, draw):
in_shape = draw(
st.lists(
st.integers(
min_value=2, max_value=100),
min_size=1,
max_size=1))
in_dtype = draw(st.sampled_from([np.float32, np.int32, np.int64]))
def generate_X_data():
return np.random.normal(0.0, 5.0, in_shape).astype(in_dtype)
def generate_IndexTensor():
return np.random.randint(1, 5, size=in_shape).astype(np.int32)
unique_with_counts_op = OpConfig(
type="unique_with_counts",
inputs={"X": ["input_data"]},
outputs={
"Out": ["Out_data"],
"Index": ["Index_data"],
"Count": ["Count_data"]
},
attrs={"dtype": 2}) # data type for output index,int32
unique_with_counts_op.outputs_dtype = {"Out_data": in_dtype}
unique_with_counts_op.outputs_dtype = {"Index_data": np.int32}
unique_with_counts_op.outputs_dtype = {"Count_data": np.int32}
program_config = ProgramConfig(
ops=[unique_with_counts_op],
weights={
"Index_data":
TensorConfig(data_gen=partial(generate_IndexTensor))
},
inputs={
"input_data": TensorConfig(data_gen=partial(generate_X_data)),
},
outputs=["Out_data", "Index_data", "Count_data"])
return program_config
def sample_program_configs(self, draw):
in_shape = draw(
st.lists(st.integers(min_value=0, max_value=1),
min_size=1,
max_size=20))
level = draw(st.sampled_from([0]))
count = 0
for i in in_shape:
count += i
assume(count != 0)
assume(count != len(in_shape))
def generate_input1(*args, **kwargs):
return np.arange(len(in_shape)).reshape(len(in_shape),
1).astype('int32')
def generate_mask_np(*args, **kwargs):
mask_np = np.array(in_shape).astype('int32')
mask_np = np.expand_dims(mask_np, axis=1)
return mask_np
cast_mask_np = OpConfig(type="cast",
inputs={"X": ["Mask_input"]},
outputs={"Out": ["Mask_output"]},
attrs={
"in_dtype": int(2),
"out_dtype": int(0)
})
cast_mask_np.outputs_dtype = {"Mask_output": np.bool_}
ops_config = OpConfig(type="split_lod_tensor",
inputs={
"X": ["input_data"],
"Mask": ["Mask_output"]
},
outputs={
"OutTrue": ["output_true"],
"OutFalse": ["output_false"]
},
attrs={"level": level})
program_config = ProgramConfig(
ops=[cast_mask_np, ops_config],
weights={
"Mask_input": TensorConfig(data_gen=partial(generate_mask_np))
},
inputs={
"input_data": TensorConfig(data_gen=partial(generate_input1))
},
outputs=["output_true", "output_false"])
return program_config
def sample_program_configs(self, draw):
n = draw(st.integers(min_value=1, max_value=32))
def generate_input_data_in_shape(*args, **kwargs):
return np.random.random([n, 1]).astype('float32')
def generate_mask_data_in_shape(*args, **kwargs):
return np.expand_dims(
np.random.randint(
low=0, high=1, size=[n]).astype('int32'),
axis=1)
def generate_in_true_data_in_shape(*args, **kwargs):
return np.expand_dims(np.random.rand(n).astype('float32'), axis=1)
def generate_in_false_data_in_shape(*args, **kwargs):
return np.expand_dims(np.random.rand(n).astype('float32'), axis=1)
cast_x = OpConfig(
type="cast",
inputs={"X": ["input_data_mask"], },
outputs={"Out": ["cast_data_mask"], },
attrs={"in_dtype": int(2),
"out_dtype": int(0)})
cast_x.outputs_dtype = {"cast_data_mask": np.bool_}
match_matrix_tensor_op = OpConfig(
type="merge_lod_tensor",
inputs={
"X": ["input_data_x"],
"Mask": ["cast_data_mask"],
"InTrue": ["InTrue"],
"InFalse": ["InFalse"]
},
outputs={"Out": ["output_data"]},
attrs={"level": 0})
program_config = ProgramConfig(
ops=[cast_x, match_matrix_tensor_op],
weights={},
inputs={
"input_data_x":
TensorConfig(data_gen=generate_input_data_in_shape),
"input_data_mask":
TensorConfig(data_gen=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):
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})
ops_config.outputs_dtype = {"output_data": input_type}
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 tensor need
sequence_num = draw(st.integers(min_value=1, max_value=20))
tag_num = draw(st.integers(min_value=10, max_value=20))
max_sequence_length = draw(st.integers(min_value=10, max_value=10))
def gen_lod_data(sequence_num, max_sequence_length):
lod_data_init_list = [
np.random.randint(1, max_sequence_length + 1)
for i in range(sequence_num)
]
lod_data_init_list.insert(0, 0)
lod_data_init_array = np.array(lod_data_init_list)
lod_data = np.cumsum(lod_data_init_array)
return [lod_data.tolist()]
has_label_input_flag = draw(st.booleans())
input_lod_tensor_flag = draw(st.booleans())
if input_lod_tensor_flag:
emission_lod_info_data = gen_lod_data(sequence_num,
max_sequence_length)
else:
emission_lod_info_data = None
def gen_input_emission_data():
if input_lod_tensor_flag:
total_sequence_length_of_mini_batch = emission_lod_info_data[
-1][-1]
emission_data = np.random.uniform(
-1, 1, [total_sequence_length_of_mini_batch,
tag_num]).astype(np.float32)
else:
emission_data = np.random.uniform(
-1, 1, [sequence_num, max_sequence_length,
tag_num]).astype(np.float32)
return emission_data
def gen_input_transition_data():
return np.random.uniform(-0.5, 0.5,
[tag_num + 2, tag_num]).astype(np.float32)
def gen_input_length_data():
input_length_data = [
np.random.randint(1, max_sequence_length + 1)
for i in range(sequence_num)
]
return np.array(input_length_data).reshape(-1, 1).astype(np.int64)
def gen_input_label_data():
if input_lod_tensor_flag:
total_sequence_length_of_mini_batch = emission_lod_info_data[
-1][-1]
label_data = np.random.randint(
0, tag_num,
[total_sequence_length_of_mini_batch, 1]).astype(np.int64)
else:
label_data = np.random.randint(
0, tag_num,
[sequence_num, max_sequence_length]).astype(np.int64)
return label_data
def gen_inputs():
inputs = {
"Emission": ["input_emission_data"],
"Transition": ["input_transition_data"]
}
inputs_tensor = {
"input_emission_data": TensorConfig(
data_gen=partial(gen_input_emission_data),
lod=emission_lod_info_data),
"input_transition_data":
TensorConfig(data_gen=partial(gen_input_transition_data))
}
if has_label_input_flag:
inputs['Label'] = ["input_label_data"]
inputs_tensor['input_label_data'] = TensorConfig(
data_gen=partial(gen_input_label_data),
lod=emission_lod_info_data)
if not input_lod_tensor_flag:
inputs['Length'] = ['input_length_data']
inputs_tensor['input_length_data'] = TensorConfig(
data_gen=partial(gen_input_length_data))
return inputs, inputs_tensor
inputs, inputs_tensor = gen_inputs()
crf_decoding_op = OpConfig(
type="crf_decoding",
inputs=inputs,
outputs={"ViterbiPath": ["viterbi_path"]},
attrs={})
crf_decoding_op.outputs_dtype = {"viterbi_path": np.int64}
program_config = ProgramConfig(
ops=[crf_decoding_op],
weights={},
inputs=inputs_tensor,
outputs=["viterbi_path"])
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(self, draw):
if self.get_target() == "OpenCL":
in_shape = draw(
st.lists(st.integers(min_value=1, max_value=8),
min_size=4,
max_size=4))
else:
in_shape = draw(
st.lists(st.integers(min_value=1, max_value=8),
min_size=2,
max_size=4))
expand_shape = draw(
st.lists(st.integers(min_value=1, max_value=4),
min_size=len(in_shape),
max_size=len(in_shape)))
with_tensor = draw(st.sampled_from([True, False]))
def generate_shape(*args, **kwargs):
return np.array(expand_shape).astype(np.int32)
def generate_input(*args, **kwargs):
if kwargs["type"] == "int32":
return np.random.randint(kwargs["low"], kwargs["high"],
kwargs["shape"]).astype(np.int32)
elif kwargs["type"] == "int64":
return np.random.randint(kwargs["low"], kwargs["high"],
kwargs["shape"]).astype(np.int64)
elif kwargs["type"] == "float32":
return (kwargs["high"] - kwargs["low"]) * np.random.random(
kwargs["shape"]).astype(np.float32) + kwargs["low"]
input_type = draw(st.sampled_from(["float32", "int32", "int64"]))
def gnerate_inputs(with_tensor):
inputs1 = {}
inputs2 = {}
if (with_tensor):
inputs1 = {"X": ["input_data"], "ExpandTimes": ["expand_data"]}
inputs2 = {
"input_data":
TensorConfig(data_gen=partial(generate_input,
type=input_type,
low=-10,
high=10,
shape=in_shape)),
"expand_data":
TensorConfig(data_gen=partial(generate_shape))
}
else:
inputs1 = {"X": ["input_data"]}
inputs2 = {
"input_data":
TensorConfig(data_gen=partial(generate_input,
type=input_type,
low=-10,
high=10,
shape=in_shape))
}
return [inputs1, inputs2]
attr_shape = draw(
st.lists(st.integers(min_value=1, max_value=8),
min_size=len(in_shape),
max_size=len(in_shape)))
inputs = gnerate_inputs(with_tensor)
expand_op = OpConfig(type="expand",
inputs=inputs[0],
outputs={"Out": ["output_data"]},
attrs={"expand_times": attr_shape})
expand_op.outputs_dtype = {"output_data": input_type}
program_config = ProgramConfig(ops=[expand_op],
weights={},
inputs=inputs[1],
outputs=["output_data"])
return program_config
def sample_program_configs(self, draw):
in_shape = draw(st.sampled_from([[1, 1, 1], [2, 1, 4]]))
Shape = draw(st.sampled_from([[2, 4, 4], [3, 2, 3, 4]]))
expand_shape = draw(st.sampled_from([[2, 5, 4], [2, 3, 4]]))
with_Shape = draw(st.sampled_from([True, False]))
#todo daming5432 input vector tensor
with_expand_shape = draw(st.booleans())
def generate_shape(*args, **kwargs):
return np.array(Shape).astype(np.int32)
def generate_expand_shape(i, *args, **kwargs):
return np.array([expand_shape[i]]).astype(np.int32)
def generate_input(*args, **kwargs):
if kwargs["type"] == "int32":
return np.random.randint(kwargs["low"], kwargs["high"],
kwargs["shape"]).astype(np.int32)
elif kwargs["type"] == "int64":
return np.random.randint(kwargs["low"], kwargs["high"],
kwargs["shape"]).astype(np.int64)
elif kwargs["type"] == "float32":
return (kwargs["high"] - kwargs["low"]) * np.random.random(
kwargs["shape"]).astype(np.float32) + kwargs["low"]
input_type = draw(st.sampled_from(["float32", "int64", "int32"]))
def gnerate_inputs(with_Shape, with_expand_shape):
inputs1 = {}
inputs2 = {}
# with_Shape has a higher priority than expand_shapes_tensor
if (with_Shape):
inputs1 = {
"X": ["input_data"],
"Shape": ["shape_data"],
}
inputs2 = {
"input_data":
TensorConfig(data_gen=partial(generate_input,
type=input_type,
low=-10,
high=10,
shape=in_shape)),
"shape_data":
TensorConfig(data_gen=partial(generate_shape))
}
elif ((not with_Shape) and with_expand_shape):
inputs1 = {
"X": ["input_data"],
"expand_shapes_tensor":
["expand_data0", "expand_data1", "expand_data2"]
}
inputs2 = {
"input_data":
TensorConfig(data_gen=partial(generate_input,
type=input_type,
low=-10,
high=10,
shape=in_shape)),
"expand_data0":
TensorConfig(data_gen=partial(generate_expand_shape, 0)),
"expand_data1":
TensorConfig(data_gen=partial(generate_expand_shape, 1)),
"expand_data2":
TensorConfig(data_gen=partial(generate_expand_shape, 2))
}
elif (with_Shape and (not with_expand_shape)):
inputs1 = {"X": ["input_data"], "Shape": ["shape_data"]}
inputs2 = {
"input_data":
TensorConfig(data_gen=partial(generate_input,
type=input_type,
low=-10,
high=10,
shape=in_shape)),
"shape_data":
TensorConfig(data_gen=partial(generate_shape))
}
else:
inputs1 = {"X": ["input_data"]}
inputs2 = {
"input_data":
TensorConfig(data_gen=partial(generate_input,
type=input_type,
low=-10,
high=10,
shape=in_shape))
}
return [inputs1, inputs2]
attr_shape = draw(
st.sampled_from([[2, 3, 4], [2, 4, 4], [2, 2, 3, 4], [3, 2, 5,
4]]))
inputs = gnerate_inputs(with_Shape, with_expand_shape)
expand_v2_op = OpConfig(type="expand_v2",
inputs=inputs[0],
outputs={"Out": ["output_data"]},
attrs={"shape": attr_shape})
expand_v2_op.outputs_dtype = {"output_data": input_type}
program_config = ProgramConfig(ops=[expand_v2_op],
weights={},
inputs=inputs[1],
outputs=["output_data"])
return program_config
def sample_program_configs(self, draw):
in_shape = draw(
st.lists(
st.integers(
min_value=3, max_value=64), min_size=2, max_size=4))
op_type_str = draw(
st.sampled_from(
["logical_and", "logical_not", "logical_or", "logical_xor"]))
def generate_input_x():
return np.random.choice(a=[0, 1], size=in_shape).astype(np.int32)
def generate_input_y():
return np.random.choice(a=[0, 1], size=in_shape).astype(np.int32)
cast_x = OpConfig(
type="cast",
inputs={"X": ["input_data_x"], },
outputs={"Out": ["cast_data_x"], },
attrs={"in_dtype": int(2),
"out_dtype": int(0)})
cast_x.outputs_dtype = {"cast_data_x": np.bool_}
cast_y = OpConfig(
type="cast",
inputs={"X": ["input_data_y"], },
outputs={"Out": ["cast_data_y"], },
attrs={"in_dtype": int(2),
"out_dtype": int(0)})
cast_y.outputs_dtype = {"cast_data_y": np.bool_}
# two args
build_ops = OpConfig(
type=op_type_str,
inputs={"X": ["cast_data_x"],
"Y": ["cast_data_y"]},
outputs={"Out": ["output_data"], },
attrs={})
build_ops.outputs_dtype = {"output_data": np.bool_}
#one args
build_op = OpConfig(
type="logical_not",
inputs={"X": ["cast_data_x"]},
outputs={"Out": ["output_data"], },
attrs={})
build_op.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)})
cast_out.outputs_dtype = {"cast_data_out": np.int32}
tmp_ops = []
if op_type_str == "logical_not":
tmp_ops = [cast_x, build_op, cast_out]
else:
tmp_ops = [cast_x, cast_y, build_ops, cast_out]
program_config = ProgramConfig(
ops=tmp_ops,
weights={},
inputs={
"input_data_x":
TensorConfig(data_gen=partial(generate_input_x)),
"input_data_y":
TensorConfig(data_gen=partial(generate_input_y)),
},
outputs=["cast_data_out"])
return program_config
def sample_program_configs(self, draw):
in_shape = draw(
st.lists(st.integers(min_value=6, max_value=64),
min_size=4,
max_size=4))
idx_shape = draw(
st.lists(st.integers(min_value=1, max_value=5),
min_size=1,
max_size=1))
dim_data = draw(st.sampled_from([1, 2, 3]))
type_str = draw(
st.sampled_from(
["type_float", "type_int", "type_short", "type_char"]))
def generate_input1(*args, **kwargs):
return np.random.random(in_shape).astype(np.float32)
def generate_input2(*args, **kwargs):
return np.random.randint(low=1, high=100,
size=in_shape).astype(np.int32)
def generate_input3(*args, **kwargs):
return np.random.randint(low=1, high=100,
size=in_shape).astype(np.int16)
def generate_input4(*args, **kwargs):
return np.random.randint(low=1, high=100,
size=in_shape).astype(np.int8)
def generate_idx(*args, **kwargs):
return np.random.randint(low=1, high=5,
size=idx_shape).astype(np.int64)
build_ops = OpConfig(type="index_select",
inputs={
"X": ["input_data"],
"Index": ["idx"]
},
outputs={
"Out": ["output_data"],
},
attrs={
"dim": dim_data,
})
tmp_input = {}
if type_str == "type_float":
tmp_input = {
"input_data": TensorConfig(data_gen=partial(generate_input1)),
"idx": TensorConfig(data_gen=partial(generate_idx)),
}
elif type_str == "type_int":
build_ops.outputs_dtype = {"output_data": np.int32}
tmp_input = {
"input_data": TensorConfig(data_gen=partial(generate_input2)),
"idx": TensorConfig(data_gen=partial(generate_idx)),
}
elif type_str == "type_short":
build_ops.outputs_dtype = {"output_data": np.int16}
tmp_input = {
"input_data": TensorConfig(data_gen=partial(generate_input3)),
"idx": TensorConfig(data_gen=partial(generate_idx)),
}
elif type_str == "type_char":
build_ops.outputs_dtype = {"output_data": np.int8}
tmp_input = {
"input_data": TensorConfig(data_gen=partial(generate_input4)),
"idx": TensorConfig(data_gen=partial(generate_idx)),
}
program_config = ProgramConfig(ops=[build_ops],
weights={},
inputs=tmp_input,
outputs=["output_data"])
return program_config
def sample_program_configs(self, draw):
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_shape = draw(
st.lists(st.integers(min_value=3, max_value=5),
min_size=1,
max_size=4))
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)
k_data = draw(st.integers(min_value=1, max_value=2))
axis_data = draw(st.integers(min_value=0, max_value=1))
choose_k = draw(st.sampled_from(["k", "K"]))
inputs = {"X": ["X_data"]}
def generate_K_data():
if (choose_k == "K"):
inputs["K"] = ["K_data"]
a = np.array([k_data]).astype(np.int32)
return a
else:
return np.random.randint(1, 5, []).astype(np.int32)
assume(k_data <= in_shape[-1])
assume(axis_data < len(in_shape))
# Lite does not have these two attributes
largest_data = draw(st.booleans())
sorted_data = draw(st.booleans())
top_k_v2_op = OpConfig(
type="top_k_v2",
inputs=inputs,
outputs={
"Out": ["Out_data"],
"Indices": ["Indices_data"]
},
attrs={
"k": k_data,
"axis": axis_data,
#"largest": largest_data,
#"sorted": sorted_data
})
top_k_v2_op.outputs_dtype = {"Out_data": in_dtype}
program_config = ProgramConfig(
ops=[top_k_v2_op],
weights={},
inputs={
"X_data": TensorConfig(data_gen=partial(generate_X_data)),
"K_data": TensorConfig(data_gen=partial(generate_K_data))
},
outputs=["Out_data", "Indices_data"])
return program_config
def sample_program_configs(self, draw):
in_shape = 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(["less_equal", "less_than"]))
process_type = draw(
st.sampled_from(["type_int64", "type_float", "type_int32"]))
if axis == -1:
in_shape_y = in_shape
else:
in_shape_y = in_shape[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)
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
})
build_ops.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)
})
cast_out.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