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