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