def setUp(self): self.set_mlu() self.place = paddle.MLUPlace(0) x = np.random.random(size=(10, 7)).astype(typename) y = np.random.random(size=(10, 7)).astype(typename) out = callback(x, y) self.inputs = {'X': x, 'Y': y} self.outputs = {'Out': out} self.op_type = op_type
def setUp(self): self.set_mlu() self.op_type = "leaky_relu" self.place = paddle.MLUPlace(0) self.init_dtype() np.random.seed(SEED) self.set_inputs() self.set_attrs() self.set_outputs()
def _test(self, run_mlu=True): main_prog = paddle.static.Program() startup_prog = paddle.static.Program() main_prog.random_seed = SEED startup_prog.random_seed = SEED np.random.seed(SEED) a_np = np.random.random(size=(32, 32)).astype('float32') b_np = np.random.random(size=(32, 32)).astype('float32') label_np = np.random.randint(2, size=(32, 1)).astype('int64') with paddle.static.program_guard(main_prog, startup_prog): a = paddle.static.data(name="a", shape=[32, 32], dtype='float32') b = paddle.static.data(name="b", shape=[32, 32], dtype='float32') label = paddle.static.data(name="label", shape=[32, 1], dtype='int64') c = paddle.multiply(a, b) fc_1 = fluid.layers.fc(input=c, size=128) fc_1_gelu = fluid.layers.gelu(fc_1) prediction = fluid.layers.fc(input=fc_1_gelu, size=2, act='softmax') cost = fluid.layers.cross_entropy(input=prediction, label=label) loss = fluid.layers.reduce_mean(cost) sgd = fluid.optimizer.SGD(learning_rate=0.01) sgd.minimize(loss) if run_mlu: place = paddle.MLUPlace(0) else: place = paddle.CPUPlace() exe = paddle.static.Executor(place) exe.run(startup_prog) print("Start run on {}".format(place)) for epoch in range(100): pred_res, loss_res = exe.run(main_prog, feed={ "a": a_np, "b": b_np, "label": label_np }, fetch_list=[prediction, loss]) if epoch % 10 == 0: print("Epoch {} | Prediction[0]: {}, Loss: {}".format( epoch, pred_res[0], loss_res)) return pred_res, loss_res
def setUp(self): self.op_type = "gather" self.place = paddle.MLUPlace(0) self.__class__.use_mlu = True self.python_api = paddle.gather self.config() xnp = np.random.random(self.x_shape).astype(self.x_type) self.inputs = { 'X': xnp, 'Index': np.array(self.index).astype(self.index_type) } self.outputs = {'Out': self.inputs["X"][self.inputs["Index"]]}
def setUp(self): self.set_mlu() self.place = paddle.MLUPlace(0) self.op_type = "mean" self.init_dtype() x = np.random.random([3, 200]).astype(self.dtype) self.inputs = {'X': x} self.attrs = {} np_out = np.mean(x) self.outputs = {'Out': np_out}
def setUp(self): self.set_mlu() self.op_type = "relu" self.place = paddle.MLUPlace(0) self.init_dtype() np.random.seed(SEED) x = np.array([0.1, -0.1, -1.0]).astype(self.dtype) out = np.array([0.1, 0.0, 0.0]).astype(self.dtype) self.inputs = {'X': OpTest.np_dtype_to_fluid_dtype(x)} self.attrs = {} self.outputs = {'Out': out}
def setUp(self): self.set_mlu() self.op_type = "gelu" self.place = paddle.MLUPlace(0) self.init_dtype() np.random.seed(SEED) x = np.random.uniform(1, 2, [3, 4]).astype(self.dtype) out = np_gelu(x) self.inputs = {'X': OpTest.np_dtype_to_fluid_dtype(x)} self.attrs = {} self.outputs = {'Out': out}
def setUp(self): self.set_mlu() self.init_dtype() self.op_type = "sum" self.place = paddle.MLUPlace(0) x0 = np.random.random((3, 3)).astype(self.dtype) self.inputs = {'X': [("x0", x0)]} y = x0 self.outputs = {'Out': y} self.attrs = {'use_mkldnn': False}
def test_out2(self): with fluid.dygraph.guard(paddle.MLUPlace(0)): input_1 = np.random.random([4, 6, 6]).astype("int32") # input is a variable which shape is [4, 6, 6] input = fluid.dygraph.to_variable(input_1) x0, x1, x2 = paddle.split(input, num_or_sections=[1, 2, 3], axis=1) x0_out = x0.numpy() x1_out = x1.numpy() x2_out = x2.numpy() ex_x0, ex_x1, ex_x2 = np.split(input_1, (1, 3), axis=1) self.assertTrue(np.allclose(ex_x0, x0_out)) self.assertTrue(np.allclose(ex_x1, x1_out)) self.assertTrue(np.allclose(ex_x2, x2_out))
def setUp(self): self.op_type = "slice" self.__class__.use_mlu = True self.place = paddle.MLUPlace(0) self.config() self.inputs = {'Input': self.input} self.outputs = {'Out': self.out} self.attrs = { 'axes': self.axes, 'starts': self.starts, 'ends': self.ends, 'infer_flags': self.infer_flags }
def test_static_api(self): paddle.enable_static() np_x = np.random.rand(2, 3, 4, 4).astype('float32') main_prog = paddle.static.Program() with paddle.static.program_guard(main_prog, paddle.static.Program()): x = paddle.static.data(name="x", shape=[2, 3, 4, 4], dtype='float32') out = self.execute_api(x, start_axis=-2, stop_axis=-1) exe = paddle.static.Executor(place=paddle.MLUPlace(0)) fetch_out = exe.run(main_prog, feed={"x": np_x}, fetch_list=[out]) self.assertTrue((2, 3, 16) == fetch_out[0].shape)
def setUp(self): self.set_mlu() self.op_type = "relu6" self.place = paddle.MLUPlace(0) self.init_dtype() np.random.seed(SEED) x = np.random.uniform(-10, -1, [10, 12]).astype(self.dtype) x[np.abs(x) < 0.005] = 0.02 out = ref_relu6(x) self.inputs = {'X': OpTest.np_dtype_to_fluid_dtype(x)} self.attrs = {'threshold': 6.0} self.outputs = {'Out': out}
def setUp(self): self.set_mlu() self.op_type = "flatten_contiguous_range" self.place = paddle.MLUPlace(0) self.start_axis = 0 self.stop_axis = -1 self.dtype = np.float64 self.init_test_case() self.inputs = {"X": np.random.random(self.in_shape).astype(self.dtype)} self.init_attrs() self.outputs = { "Out": self.inputs["X"].reshape(self.new_shape), "XShape": np.random.random(self.in_shape).astype("float32") }
def test_static_out(self): paddle.enable_static() with paddle.static.program_guard(paddle.static.Program()): x = paddle.static.data(name='x', shape=[2, 3, 4], dtype='float32') x_trans1 = paddle.transpose(x, perm=[1, 0, 2]) x_trans2 = paddle.transpose(x, perm=(2, 1, 0)) place = paddle.MLUPlace(0) exe = paddle.static.Executor(place) x_np = np.random.random([2, 3, 4]).astype("float32") result1, result2 = exe.run(feed={"x": x_np}, fetch_list=[x_trans1, x_trans2]) expected_result1 = np.transpose(x_np, [1, 0, 2]) expected_result2 = np.transpose(x_np, (2, 1, 0)) np.testing.assert_array_equal(result1, expected_result1) np.testing.assert_array_equal(result2, expected_result2)
def setUp(self): self.op_type = "softmax" self.place = paddle.MLUPlace(0) self.dtype = np.float32 self.init_kernel_type() self.shape = self.get_x_shape() self.axis = self.get_axis() np.random.seed(0) x = np.random.uniform(0.1, 1, self.shape).astype(self.dtype) out = np.apply_along_axis(stable_softmax, self.axis, x) self.inputs = {'X': OpTest.np_dtype_to_fluid_dtype(x)} self.outputs = {'Out': out} self.attrs = { 'axis': self.axis, }
def setUp(self): self.op_type = "slice" self.__class__.use_mlu = True self.place = paddle.MLUPlace(0) self.config() self.inputs = { 'Input': self.input, "StartsTensor": np.array( self.starts, dtype="int32") } self.outputs = {'Out': self.out} self.attrs = { 'axes': self.axes, #'starts': self.starts, 'ends': self.ends, 'infer_flags': self.infer_flags, 'decrease_axis': self.decrease_axis, }
def setUp(self): self.set_mlu() self.init_dtype() self.op_type = "sum" self.place = paddle.MLUPlace(0) x0 = np.random.random((3, 3)).astype(self.dtype) x1 = np.random.random((3, 3)).astype(self.dtype) x2 = np.random.random((3, 3)).astype(self.dtype) x3 = np.random.random((3, 3)).astype(self.dtype) self.inputs = {'X': [("x0", x0), ("x1", x1), ("x2", x2), ("x3", x3)]} # There will be a problem if just using `y=x0+x1+x2+x3` to calculate the # summation result as the reference standard result. The reason is that # numpy's fp16 data has precision loss when doing `add` operation. # For example, the results of `x0+x1+x2+x3` is different from that of # `x3+x2+x1+x0` if the dtype is fp16. # Therefore, converting the input to fp32 for calculation. y = (x0.astype(np.float32) + x1.astype(np.float32) + x2.astype(np.float32) + x3.astype(np.float32)).astype(self.dtype) self.outputs = {'Out': y} self.attrs = {'use_mkldnn': False}
def setUp(self): self.op_type = "slice" self.__class__.use_mlu = True self.place = paddle.MLUPlace(0) self.config() ends_tensor = [] for index, ele in enumerate(self.ends): ends_tensor.append(("y" + str(index), np.ones( (1)).astype('int32') * ele)) self.inputs = { 'Input': self.input, "StartsTensor": np.array( self.starts, dtype="int32"), 'EndsTensorList': ends_tensor } self.outputs = {'Out': self.out} self.attrs = { 'axes': self.axes, #'starts': self.starts, 'ends': self.ends_infer, 'infer_flags': self.infer_flags }
def test_Negative(): paddle.disable_static(paddle.MLUPlace(0)) img = paddle.to_tensor(x) out = paddle.flatten(img, start_axis=-2, stop_axis=-1) return out.numpy().shape
def set_mlu(self): self.__class__.use_mlu = True self.place = paddle.MLUPlace(0)
def setUp(self): self.place = paddle.MLUPlace(0) self.x_np = np.random.uniform(-1., 1., [2, 3, 4, 5]).astype('float32') self.out_ref = np.apply_along_axis(stable_softmax, -1, self.x_np) self.executed_api()