test_cumsum_op.py 14.7 KB
Newer Older
1
#   Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
E
emailweixu 已提交
2 3 4 5 6 7 8 9 10 11 12 13 14
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

15 16
from __future__ import print_function

W
WangZhen 已提交
17
import os
E
emailweixu 已提交
18
import unittest
W
WangZhen 已提交
19
import tempfile
E
emailweixu 已提交
20
import numpy as np
21
from op_test import OpTest
22
import paddle
23 24 25
import paddle.fluid.core as core
import paddle.fluid as fluid
from paddle.fluid import compiler, Program, program_guard
W
WangZhen 已提交
26
import paddle.inference as paddle_infer
27 28 29
import gradient_checker
from decorator_helper import prog_scope
import paddle.fluid.layers as layers
30 31 32


class TestCumsumOp(unittest.TestCase):
33

34 35
    def run_cases(self):
        data_np = np.arange(12).reshape(3, 4)
Z
Zhou Wei 已提交
36
        data = paddle.to_tensor(data_np)
37 38 39

        y = paddle.cumsum(data)
        z = np.cumsum(data_np)
40
        np.testing.assert_array_equal(z, y.numpy())
41 42 43

        y = paddle.cumsum(data, axis=0)
        z = np.cumsum(data_np, axis=0)
44
        np.testing.assert_array_equal(z, y.numpy())
45 46 47

        y = paddle.cumsum(data, axis=-1)
        z = np.cumsum(data_np, axis=-1)
48
        np.testing.assert_array_equal(z, y.numpy())
49 50 51 52 53 54 55 56 57

        y = paddle.cumsum(data, dtype='float64')
        self.assertTrue(y.dtype == core.VarDesc.VarType.FP64)

        y = paddle.cumsum(data, dtype=np.int32)
        self.assertTrue(y.dtype == core.VarDesc.VarType.INT32)

        y = paddle.cumsum(data, axis=-2)
        z = np.cumsum(data_np, axis=-2)
58
        np.testing.assert_array_equal(z, y.numpy())
59 60 61 62

    def run_static(self, use_gpu=False):
        with fluid.program_guard(fluid.Program()):
            data_np = np.random.random((100, 100)).astype(np.float32)
63
            x = paddle.static.data('X', [100, 100])
64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80
            y = paddle.cumsum(x)
            y2 = paddle.cumsum(x, axis=0)
            y3 = paddle.cumsum(x, axis=-1)
            y4 = paddle.cumsum(x, dtype='float64')
            y5 = paddle.cumsum(x, dtype=np.int32)
            y6 = paddle.cumsum(x, axis=-2)

            place = fluid.CUDAPlace(0) if use_gpu else fluid.CPUPlace()
            exe = fluid.Executor(place)
            exe.run(fluid.default_startup_program())
            out = exe.run(feed={'X': data_np},
                          fetch_list=[
                              y.name, y2.name, y3.name, y4.name, y5.name,
                              y6.name
                          ])

            z = np.cumsum(data_np)
81
            np.testing.assert_allclose(z, out[0], rtol=1e-05)
82
            z = np.cumsum(data_np, axis=0)
83
            np.testing.assert_allclose(z, out[1], rtol=1e-05)
84
            z = np.cumsum(data_np, axis=-1)
85
            np.testing.assert_allclose(z, out[2], rtol=1e-05)
86 87 88
            self.assertTrue(out[3].dtype == np.float64)
            self.assertTrue(out[4].dtype == np.int32)
            z = np.cumsum(data_np, axis=-2)
89
            np.testing.assert_allclose(z, out[5], rtol=1e-05)
90 91

    def test_cpu(self):
92 93 94
        paddle.disable_static(paddle.fluid.CPUPlace())
        self.run_cases()
        paddle.enable_static()
95 96 97 98 99 100

        self.run_static()

    def test_gpu(self):
        if not fluid.core.is_compiled_with_cuda():
            return
101 102 103
        paddle.disable_static(paddle.fluid.CUDAPlace(0))
        self.run_cases()
        paddle.enable_static()
104 105 106 107 108

        self.run_static(use_gpu=True)

    def test_name(self):
        with fluid.program_guard(fluid.Program()):
109
            x = paddle.static.data('x', [3, 4])
110 111
            y = paddle.cumsum(x, name='out')
            self.assertTrue('out' in y.name)
E
emailweixu 已提交
112 113 114


class TestSumOp1(OpTest):
115

E
emailweixu 已提交
116 117 118 119 120 121 122
    def setUp(self):
        self.op_type = "cumsum"
        self.attrs = {'axis': 2}
        self.inputs = {'X': np.random.random((5, 6, 10)).astype("float64")}
        self.outputs = {'Out': self.inputs['X'].cumsum(axis=2)}

    def test_check_output(self):
123
        self.check_output()
E
emailweixu 已提交
124 125

    def test_check_grad(self):
126
        self.check_grad(['X'], 'Out')
E
emailweixu 已提交
127 128 129


class TestSumOp2(OpTest):
130

E
emailweixu 已提交
131 132 133 134 135
    def setUp(self):
        self.op_type = "cumsum"
        self.attrs = {'axis': -1, 'reverse': True}
        self.inputs = {'X': np.random.random((5, 6, 10)).astype("float64")}
        self.outputs = {
136 137
            'Out': np.flip(np.flip(self.inputs['X'], axis=2).cumsum(axis=2),
                           axis=2)
E
emailweixu 已提交
138 139 140
        }

    def test_check_output(self):
141
        self.check_output()
E
emailweixu 已提交
142 143

    def test_check_grad(self):
144
        self.check_grad(['X'], 'Out')
E
emailweixu 已提交
145 146 147


class TestSumOp3(OpTest):
148

E
emailweixu 已提交
149 150 151 152 153 154 155
    def setUp(self):
        self.op_type = "cumsum"
        self.attrs = {'axis': 1}
        self.inputs = {'X': np.random.random((5, 6, 10)).astype("float64")}
        self.outputs = {'Out': self.inputs['X'].cumsum(axis=1)}

    def test_check_output(self):
156
        self.check_output()
E
emailweixu 已提交
157 158

    def test_check_grad(self):
159
        self.check_grad(['X'], 'Out')
E
emailweixu 已提交
160 161 162


class TestSumOp4(OpTest):
163

E
emailweixu 已提交
164 165 166 167 168 169 170
    def setUp(self):
        self.op_type = "cumsum"
        self.attrs = {'axis': 0}
        self.inputs = {'X': np.random.random((5, 6, 10)).astype("float64")}
        self.outputs = {'Out': self.inputs['X'].cumsum(axis=0)}

    def test_check_output(self):
171
        self.check_output()
E
emailweixu 已提交
172 173

    def test_check_grad(self):
174
        self.check_grad(['X'], 'Out')
E
emailweixu 已提交
175 176 177


class TestSumOp5(OpTest):
178

E
emailweixu 已提交
179 180
    def setUp(self):
        self.op_type = "cumsum"
Z
zhupengyang 已提交
181
        self.inputs = {'X': np.random.random((5, 20)).astype("float64")}
E
emailweixu 已提交
182 183 184
        self.outputs = {'Out': self.inputs['X'].cumsum(axis=1)}

    def test_check_output(self):
185
        self.check_output()
E
emailweixu 已提交
186 187

    def test_check_grad(self):
188
        self.check_grad(['X'], 'Out')
E
emailweixu 已提交
189 190 191


class TestSumOp7(OpTest):
192

E
emailweixu 已提交
193 194
    def setUp(self):
        self.op_type = "cumsum"
Z
zhupengyang 已提交
195
        self.inputs = {'X': np.random.random((100)).astype("float64")}
E
emailweixu 已提交
196 197 198
        self.outputs = {'Out': self.inputs['X'].cumsum(axis=0)}

    def test_check_output(self):
199
        self.check_output()
E
emailweixu 已提交
200 201

    def test_check_grad(self):
202
        self.check_grad(['X'], 'Out')
E
emailweixu 已提交
203 204


205
class TestSumOpExclusive1(OpTest):
206

E
emailweixu 已提交
207 208 209
    def setUp(self):
        self.op_type = "cumsum"
        self.attrs = {'axis': 2, "exclusive": True}
210
        a = np.random.random((4, 5, 65)).astype("float64")
E
emailweixu 已提交
211 212
        self.inputs = {'X': a}
        self.outputs = {
213 214 215 216
            'Out':
            np.concatenate((np.zeros(
                (4, 5, 1), dtype=np.float64), a[:, :, :-1].cumsum(axis=2)),
                           axis=2)
E
emailweixu 已提交
217 218 219
        }

    def test_check_output(self):
220
        self.check_output()
E
emailweixu 已提交
221

222 223

class TestSumOpExclusive2(OpTest):
224

225 226 227 228 229 230
    def setUp(self):
        self.op_type = "cumsum"
        self.attrs = {'axis': 2, "exclusive": True}
        a = np.random.random((1, 1, 888)).astype("float64")
        self.inputs = {'X': a}
        self.outputs = {
231 232 233 234
            'Out':
            np.concatenate((np.zeros(
                (1, 1, 1), dtype=np.float64), a[:, :, :-1].cumsum(axis=2)),
                           axis=2)
235 236 237 238 239 240 241
        }

    def test_check_output(self):
        self.check_output()


class TestSumOpExclusive3(OpTest):
242

243 244 245 246 247 248
    def setUp(self):
        self.op_type = "cumsum"
        self.attrs = {'axis': 2, "exclusive": True}
        a = np.random.random((4, 5, 888)).astype("float32")
        self.inputs = {'X': a}
        self.outputs = {
249 250 251 252
            'Out':
            np.concatenate((np.zeros(
                (4, 5, 1), dtype=np.float64), a[:, :, :-1].cumsum(axis=2)),
                           axis=2)
253 254 255 256 257 258 259
        }

    def test_check_output(self):
        self.check_output()


class TestSumOpExclusive4(OpTest):
260

261 262 263 264 265 266
    def setUp(self):
        self.op_type = "cumsum"
        self.attrs = {'axis': 2, "exclusive": True}
        a = np.random.random((1, 1, 3049)).astype("float64")
        self.inputs = {'X': a}
        self.outputs = {
267 268 269 270
            'Out':
            np.concatenate((np.zeros(
                (1, 1, 1), dtype=np.float64), a[:, :, :-1].cumsum(axis=2)),
                           axis=2)
271 272 273 274 275 276 277
        }

    def test_check_output(self):
        self.check_output()


class TestSumOpExclusive5(OpTest):
278

279 280 281 282 283 284
    def setUp(self):
        self.op_type = "cumsum"
        self.attrs = {'axis': 2, "exclusive": True}
        a = np.random.random((4, 5, 3096)).astype("float64")
        self.inputs = {'X': a}
        self.outputs = {
285 286 287 288
            'Out':
            np.concatenate((np.zeros(
                (4, 5, 1), dtype=np.float64), a[:, :, :-1].cumsum(axis=2)),
                           axis=2)
289 290 291 292 293 294 295
        }

    def test_check_output(self):
        self.check_output()


class TestSumOpReverseExclusive(OpTest):
296

297 298 299 300 301 302 303
    def setUp(self):
        self.op_type = "cumsum"
        self.attrs = {'axis': 2, 'reverse': True, "exclusive": True}
        a = np.random.random((4, 5, 6)).astype("float64")
        self.inputs = {'X': a}
        a = np.flip(a, axis=2)
        self.outputs = {
304 305 306 307
            'Out':
            np.concatenate(
                (np.flip(a[:, :, :-1].cumsum(axis=2),
                         axis=2), np.zeros((4, 5, 1), dtype=np.float64)),
308 309 310 311 312
                axis=2)
        }

    def test_check_output(self):
        self.check_output()
E
emailweixu 已提交
313 314


315
class BadInputTest(unittest.TestCase):
316

317 318 319 320
    def test_error(self):
        with fluid.program_guard(fluid.Program()):

            def test_bad_x():
321
                data = [1, 2, 4]
322 323 324 325 326
                result = fluid.layers.cumsum(data, axis=0)

            self.assertRaises(TypeError, test_bad_x)


W
WangZhen 已提交
327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385
class TestTensorAxis(unittest.TestCase):

    def setUp(self):
        paddle.seed(2022)
        self.temp_dir = tempfile.TemporaryDirectory()
        self.save_path = os.path.join(self.temp_dir.name, 'tensor_axis_cumsum')
        self.place = paddle.CUDAPlace(
            0) if paddle.is_compiled_with_cuda() else paddle.CPUPlace()

    def test_dygraph(self):
        paddle.disable_static()
        x = np.random.randn(5, 6)
        axis = 1
        np_out = np.cumsum(x, axis)
        pd_out = paddle.cumsum(paddle.to_tensor(x),
                               axis=paddle.to_tensor([axis], dtype='int32'))
        np.testing.assert_allclose(np_out, pd_out.numpy())

    def test_static_and_infer(self):
        paddle.enable_static()
        np_x = np.random.randn(9, 10, 11).astype('float32')
        main_prog = paddle.static.Program()
        starup_prog = paddle.static.Program()
        with paddle.static.program_guard(main_prog, starup_prog):
            # run static
            x = paddle.static.data(shape=np_x.shape, name='x', dtype=np_x.dtype)
            print(x)
            linear = paddle.nn.Linear(np_x.shape[-1], np_x.shape[-1])
            linear_out = linear(x)
            relu_out = paddle.nn.functional.relu(linear_out)
            axis = paddle.full([1], 2, dtype='int64')
            out = paddle.cumsum(relu_out, axis=axis)

            exe = paddle.static.Executor(self.place)
            exe.run(starup_prog)
            static_out = exe.run(feed={'x': np_x}, fetch_list=[out])

            # run infer
            paddle.static.save_inference_model(self.save_path, [x], [out], exe)
            config = paddle_infer.Config(self.save_path + '.pdmodel',
                                         self.save_path + '.pdiparams')
            if paddle.is_compiled_with_cuda():
                config.enable_use_gpu(100, 0)
            else:
                config.disable_gpu()

            predictor = paddle_infer.create_predictor(config)
            input_names = predictor.get_input_names()
            input_handle = predictor.get_input_handle(input_names[0])
            fake_input = np_x
            input_handle.reshape(np_x.shape)
            input_handle.copy_from_cpu(fake_input)
            predictor.run()
            output_names = predictor.get_output_names()
            output_handle = predictor.get_output_handle(output_names[0])
            infer_out = output_handle.copy_to_cpu()
            np.testing.assert_allclose(static_out[0], infer_out)


386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459
class TestCumsumDoubleGradCheck(unittest.TestCase):

    def cumsum_wrapper(self, x):
        return paddle.cumsum(x[0], 0)

    @prog_scope()
    def func(self, place):
        # the shape of input variable should be clearly specified, not inlcude -1.
        eps = 0.005
        dtype = np.float64

        data = layers.data('data', [3, 4], False, dtype)
        data.persistable = True
        out = paddle.cumsum(data, 0)
        data_arr = np.random.uniform(-1, 1, data.shape).astype(dtype)

        gradient_checker.double_grad_check([data],
                                           out,
                                           x_init=[data_arr],
                                           place=place,
                                           eps=eps)
        fluid.set_flags({"FLAGS_retain_grad_for_all_tensor": True})
        gradient_checker.double_grad_check_for_dygraph(self.cumsum_wrapper,
                                                       [data],
                                                       out,
                                                       x_init=[data_arr],
                                                       place=place)

    def test_grad(self):
        paddle.enable_static()
        places = [fluid.CPUPlace()]
        if core.is_compiled_with_cuda():
            places.append(fluid.CUDAPlace(0))
        for p in places:
            self.func(p)


class TestCumsumTripleGradCheck(unittest.TestCase):

    def cumsum_wrapper(self, x):
        return paddle.cumsum(x[0], 0)

    @prog_scope()
    def func(self, place):
        # the shape of input variable should be clearly specified, not inlcude -1.
        eps = 0.005
        dtype = np.float32

        data = layers.data('data', [2, 3], False, dtype)
        data.persistable = True
        out = paddle.cumsum(data, 0)
        data_arr = np.random.uniform(-1, 1, data.shape).astype(dtype)

        gradient_checker.triple_grad_check([data],
                                           out,
                                           x_init=[data_arr],
                                           place=place,
                                           eps=eps)
        fluid.set_flags({"FLAGS_retain_grad_for_all_tensor": True})
        gradient_checker.triple_grad_check_for_dygraph(self.cumsum_wrapper,
                                                       [data],
                                                       out,
                                                       x_init=[data_arr],
                                                       place=place)

    def test_grad(self):
        paddle.enable_static()
        places = [fluid.CPUPlace()]
        if core.is_compiled_with_cuda():
            places.append(fluid.CUDAPlace(0))
        for p in places:
            self.func(p)


E
emailweixu 已提交
460 461
if __name__ == '__main__':
    unittest.main()