test_layers.py 112.9 KB
Newer Older
1
#   Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
D
dzhwinter 已提交
2
#
D
dzhwinter 已提交
3 4 5
# 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
D
dzhwinter 已提交
6
#
D
dzhwinter 已提交
7
#     http://www.apache.org/licenses/LICENSE-2.0
D
dzhwinter 已提交
8
#
D
dzhwinter 已提交
9 10 11 12 13 14
# 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
import contextlib
import inspect
Q
Qiao Longfei 已提交
17 18
import unittest

19
import numpy as np
20
from decorator_helper import prog_scope
21
from test_imperative_base import new_program_scope
22 23 24

import paddle
import paddle.fluid as fluid
25
import paddle.fluid.layers as layers
26
import paddle.fluid.nets as nets
27
import paddle.nn.functional as F
28
from paddle.fluid import core
29 30 31 32 33 34 35
from paddle.fluid.dygraph import base, nn, to_variable
from paddle.fluid.framework import (
    Program,
    _test_eager_guard,
    default_main_program,
    program_guard,
)
36
from paddle.tensor import random
37 38 39 40 41 42 43 44 45 46 47


class LayerTest(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.seed = 111

    @classmethod
    def tearDownClass(cls):
        pass

48 49 50 51 52 53 54 55
    def _get_place(self, force_to_use_cpu=False):
        # this option for ops that only have cpu kernel
        if force_to_use_cpu:
            return core.CPUPlace()
        else:
            if core.is_compiled_with_cuda():
                return core.CUDAPlace(0)
            return core.CPUPlace()
56 57 58 59

    @contextlib.contextmanager
    def static_graph(self):
        with new_program_scope():
C
cnn 已提交
60
            paddle.seed(self.seed)
L
Leo Chen 已提交
61
            paddle.framework.random._manual_program_seed(self.seed)
62 63
            yield

64 65 66
    def get_static_graph_result(
        self, feed, fetch_list, with_lod=False, force_to_use_cpu=False
    ):
67
        exe = fluid.Executor(self._get_place(force_to_use_cpu))
68
        exe.run(fluid.default_startup_program())
69 70 71 72 73 74
        return exe.run(
            fluid.default_main_program(),
            feed=feed,
            fetch_list=fetch_list,
            return_numpy=(not with_lod),
        )
75 76

    @contextlib.contextmanager
77
    def dynamic_graph(self, force_to_use_cpu=False):
L
lujun 已提交
78
        with fluid.dygraph.guard(
79 80
            self._get_place(force_to_use_cpu=force_to_use_cpu)
        ):
C
cnn 已提交
81
            paddle.seed(self.seed)
L
Leo Chen 已提交
82
            paddle.framework.random._manual_program_seed(self.seed)
83 84 85 86
            yield


class TestLayer(LayerTest):
87 88
    def test_custom_layer_with_kwargs(self):
        class CustomLayer(fluid.Layer):
89
            def __init__(self, input_size, linear1_size=4):
90
                super().__init__()
91
                self.linear1 = paddle.nn.Linear(
92 93
                    input_size, linear1_size, bias_attr=False
                )
94 95 96
                self.linear2 = paddle.nn.Linear(
                    linear1_size, 1, bias_attr=False
                )
97 98 99 100 101

            def forward(self, x, do_linear2=False):
                ret = self.linear1(x)
                if do_linear2:
                    ret = self.linear2(ret)
102 103 104
                return ret

        with self.dynamic_graph():
105 106 107 108 109
            with _test_eager_guard():
                inp = np.ones([3, 3], dtype='float32')
                x = base.to_variable(inp)
                custom = CustomLayer(input_size=3, linear1_size=2)
                ret = custom(x, do_linear2=False)
110
                np.testing.assert_array_equal(ret.numpy().shape, [3, 2])
111
                ret = custom(x, do_linear2=True)
112
                np.testing.assert_array_equal(ret.numpy().shape, [3, 1])
113 114
            inp = np.ones([3, 3], dtype='float32')
            x = base.to_variable(inp)
115 116
            custom = CustomLayer(input_size=3, linear1_size=2)
            ret = custom(x, do_linear2=False)
117
            np.testing.assert_array_equal(ret.numpy().shape, [3, 2])
118
            ret = custom(x, do_linear2=True)
119
            np.testing.assert_array_equal(ret.numpy().shape, [3, 1])
120

S
songyouwei 已提交
121 122 123
    def test_linear(self):
        inp = np.ones([3, 32, 32], dtype='float32')
        with self.static_graph():
124 125 126 127 128 129
            t = layers.data(
                name='data',
                shape=[3, 32, 32],
                dtype='float32',
                append_batch_size=False,
            )
130
            linear = paddle.nn.Linear(
131 132
                32, 4, bias_attr=fluid.initializer.ConstantInitializer(value=1)
            )
S
songyouwei 已提交
133
            ret = linear(t)
134 135 136
            static_ret = self.get_static_graph_result(
                feed={'data': inp}, fetch_list=[ret]
            )[0]
S
songyouwei 已提交
137
        with self.dynamic_graph():
138 139
            with _test_eager_guard():
                t = base.to_variable(inp)
140
                linear = paddle.nn.Linear(
141 142
                    32,
                    4,
143 144
                    bias_attr=fluid.initializer.ConstantInitializer(value=1),
                )
145 146 147
                dy_eager_ret = linear(t)
                dy_eager_ret_value = dy_eager_ret.numpy()

S
songyouwei 已提交
148
            t = base.to_variable(inp)
149
            linear = paddle.nn.Linear(
150 151
                32, 4, bias_attr=fluid.initializer.ConstantInitializer(value=1)
            )
S
songyouwei 已提交
152 153 154
            dy_ret = linear(t)
            dy_ret_value = dy_ret.numpy()

155 156
        np.testing.assert_array_equal(static_ret, dy_eager_ret_value)
        np.testing.assert_array_equal(static_ret, dy_ret_value)
S
songyouwei 已提交
157

158 159 160 161 162
        with self.static_graph():

            # the input of Linear must be Variable.
            def test_Variable():
                inp = np.ones([3, 32, 32], dtype='float32')
163
                linear = paddle.nn.Linear(
164 165
                    32,
                    4,
166 167
                    bias_attr=fluid.initializer.ConstantInitializer(value=1),
                )
168 169 170 171 172 173 174 175
                linear_ret1 = linear(inp)

            self.assertRaises(TypeError, test_Variable)

            # the input dtype of Linear must be float16 or float32 or float64
            # float16 only can be set on GPU place
            def test_type():
                inp = np.ones([3, 32, 32], dtype='int32')
176
                linear = paddle.nn.Linear(
177 178
                    32,
                    4,
179 180
                    bias_attr=fluid.initializer.ConstantInitializer(value=1),
                )
181 182 183 184 185 186 187
                linear_ret2 = linear(inp)

            self.assertRaises(TypeError, test_type)

    def test_Flatten(self):
        inp = np.ones([3, 4, 4, 5], dtype='float32')
        with self.static_graph():
188 189 190 191 192 193
            t = layers.data(
                name='data',
                shape=[3, 4, 4, 5],
                dtype='float32',
                append_batch_size=False,
            )
194
            flatten = paddle.nn.Flatten()
195
            ret = flatten(t)
196 197 198
            static_ret = self.get_static_graph_result(
                feed={'data': inp}, fetch_list=[ret]
            )[0]
199
        with self.dynamic_graph():
200 201
            with _test_eager_guard():
                t = base.to_variable(inp)
202
                flatten = paddle.nn.Flatten()
203 204 205
                dy_eager_ret = flatten(t)
                dy_eager_ret_value = dy_eager_ret.numpy()

206
            t = base.to_variable(inp)
207
            flatten = paddle.nn.Flatten()
208 209 210
            dy_ret = flatten(t)
            dy_ret_value = dy_ret.numpy()

211 212
        np.testing.assert_array_equal(static_ret, dy_eager_ret_value)
        np.testing.assert_array_equal(static_ret, dy_ret_value)
213 214 215 216 217 218

        with self.static_graph():

            # the input of Linear must be Variable.
            def test_Variable():
                inp = np.ones([3, 32, 32], dtype='float32')
219
                linear = paddle.nn.Linear(
220 221
                    32,
                    4,
222 223
                    bias_attr=fluid.initializer.ConstantInitializer(value=1),
                )
224 225 226 227 228 229 230 231
                linear_ret1 = linear(inp)

            self.assertRaises(TypeError, test_Variable)

            # the input dtype of Linear must be float16 or float32 or float64
            # float16 only can be set on GPU place
            def test_type():
                inp = np.ones([3, 32, 32], dtype='int32')
232
                linear = paddle.nn.Linear(
233 234
                    32,
                    4,
235 236
                    bias_attr=fluid.initializer.ConstantInitializer(value=1),
                )
237 238 239 240
                linear_ret2 = linear(inp)

            self.assertRaises(TypeError, test_type)

C
ceci3 已提交
241 242 243 244
    def test_SyncBatchNorm(self):
        if core.is_compiled_with_cuda():
            with self.static_graph():
                t = layers.data(name='t', shape=[-1, 3, 5, 5], dtype='float32')
C
ceci3 已提交
245
                my_sync_bn = paddle.nn.SyncBatchNorm(3)
C
ceci3 已提交
246 247
                ret = my_sync_bn(t)
                static_ret = self.get_static_graph_result(
248
                    feed={'t': np.ones([3, 3, 5, 5], dtype='float32')},
249 250
                    fetch_list=[ret],
                )[0]
C
ceci3 已提交
251 252

            with self.dynamic_graph():
253 254 255 256 257 258
                with _test_eager_guard():
                    t = np.ones([3, 3, 5, 5], dtype='float32')
                    my_syncbn = paddle.nn.SyncBatchNorm(3)
                    dy_eager_ret = my_syncbn(base.to_variable(t))
                    dy_eager_ret_value = dy_eager_ret.numpy()

C
ceci3 已提交
259 260 261 262
                t = np.ones([3, 3, 5, 5], dtype='float32')
                my_syncbn = paddle.nn.SyncBatchNorm(3)
                dy_ret = my_syncbn(base.to_variable(t))
                dy_ret_value = dy_ret.numpy()
263 264
            np.testing.assert_array_equal(static_ret, dy_ret_value)
            np.testing.assert_array_equal(static_ret, dy_eager_ret_value)
C
ceci3 已提交
265

266 267 268 269 270
    def test_relu(self):
        with self.static_graph():
            t = layers.data(name='t', shape=[3, 3], dtype='float32')
            ret = layers.relu(t)
            static_ret = self.get_static_graph_result(
271 272
                feed={'t': np.ones([3, 3], dtype='float32')}, fetch_list=[ret]
            )[0]
273 274

        with self.dynamic_graph():
275 276 277 278 279
            with _test_eager_guard():
                t = np.ones([3, 3], dtype='float32')
                dy_eager_ret = layers.relu(base.to_variable(t))
                dy_eager_ret_value = dy_eager_ret.numpy()

280 281
            t = np.ones([3, 3], dtype='float32')
            dy_ret = layers.relu(base.to_variable(t))
282
            dy_ret_value = dy_ret.numpy()
283

284 285
        np.testing.assert_allclose(static_ret, dy_ret_value, rtol=1e-05)
        np.testing.assert_allclose(static_ret, dy_eager_ret_value, rtol=1e-05)
C
ceci3 已提交
286

287 288 289 290
    def test_matmul(self):
        with self.static_graph():
            t = layers.data(name='t', shape=[3, 3], dtype='float32')
            t2 = layers.data(name='t2', shape=[3, 3], dtype='float32')
K
kangguangli 已提交
291
            ret = paddle.matmul(t, t2)
292 293 294 295 296 297 298
            static_ret = self.get_static_graph_result(
                feed={
                    't': np.ones([3, 3], dtype='float32'),
                    't2': np.ones([3, 3], dtype='float32'),
                },
                fetch_list=[ret],
            )[0]
299 300

        with self.dynamic_graph():
301 302 303
            with _test_eager_guard():
                t = np.ones([3, 3], dtype='float32')
                t2 = np.ones([3, 3], dtype='float32')
K
kangguangli 已提交
304
                dy_eager_ret = paddle.matmul(
305 306
                    base.to_variable(t), base.to_variable(t2)
                )
307 308
                dy_eager_ret_value = dy_eager_ret.numpy()

309 310
            t = np.ones([3, 3], dtype='float32')
            t2 = np.ones([3, 3], dtype='float32')
K
kangguangli 已提交
311
            dy_ret = paddle.matmul(base.to_variable(t), base.to_variable(t2))
312
            dy_ret_value = dy_ret.numpy()
313

314 315
        np.testing.assert_allclose(static_ret, dy_ret_value, rtol=1e-05)
        np.testing.assert_allclose(static_ret, dy_eager_ret_value, rtol=1e-05)
316

X
Xin Pan 已提交
317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332
    def test_elementwise_math(self):
        n = np.ones([3, 3], dtype='float32')
        n2 = np.ones([3, 3], dtype='float32') * 1.1
        n3 = np.ones([3, 3], dtype='float32') * 2
        n4 = np.ones([3, 3], dtype='float32') * 3
        n5 = np.ones([3, 3], dtype='float32') * 4
        n6 = np.ones([3, 3], dtype='float32') * 5

        with self.static_graph():
            t = layers.data(name='t', shape=[3, 3], dtype='float32')
            t2 = layers.data(name='t2', shape=[3, 3], dtype='float32')
            t3 = layers.data(name='t3', shape=[3, 3], dtype='float32')
            t4 = layers.data(name='t4', shape=[3, 3], dtype='float32')
            t5 = layers.data(name='t5', shape=[3, 3], dtype='float32')
            t6 = layers.data(name='t6', shape=[3, 3], dtype='float32')

333
            ret = paddle.add(t, t2)
334
            ret = paddle.pow(ret, t3)
335 336 337
            ret = paddle.divide(ret, t4)
            ret = paddle.subtract(ret, t5)
            ret = paddle.multiply(ret, t6)
X
Xin Pan 已提交
338

339 340 341 342
            static_ret = self.get_static_graph_result(
                feed={'t': n, 't2': n2, 't3': n3, 't4': n4, 't5': n5, 't6': n6},
                fetch_list=[ret],
            )[0]
X
Xin Pan 已提交
343 344

        with self.dynamic_graph():
345
            with _test_eager_guard():
346
                ret = paddle.add(to_variable(n), to_variable(n2))
347
                ret = paddle.pow(ret, to_variable(n3))
348 349 350
                ret = paddle.divide(ret, to_variable(n4))
                ret = paddle.subtract(ret, to_variable(n5))
                dy_eager_ret = paddle.multiply(ret, to_variable(n6))
351 352
                dy_eager_ret_value = dy_eager_ret.numpy()

353
            ret = paddle.add(to_variable(n), to_variable(n2))
354
            ret = paddle.pow(ret, to_variable(n3))
355 356 357
            ret = paddle.divide(ret, to_variable(n4))
            ret = paddle.subtract(ret, to_variable(n5))
            dy_ret = paddle.multiply(ret, to_variable(n6))
358
            dy_ret_value = dy_ret.numpy()
359

360 361
        np.testing.assert_allclose(static_ret, dy_ret_value, rtol=1e-05)
        np.testing.assert_allclose(static_ret, dy_eager_ret_value, rtol=1e-05)
X
Xin Pan 已提交
362 363 364 365 366 367

    def test_elementwise_minmax(self):
        n = np.ones([3, 3], dtype='float32')
        n2 = np.ones([3, 3], dtype='float32') * 2

        with self.dynamic_graph():
368
            with _test_eager_guard():
369
                min_eager_ret = paddle.minimum(to_variable(n), to_variable(n2))
H
HongyuJia 已提交
370
                max_eager_ret = paddle.maximum(to_variable(n), to_variable(n2))
371 372 373
                min_eager_ret_value = min_eager_ret.numpy()
                max_eager_ret_value = max_eager_ret.numpy()

374
            min_ret = paddle.minimum(to_variable(n), to_variable(n2))
H
HongyuJia 已提交
375
            max_ret = paddle.maximum(to_variable(n), to_variable(n2))
376 377
            min_ret_value = min_ret.numpy()
            max_ret_value = max_ret.numpy()
X
Xin Pan 已提交
378

379 380 381 382
        np.testing.assert_allclose(n, min_ret_value, rtol=1e-05)
        np.testing.assert_allclose(n2, max_ret_value, rtol=1e-05)
        np.testing.assert_allclose(n, min_eager_ret_value, rtol=1e-05)
        np.testing.assert_allclose(n2, max_eager_ret_value, rtol=1e-05)
X
Xin Pan 已提交
383

384 385 386 387
    def test_conv2d_transpose(self):
        inp_np = np.arange(0, 24).reshape([2, 3, 2, 2]).astype('float32')
        with self.static_graph():
            img = layers.data(name='pixel', shape=[3, 2, 2], dtype='float32')
388
            out = paddle.static.nn.conv2d_transpose(
389 390
                input=img,
                num_filters=10,
391
                filter_size=27,
392
                act='sigmoid',
393 394 395 396 397
                bias_attr=fluid.initializer.ConstantInitializer(value=1),
            )
            static_rlt = self.get_static_graph_result(
                feed={'pixel': inp_np}, fetch_list=[out]
            )[0]
398 399
        with self.static_graph():
            img = layers.data(name='pixel', shape=[3, 2, 2], dtype='float32')
400 401 402 403
            conv2d_transpose = paddle.nn.Conv2DTranspose(
                3,
                10,
                27,
404 405
                bias_attr=fluid.initializer.ConstantInitializer(value=1),
            )
406
            out = conv2d_transpose(img)
407
            out = paddle.nn.functional.sigmoid(out)
408 409 410
            static_rlt2 = self.get_static_graph_result(
                feed={'pixel': inp_np}, fetch_list=[out]
            )[0]
411
        with self.dynamic_graph():
412
            with _test_eager_guard():
413 414 415 416
                conv2d_transpose = paddle.nn.Conv2DTranspose(
                    3,
                    10,
                    27,
417 418
                    bias_attr=fluid.initializer.ConstantInitializer(value=1),
                )
419
                dy_eager_rlt = conv2d_transpose(base.to_variable(inp_np))
420
                dy_eager_rlt = paddle.nn.functional.sigmoid(dy_eager_rlt)
421 422
                dy_eager_rlt_value = dy_eager_rlt.numpy()

423 424 425 426
            conv2d_transpose = paddle.nn.Conv2DTranspose(
                3,
                10,
                27,
427 428
                bias_attr=fluid.initializer.ConstantInitializer(value=1),
            )
429
            dy_rlt = conv2d_transpose(base.to_variable(inp_np))
430
            dy_rlt = paddle.nn.functional.sigmoid(dy_rlt)
431
            dy_rlt_value = dy_rlt.numpy()
432 433 434
        np.testing.assert_allclose(static_rlt2, static_rlt, rtol=1e-05)
        np.testing.assert_allclose(dy_rlt_value, static_rlt2, rtol=1e-05)
        np.testing.assert_allclose(dy_eager_rlt_value, static_rlt2, rtol=1e-05)
435

436
        with self.dynamic_graph():
437 438 439 440 441
            with _test_eager_guard():
                images = np.ones([2, 3, 5, 5], dtype='float32')
                custom_weight = np.random.randn(3, 3, 2, 2).astype("float32")
                weight_attr = fluid.ParamAttr(
                    initializer=fluid.initializer.NumpyArrayInitializer(
442 443 444
                        custom_weight
                    )
                )
445 446 447 448 449 450
                conv2d1 = paddle.nn.Conv2DTranspose(3, 3, [2, 2])
                conv2d2 = paddle.nn.Conv2DTranspose(
                    3,
                    3,
                    [2, 2],
                    weight_attr=weight_attr,
451
                )
452 453 454
                dy_ret1 = conv2d1(base.to_variable(images))
                dy_ret2 = conv2d2(base.to_variable(images))
                self.assertFalse(
455 456
                    np.array_equal(dy_ret1.numpy(), dy_ret2.numpy())
                )
457 458 459 460

                conv2d1_weight_np = conv2d1.weight.numpy()
                conv2d1_bias = conv2d1.bias
                self.assertFalse(
461 462
                    np.array_equal(conv2d1_weight_np, conv2d2.weight.numpy())
                )
463
                conv2d2.weight.set_value(conv2d1_weight_np)
464 465 466
                np.testing.assert_array_equal(
                    conv2d1_weight_np, conv2d2.weight.numpy()
                )
467 468 469
                conv2d2.bias.set_value(conv2d1_bias)
                dy_ret1 = conv2d1(base.to_variable(images))
                dy_ret2 = conv2d2(base.to_variable(images))
470
                np.testing.assert_array_equal(dy_ret1.numpy(), dy_ret2.numpy())
471 472 473

                conv2d2.weight = conv2d1.weight
                conv2d2.bias = conv2d1.bias
474 475 476 477 478 479
                np.testing.assert_array_equal(
                    conv2d1.weight.numpy(), conv2d2.weight.numpy()
                )
                np.testing.assert_array_equal(
                    conv2d1.bias.numpy(), conv2d2.bias.numpy()
                )
480

481 482
            images = np.ones([2, 3, 5, 5], dtype='float32')
            custom_weight = np.random.randn(3, 3, 2, 2).astype("float32")
483 484 485 486 487
            weight_attr = fluid.ParamAttr(
                initializer=fluid.initializer.NumpyArrayInitializer(
                    custom_weight
                )
            )
488 489 490 491 492 493
            conv2d1 = paddle.nn.Conv2DTranspose(3, 3, [2, 2])
            conv2d2 = paddle.nn.Conv2DTranspose(
                3,
                3,
                [2, 2],
                weight_attr=weight_attr,
494
            )
495 496 497 498 499 500 501
            dy_ret1 = conv2d1(base.to_variable(images))
            dy_ret2 = conv2d2(base.to_variable(images))
            self.assertFalse(np.array_equal(dy_ret1.numpy(), dy_ret2.numpy()))

            conv2d1_weight_np = conv2d1.weight.numpy()
            conv2d1_bias = conv2d1.bias
            self.assertFalse(
502 503
                np.array_equal(conv2d1_weight_np, conv2d2.weight.numpy())
            )
504
            conv2d2.weight.set_value(conv2d1_weight_np)
505 506 507
            np.testing.assert_array_equal(
                conv2d1_weight_np, conv2d2.weight.numpy()
            )
508 509 510
            conv2d2.bias.set_value(conv2d1_bias)
            dy_ret1 = conv2d1(base.to_variable(images))
            dy_ret2 = conv2d2(base.to_variable(images))
511
            np.testing.assert_array_equal(dy_ret1.numpy(), dy_ret2.numpy())
512 513 514

            conv2d2.weight = conv2d1.weight
            conv2d2.bias = conv2d1.bias
515 516 517 518 519 520
            np.testing.assert_array_equal(
                conv2d1.weight.numpy(), conv2d2.weight.numpy()
            )
            np.testing.assert_array_equal(
                conv2d1.bias.numpy(), conv2d2.bias.numpy()
            )
521

522 523 524 525 526
        with self.static_graph():

            # the input of Conv2DTranspose must be Variable.
            def test_Variable():
                images = np.ones([2, 3, 5, 5], dtype='float32')
527
                conv2d = paddle.nn.Conv2DTranspose(3, 3, [2, 2])
528 529 530 531 532 533 534
                conv2d_ret1 = conv2d(images)

            self.assertRaises(TypeError, test_Variable)

            # the input dtype of Conv2DTranspose must be float16 or float32 or float64
            # float16 only can be set on GPU place
            def test_type():
535 536 537
                images = layers.data(
                    name='pixel', shape=[3, 5, 5], dtype='int32'
                )
538
                conv2d = paddle.nn.Conv2DTranspose(3, 3, [2, 2])
539 540 541 542
                conv2d_ret2 = conv2d(images)

            self.assertRaises(TypeError, test_type)

543 544 545 546 547
    def test_bilinear_tensor_product(self):
        inp_np_x = np.array([[1, 2, 3]]).astype('float32')
        inp_np_y = np.array([[4, 5, 6]]).astype('float32')

        with self.static_graph():
548 549 550 551 552 553
            data_x = layers.data(
                name='x', shape=[1, 3], dtype="float32", append_batch_size=False
            )
            data_y = layers.data(
                name='y', shape=[1, 3], dtype="float32", append_batch_size=False
            )
554
            out = paddle.static.nn.common.bilinear_tensor_product(
555 556 557 558
                data_x,
                data_y,
                6,
                bias_attr=fluid.initializer.ConstantInitializer(value=1),
559 560
                act='sigmoid',
            )
561

562 563 564
            static_rlt = self.get_static_graph_result(
                feed={'x': inp_np_x, 'y': inp_np_y}, fetch_list=[out]
            )[0]
565

566
        with self.static_graph():
567 568 569 570 571 572
            data_x = layers.data(
                name='x', shape=[1, 3], dtype="float32", append_batch_size=False
            )
            data_y = layers.data(
                name='y', shape=[1, 3], dtype="float32", append_batch_size=False
            )
573
            btp = paddle.nn.Bilinear(
574 575
                3,
                3,
576 577
                6,
                bias_attr=fluid.initializer.ConstantInitializer(value=1),
578
            )
579
            out = btp(data_x, data_y)
580
            out = paddle.nn.functional.sigmoid(out)
581 582 583
            static_rlt2 = self.get_static_graph_result(
                feed={'x': inp_np_x, 'y': inp_np_y}, fetch_list=[out]
            )[0]
584
        with self.dynamic_graph():
585
            with _test_eager_guard():
586
                btp = paddle.nn.Bilinear(
587 588 589 590
                    3,
                    3,
                    6,
                    bias_attr=fluid.initializer.ConstantInitializer(value=1),
591 592 593 594
                )
                dy_eager_rlt = btp(
                    base.to_variable(inp_np_x), base.to_variable(inp_np_y)
                )
595
                dy_eager_rlt = paddle.nn.functional.sigmoid(dy_eager_rlt)
596 597
                dy_eager_rlt_value = dy_eager_rlt.numpy()

598
            btp = paddle.nn.Bilinear(
599 600
                3,
                3,
601 602
                6,
                bias_attr=fluid.initializer.ConstantInitializer(value=1),
603
            )
604
            dy_rlt = btp(base.to_variable(inp_np_x), base.to_variable(inp_np_y))
605
            dy_rlt = paddle.nn.functional.sigmoid(dy_rlt)
606
            dy_rlt_value = dy_rlt.numpy()
607

608
        with self.dynamic_graph():
609
            with _test_eager_guard():
610
                btp2 = paddle.nn.Bilinear(3, 3, 6)
611 612 613
                dy_eager_rlt2 = btp2(
                    base.to_variable(inp_np_x), base.to_variable(inp_np_y)
                )
614
                dy_eager_rlt2 = paddle.nn.functional.sigmoid(dy_eager_rlt2)
615 616
                dy_eager_rlt2_value = dy_eager_rlt2.numpy()

617
            btp2 = paddle.nn.Bilinear(3, 3, 6)
618 619 620
            dy_rlt2 = btp2(
                base.to_variable(inp_np_x), base.to_variable(inp_np_y)
            )
621
            dy_rlt2 = paddle.nn.functional.sigmoid(dy_rlt2)
622
            dy_rlt2_value = dy_rlt2.numpy()
623

624
        with self.static_graph():
625 626 627 628 629 630
            data_x2 = layers.data(
                name='x', shape=[1, 3], dtype="float32", append_batch_size=False
            )
            data_y2 = layers.data(
                name='y', shape=[1, 3], dtype="float32", append_batch_size=False
            )
631
            out2 = paddle.static.nn.common.bilinear_tensor_product(
632 633 634 635 636 637
                data_x2, data_y2, 6, act='sigmoid'
            )

            static_rlt3 = self.get_static_graph_result(
                feed={'x': inp_np_x, 'y': inp_np_y}, fetch_list=[out2]
            )[0]
638

639 640 641 642 643
        np.testing.assert_array_equal(dy_rlt2_value, static_rlt3)
        np.testing.assert_array_equal(dy_eager_rlt2_value, static_rlt3)
        np.testing.assert_array_equal(static_rlt2, static_rlt)
        np.testing.assert_array_equal(dy_rlt_value, static_rlt)
        np.testing.assert_array_equal(dy_eager_rlt_value, static_rlt)
644

645
        with self.dynamic_graph():
646 647 648 649
            with _test_eager_guard():
                custom_weight = np.random.randn(6, 3, 3).astype("float32")
                weight_attr = fluid.ParamAttr(
                    initializer=fluid.initializer.NumpyArrayInitializer(
650 651 652
                        custom_weight
                    )
                )
653 654
                btp1 = paddle.nn.Bilinear(3, 3, 6)
                btp2 = paddle.nn.Bilinear(3, 3, 6, weight_attr=weight_attr)
655 656 657
                dy_rlt1 = btp1(
                    base.to_variable(inp_np_x), base.to_variable(inp_np_y)
                )
658
                dy_rlt1 = paddle.nn.functional.sigmoid(dy_rlt1)
659 660 661
                dy_rlt2 = btp2(
                    base.to_variable(inp_np_x), base.to_variable(inp_np_y)
                )
662
                dy_rlt2 = paddle.nn.functional.sigmoid(dy_rlt2)
663
                self.assertFalse(
664 665
                    np.array_equal(dy_rlt1.numpy(), dy_rlt2.numpy())
                )
666 667
                btp2.weight.set_value(btp1.weight.numpy())
                btp2.bias.set_value(btp1.bias)
668 669 670 671 672 673
                dy_rlt1 = btp1(
                    base.to_variable(inp_np_x), base.to_variable(inp_np_y)
                )
                dy_rlt2 = btp2(
                    base.to_variable(inp_np_x), base.to_variable(inp_np_y)
                )
674
                np.testing.assert_array_equal(dy_rlt1.numpy(), dy_rlt2.numpy())
675 676 677

                btp2.weight = btp1.weight
                btp2.bias = btp1.bias
678 679 680 681 682 683
                np.testing.assert_array_equal(
                    btp1.weight.numpy(), btp2.weight.numpy()
                )
                np.testing.assert_array_equal(
                    btp1.bias.numpy(), btp2.bias.numpy()
                )
684

685
            custom_weight = np.random.randn(6, 3, 3).astype("float32")
686 687 688 689 690
            weight_attr = fluid.ParamAttr(
                initializer=fluid.initializer.NumpyArrayInitializer(
                    custom_weight
                )
            )
691 692
            btp1 = paddle.nn.Bilinear(3, 3, 6)
            btp2 = paddle.nn.Bilinear(3, 3, 6, weight_attr=weight_attr)
693 694 695
            dy_rlt1 = btp1(
                base.to_variable(inp_np_x), base.to_variable(inp_np_y)
            )
696
            dy_rlt1 = paddle.nn.functional.sigmoid(dy_rlt1)
697 698 699
            dy_rlt2 = btp2(
                base.to_variable(inp_np_x), base.to_variable(inp_np_y)
            )
700
            dy_rlt2 = paddle.nn.functional.sigmoid(dy_rlt2)
701 702 703
            self.assertFalse(np.array_equal(dy_rlt1.numpy(), dy_rlt2.numpy()))
            btp2.weight.set_value(btp1.weight.numpy())
            btp2.bias.set_value(btp1.bias)
704 705 706 707 708 709
            dy_rlt1 = btp1(
                base.to_variable(inp_np_x), base.to_variable(inp_np_y)
            )
            dy_rlt2 = btp2(
                base.to_variable(inp_np_x), base.to_variable(inp_np_y)
            )
710
            np.testing.assert_array_equal(dy_rlt1.numpy(), dy_rlt2.numpy())
711 712 713

            btp2.weight = btp1.weight
            btp2.bias = btp1.bias
714 715 716
            np.testing.assert_array_equal(
                btp1.weight.numpy(), btp2.weight.numpy()
            )
717
            np.testing.assert_array_equal(btp1.bias.numpy(), btp2.bias.numpy())
718

719 720 721 722 723
    def test_embeding(self):
        inp_word = np.array([[[1]]]).astype('int64')
        dict_size = 20
        with self.static_graph():
            data_t = layers.data(name='word', shape=[1], dtype='int64')
724 725 726 727 728 729 730 731 732
            emb = layers.embedding(
                input=data_t,
                size=[dict_size, 32],
                param_attr='emb.w',
                is_sparse=False,
            )
            static_rlt = self.get_static_graph_result(
                feed={'word': inp_word}, fetch_list=[emb]
            )[0]
733 734
        with self.static_graph():
            data_t = layers.data(name='word', shape=[1], dtype='int64')
735 736 737
            emb2 = nn.Embedding(
                size=[dict_size, 32], param_attr='emb.w', is_sparse=False
            )
738
            emb_rlt = emb2(data_t)
739 740 741
            static_rlt2 = self.get_static_graph_result(
                feed={'word': inp_word}, fetch_list=[emb_rlt]
            )[0]
742
        with self.dynamic_graph():
743
            with _test_eager_guard():
744 745 746 747 748
                emb2 = nn.Embedding(
                    size=[dict_size, 32],
                    param_attr='eager_emb.w',
                    is_sparse=False,
                )
749 750 751
                dy_eager_rlt = emb2(base.to_variable(inp_word))
                dy_eager_rlt_value = dy_eager_rlt.numpy()

752 753 754
            emb2 = nn.Embedding(
                size=[dict_size, 32], param_attr='emb.w', is_sparse=False
            )
755 756
            dy_rlt = emb2(base.to_variable(inp_word))
            dy_rlt_value = dy_rlt.numpy()
757 758

        self.assertTrue(np.allclose(static_rlt2, static_rlt))
759
        self.assertTrue(np.allclose(dy_rlt_value, static_rlt))
760
        self.assertTrue(np.allclose(dy_eager_rlt_value, static_rlt))
761

762
        with self.dynamic_graph():
763 764 765 766
            with _test_eager_guard():
                custom_weight = np.random.randn(dict_size, 32).astype("float32")
                weight_attr = fluid.ParamAttr(
                    initializer=fluid.initializer.NumpyArrayInitializer(
767 768 769
                        custom_weight
                    )
                )
770
                emb1 = nn.Embedding(size=[dict_size, 32], is_sparse=False)
771 772 773 774 775
                emb2 = nn.Embedding(
                    size=[dict_size, 32],
                    param_attr=weight_attr,
                    is_sparse=False,
                )
776 777 778
                rep1 = emb1(base.to_variable(inp_word))
                rep2 = emb2(base.to_variable(inp_word))
                self.assertFalse(
779 780 781 782 783
                    np.array_equal(emb1.weight.numpy(), custom_weight)
                )
                np.testing.assert_array_equal(
                    emb2.weight.numpy(), custom_weight
                )
784 785 786
                self.assertFalse(np.array_equal(rep1.numpy(), rep2.numpy()))
                emb2.weight.set_value(emb1.weight.numpy())
                rep2 = emb2(base.to_variable(inp_word))
787
                np.testing.assert_array_equal(rep1.numpy(), rep2.numpy())
788 789

                emb2.weight = emb1.weight
790 791 792
                np.testing.assert_array_equal(
                    emb1.weight.numpy(), emb2.weight.numpy()
                )
793

794
            custom_weight = np.random.randn(dict_size, 32).astype("float32")
795 796 797 798 799
            weight_attr = fluid.ParamAttr(
                initializer=fluid.initializer.NumpyArrayInitializer(
                    custom_weight
                )
            )
800
            emb1 = nn.Embedding(size=[dict_size, 32], is_sparse=False)
801 802 803
            emb2 = nn.Embedding(
                size=[dict_size, 32], param_attr=weight_attr, is_sparse=False
            )
804 805 806
            rep1 = emb1(base.to_variable(inp_word))
            rep2 = emb2(base.to_variable(inp_word))
            self.assertFalse(np.array_equal(emb1.weight.numpy(), custom_weight))
807
            np.testing.assert_array_equal(emb2.weight.numpy(), custom_weight)
808 809 810
            self.assertFalse(np.array_equal(rep1.numpy(), rep2.numpy()))
            emb2.weight.set_value(emb1.weight.numpy())
            rep2 = emb2(base.to_variable(inp_word))
811
            np.testing.assert_array_equal(rep1.numpy(), rep2.numpy())
812 813

            emb2.weight = emb1.weight
814 815 816
            np.testing.assert_array_equal(
                emb1.weight.numpy(), emb2.weight.numpy()
            )
817

S
songyouwei 已提交
818 819
    def test_one_hot(self):
        with self.dynamic_graph():
820
            with _test_eager_guard():
821 822 823
                label = fluid.dygraph.to_variable(
                    np.array([[1], [1], [3], [0]])
                )
824 825
                one_hot_label1 = fluid.layers.one_hot(input=label, depth=4)
                one_hot_label2 = fluid.layers.one_hot(
826 827 828 829 830
                    input=label, depth=fluid.dygraph.to_variable(np.array([4]))
                )
                np.testing.assert_array_equal(
                    one_hot_label1.numpy(), one_hot_label2.numpy()
                )
831

S
songyouwei 已提交
832 833 834
            label = fluid.dygraph.to_variable(np.array([[1], [1], [3], [0]]))
            one_hot_label1 = fluid.layers.one_hot(input=label, depth=4)
            one_hot_label2 = fluid.layers.one_hot(
835 836 837 838 839
                input=label, depth=fluid.dygraph.to_variable(np.array([4]))
            )
            np.testing.assert_array_equal(
                one_hot_label1.numpy(), one_hot_label2.numpy()
            )
S
songyouwei 已提交
840 841 842

    def test_split(self):
        with self.dynamic_graph():
843 844 845
            with _test_eager_guard():
                input = fluid.dygraph.to_variable(np.random.random((3, 8, 5)))
                x0, x1 = fluid.layers.split(input, num_or_sections=2, dim=1)
846 847 848 849 850
                x00, x11 = fluid.layers.split(
                    input,
                    num_or_sections=2,
                    dim=fluid.dygraph.to_variable(np.array([1])),
                )
851 852
                np.testing.assert_array_equal(x0.numpy(), x00.numpy())
                np.testing.assert_array_equal(x1.numpy(), x11.numpy())
853

S
songyouwei 已提交
854 855
            input = fluid.dygraph.to_variable(np.random.random((3, 8, 5)))
            x0, x1 = fluid.layers.split(input, num_or_sections=2, dim=1)
856 857 858 859 860
            x00, x11 = fluid.layers.split(
                input,
                num_or_sections=2,
                dim=fluid.dygraph.to_variable(np.array([1])),
            )
861 862
            np.testing.assert_array_equal(x0.numpy(), x00.numpy())
            np.testing.assert_array_equal(x1.numpy(), x11.numpy())
S
songyouwei 已提交
863 864 865

    def test_topk(self):
        with self.dynamic_graph():
866 867
            with _test_eager_guard():
                input = fluid.dygraph.to_variable(np.random.random((13, 11)))
868 869
                top5_values1, top5_indices1 = paddle.topk(input, k=5)
                top5_values2, top5_indices2 = paddle.topk(
870 871 872 873 874 875 876 877
                    input, k=fluid.dygraph.to_variable(np.array([5]))
                )
                np.testing.assert_array_equal(
                    top5_values1.numpy(), top5_values2.numpy()
                )
                np.testing.assert_array_equal(
                    top5_indices1.numpy(), top5_indices2.numpy()
                )
878

S
songyouwei 已提交
879
            input = fluid.dygraph.to_variable(np.random.random((13, 11)))
880 881
            top5_values1, top5_indices1 = paddle.topk(input, k=5)
            top5_values2, top5_indices2 = paddle.topk(
882 883 884 885 886 887 888 889
                input, k=fluid.dygraph.to_variable(np.array([5]))
            )
            np.testing.assert_array_equal(
                top5_values1.numpy(), top5_values2.numpy()
            )
            np.testing.assert_array_equal(
                top5_indices1.numpy(), top5_indices2.numpy()
            )
S
songyouwei 已提交
890

L
lujun 已提交
891 892
    def test_conv3d(self):
        with self.static_graph():
893 894 895
            images = layers.data(
                name='pixel', shape=[3, 6, 6, 6], dtype='float32'
            )
896 897 898
            ret = paddle.static.nn.conv3d(
                input=images, num_filters=3, filter_size=2
            )
L
lujun 已提交
899
            static_ret = self.get_static_graph_result(
900
                feed={'pixel': np.ones([2, 3, 6, 6, 6], dtype='float32')},
901 902
                fetch_list=[ret],
            )[0]
L
lujun 已提交
903 904

        with self.static_graph():
905 906 907
            images = layers.data(
                name='pixel', shape=[3, 6, 6, 6], dtype='float32'
            )
908 909 910
            conv3d = paddle.nn.Conv3D(
                in_channels=3, out_channels=3, kernel_size=2
            )
L
lujun 已提交
911 912
            ret = conv3d(images)
            static_ret2 = self.get_static_graph_result(
913
                feed={'pixel': np.ones([2, 3, 6, 6, 6], dtype='float32')},
914 915
                fetch_list=[ret],
            )[0]
L
lujun 已提交
916 917

        with self.dynamic_graph():
918 919
            with _test_eager_guard():
                images = np.ones([2, 3, 6, 6, 6], dtype='float32')
920 921 922
                conv3d = paddle.nn.Conv3D(
                    in_channels=3, out_channels=3, kernel_size=2
                )
923 924 925
                dy_eager_ret = conv3d(base.to_variable(images))
                dy_eager_rlt_value = dy_eager_ret.numpy()

L
lujun 已提交
926
            images = np.ones([2, 3, 6, 6, 6], dtype='float32')
927 928 929
            conv3d = paddle.nn.Conv3D(
                in_channels=3, out_channels=3, kernel_size=2
            )
L
lujun 已提交
930
            dy_ret = conv3d(base.to_variable(images))
931
            dy_rlt_value = dy_ret.numpy()
L
lujun 已提交
932

933 934 935
        np.testing.assert_allclose(static_ret, dy_rlt_value, rtol=1e-05)
        np.testing.assert_allclose(static_ret, dy_eager_rlt_value, rtol=1e-05)
        np.testing.assert_allclose(static_ret, static_ret2, rtol=1e-05)
L
lujun 已提交
936

937
        with self.dynamic_graph():
938 939 940 941 942
            with _test_eager_guard():
                images = np.ones([2, 3, 6, 6, 6], dtype='float32')
                custom_weight = np.random.randn(3, 3, 2, 2, 2).astype("float32")
                weight_attr = fluid.ParamAttr(
                    initializer=fluid.initializer.NumpyArrayInitializer(
943 944 945
                        custom_weight
                    )
                )
946 947
                conv3d1 = paddle.nn.Conv3D(
                    in_channels=3, out_channels=3, kernel_size=2
948
                )
949 950 951 952 953
                conv3d2 = paddle.nn.Conv3D(
                    in_channels=3,
                    out_channels=3,
                    kernel_size=2,
                    weight_attr=weight_attr,
954
                )
955 956 957
                dy_ret1 = conv3d1(base.to_variable(images))
                dy_ret2 = conv3d2(base.to_variable(images))
                self.assertFalse(
958 959
                    np.array_equal(dy_ret1.numpy(), dy_ret2.numpy())
                )
960 961 962 963

                conv3d1_weight_np = conv3d1.weight.numpy()
                conv3d1_bias = conv3d1.bias
                self.assertFalse(
964 965
                    np.array_equal(conv3d1_weight_np, conv3d2.weight.numpy())
                )
966
                conv3d2.weight.set_value(conv3d1_weight_np)
967 968 969
                np.testing.assert_array_equal(
                    conv3d1_weight_np, conv3d2.weight.numpy()
                )
970 971 972
                conv3d1.bias.set_value(conv3d1_bias)
                dy_ret1 = conv3d1(base.to_variable(images))
                dy_ret2 = conv3d2(base.to_variable(images))
973
                np.testing.assert_array_equal(dy_ret1.numpy(), dy_ret2.numpy())
974 975 976

                conv3d2.weight = conv3d1.weight
                conv3d2.bias = conv3d1.bias
977 978 979 980 981 982
                np.testing.assert_array_equal(
                    conv3d1.weight.numpy(), conv3d2.weight.numpy()
                )
                np.testing.assert_array_equal(
                    conv3d1.bias.numpy(), conv3d2.bias.numpy()
                )
983

984 985
            images = np.ones([2, 3, 6, 6, 6], dtype='float32')
            custom_weight = np.random.randn(3, 3, 2, 2, 2).astype("float32")
986 987 988 989 990
            weight_attr = fluid.ParamAttr(
                initializer=fluid.initializer.NumpyArrayInitializer(
                    custom_weight
                )
            )
991 992 993 994 995 996 997 998
            conv3d1 = paddle.nn.Conv3D(
                in_channels=3, out_channels=3, kernel_size=2
            )
            conv3d2 = paddle.nn.Conv3D(
                in_channels=3,
                out_channels=3,
                kernel_size=2,
                weight_attr=weight_attr,
999
            )
1000 1001 1002 1003 1004 1005 1006
            dy_ret1 = conv3d1(base.to_variable(images))
            dy_ret2 = conv3d2(base.to_variable(images))
            self.assertFalse(np.array_equal(dy_ret1.numpy(), dy_ret2.numpy()))

            conv3d1_weight_np = conv3d1.weight.numpy()
            conv3d1_bias = conv3d1.bias
            self.assertFalse(
1007 1008
                np.array_equal(conv3d1_weight_np, conv3d2.weight.numpy())
            )
1009
            conv3d2.weight.set_value(conv3d1_weight_np)
1010 1011 1012
            np.testing.assert_array_equal(
                conv3d1_weight_np, conv3d2.weight.numpy()
            )
1013 1014 1015
            conv3d1.bias.set_value(conv3d1_bias)
            dy_ret1 = conv3d1(base.to_variable(images))
            dy_ret2 = conv3d2(base.to_variable(images))
1016
            np.testing.assert_array_equal(dy_ret1.numpy(), dy_ret2.numpy())
1017 1018 1019

            conv3d2.weight = conv3d1.weight
            conv3d2.bias = conv3d1.bias
1020 1021 1022 1023 1024 1025
            np.testing.assert_array_equal(
                conv3d1.weight.numpy(), conv3d2.weight.numpy()
            )
            np.testing.assert_array_equal(
                conv3d1.bias.numpy(), conv3d2.bias.numpy()
            )
1026

1027
    def func_group_norm(self):
L
lujun 已提交
1028 1029 1030 1031 1032 1033 1034 1035 1036 1037
        if core.is_compiled_with_cuda():
            place = core.CUDAPlace(0)
        else:
            place = core.CPUPlace()

        shape = (2, 4, 3, 3)

        input = np.random.random(shape).astype('float32')

        with self.static_graph():
1038 1039 1040 1041 1042 1043 1044
            X = fluid.layers.data(
                name='X',
                shape=shape,
                dtype='float32',
                lod_level=1,
                append_batch_size=False,
            )
1045
            ret = paddle.static.nn.group_norm(
1046 1047
                input=X,
                groups=2,
1048
                param_attr=fluid.initializer.Uniform(low=-0.5, high=0.5),
1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059
                bias_attr=fluid.initializer.ConstantInitializer(value=1),
            )
            static_ret = self.get_static_graph_result(
                feed={
                    'X': fluid.create_lod_tensor(
                        data=input, recursive_seq_lens=[[1, 1]], place=place
                    )
                },
                fetch_list=[ret],
                with_lod=True,
            )[0]
L
lujun 已提交
1060 1061

        with self.static_graph():
1062 1063 1064 1065 1066 1067 1068
            X = fluid.layers.data(
                name='X',
                shape=shape,
                dtype='float32',
                lod_level=1,
                append_batch_size=False,
            )
1069 1070 1071 1072
            groupNorm = paddle.nn.GroupNorm(
                num_channels=shape[1],
                num_groups=2,
                weight_attr=fluid.initializer.Uniform(low=-0.5, high=0.5),
1073 1074
                bias_attr=fluid.initializer.ConstantInitializer(value=1),
            )
L
lujun 已提交
1075
            ret = groupNorm(X)
1076 1077 1078 1079 1080 1081 1082 1083 1084
            static_ret2 = self.get_static_graph_result(
                feed={
                    'X': fluid.create_lod_tensor(
                        data=input, recursive_seq_lens=[[1, 1]], place=place
                    )
                },
                fetch_list=[ret],
                with_lod=True,
            )[0]
L
lujun 已提交
1085 1086

        with self.dynamic_graph():
1087 1088 1089 1090
            groupNorm = paddle.nn.GroupNorm(
                num_channels=shape[1],
                num_groups=2,
                weight_attr=fluid.initializer.Uniform(low=-0.5, high=0.5),
1091 1092
                bias_attr=fluid.initializer.ConstantInitializer(value=1),
            )
L
lujun 已提交
1093
            dy_ret = groupNorm(base.to_variable(input))
1094
            dy_rlt_value = dy_ret.numpy()
L
lujun 已提交
1095

1096 1097
        np.testing.assert_allclose(static_ret, dy_rlt_value, rtol=1e-05)
        np.testing.assert_allclose(static_ret, static_ret2, rtol=1e-05)
L
lujun 已提交
1098

1099 1100 1101 1102 1103
    def test_group_norm(self):
        with _test_eager_guard():
            self.func_group_norm()
        self.func_group_norm()

1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114
    def test_instance_norm(self):
        if core.is_compiled_with_cuda():
            place = core.CUDAPlace(0)
        else:
            place = core.CPUPlace()

        shape = (2, 4, 3, 3)

        input = np.random.random(shape).astype('float32')

        with self.static_graph():
1115 1116 1117
            X = fluid.layers.data(
                name='X', shape=shape, dtype='float32', append_batch_size=False
            )
1118
            ret = paddle.static.nn.instance_norm(input=X)
1119 1120 1121
            static_ret = self.get_static_graph_result(
                feed={'X': input}, fetch_list=[ret]
            )[0]
1122 1123

        with self.static_graph():
1124 1125 1126
            X = fluid.layers.data(
                name='X', shape=shape, dtype='float32', append_batch_size=False
            )
1127
            instanceNorm = paddle.nn.InstanceNorm2D(num_features=shape[1])
1128
            ret = instanceNorm(X)
1129 1130 1131
            static_ret2 = self.get_static_graph_result(
                feed={'X': input}, fetch_list=[ret]
            )[0]
1132 1133

        with self.dynamic_graph():
1134
            with _test_eager_guard():
1135
                instanceNorm = paddle.nn.InstanceNorm2D(num_features=shape[1])
1136 1137 1138
                dy_eager_ret = instanceNorm(base.to_variable(input))
                dy_eager_rlt_value = dy_eager_ret.numpy()

1139
            instanceNorm = paddle.nn.InstanceNorm2D(num_features=shape[1])
1140 1141 1142 1143
            dy_ret = instanceNorm(base.to_variable(input))
            dy_rlt_value = dy_ret.numpy()

        with self.dynamic_graph():
1144
            with _test_eager_guard():
1145
                instanceNorm = paddle.nn.InstanceNorm2D(num_features=shape[1])
1146 1147 1148
                dy_eager_ret = instanceNorm(base.to_variable(input))
                dy_eager_rlt_value2 = dy_eager_ret.numpy()

1149
            instanceNorm = paddle.nn.InstanceNorm2D(num_features=shape[1])
1150 1151 1152
            dy_ret = instanceNorm(base.to_variable(input))
            dy_rlt_value2 = dy_ret.numpy()

1153 1154 1155 1156 1157
        np.testing.assert_allclose(static_ret, dy_rlt_value, rtol=1e-05)
        np.testing.assert_allclose(static_ret, dy_rlt_value2, rtol=1e-05)
        np.testing.assert_allclose(static_ret, dy_eager_rlt_value, rtol=1e-05)
        np.testing.assert_allclose(static_ret, dy_eager_rlt_value2, rtol=1e-05)
        np.testing.assert_allclose(static_ret, static_ret2, rtol=1e-05)
1158 1159 1160 1161

        with self.static_graph():
            # the input of InstanceNorm must be Variable.
            def test_Variable():
1162
                instanceNorm = paddle.nn.InstanceNorm2D(num_features=shape[1])
1163 1164 1165 1166 1167 1168 1169
                ret1 = instanceNorm(input)

            self.assertRaises(TypeError, test_Variable)

            # the input dtype of InstanceNorm must be float32 or float64
            def test_type():
                input = np.random.random(shape).astype('int32')
1170
                instanceNorm = paddle.nn.InstanceNorm2D(num_features=shape[1])
1171 1172 1173 1174
                ret2 = instanceNorm(input)

            self.assertRaises(TypeError, test_type)

L
lujun 已提交
1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185
    def test_spectral_norm(self):
        if core.is_compiled_with_cuda():
            place = core.CUDAPlace(0)
        else:
            place = core.CPUPlace()

        shape = (2, 4, 3, 3)

        input = np.random.random(shape).astype('float32')

        with self.static_graph():
1186 1187 1188 1189 1190 1191 1192
            Weight = fluid.layers.data(
                name='Weight',
                shape=shape,
                dtype='float32',
                lod_level=1,
                append_batch_size=False,
            )
L
lujun 已提交
1193
            ret = layers.spectral_norm(weight=Weight, dim=1, power_iters=2)
1194 1195 1196 1197 1198 1199 1200 1201 1202
            static_ret = self.get_static_graph_result(
                feed={
                    'Weight': fluid.create_lod_tensor(
                        data=input, recursive_seq_lens=[[1, 1]], place=place
                    ),
                },
                fetch_list=[ret],
                with_lod=True,
            )[0]
L
lujun 已提交
1203 1204

        with self.static_graph():
1205 1206 1207 1208 1209 1210 1211
            Weight = fluid.layers.data(
                name='Weight',
                shape=shape,
                dtype='float32',
                lod_level=1,
                append_batch_size=False,
            )
1212
            spectralNorm = paddle.nn.SpectralNorm(shape, axis=1, power_iters=2)
L
lujun 已提交
1213
            ret = spectralNorm(Weight)
1214 1215 1216 1217 1218 1219 1220 1221 1222
            static_ret2 = self.get_static_graph_result(
                feed={
                    'Weight': fluid.create_lod_tensor(
                        data=input, recursive_seq_lens=[[1, 1]], place=place
                    )
                },
                fetch_list=[ret],
                with_lod=True,
            )[0]
L
lujun 已提交
1223 1224

        with self.dynamic_graph():
1225
            with _test_eager_guard():
1226 1227 1228
                spectralNorm = paddle.nn.SpectralNorm(
                    shape, axis=1, power_iters=2
                )
1229 1230 1231
                dy_eager_ret = spectralNorm(base.to_variable(input))
                dy_eager_rlt_value = dy_eager_ret.numpy()

1232
            spectralNorm = paddle.nn.SpectralNorm(shape, axis=1, power_iters=2)
L
lujun 已提交
1233
            dy_ret = spectralNorm(base.to_variable(input))
1234
            dy_rlt_value = dy_ret.numpy()
L
lujun 已提交
1235

1236 1237 1238
        np.testing.assert_allclose(static_ret, dy_rlt_value, rtol=1e-05)
        np.testing.assert_allclose(static_ret, dy_eager_rlt_value, rtol=1e-05)
        np.testing.assert_allclose(static_ret, static_ret2, rtol=1e-05)
L
lujun 已提交
1239 1240

    def test_conv3d_transpose(self):
1241 1242 1243
        input_array = (
            np.arange(0, 48).reshape([2, 3, 2, 2, 2]).astype('float32')
        )
L
lujun 已提交
1244 1245 1246

        with self.static_graph():
            img = layers.data(name='pixel', shape=[3, 2, 2, 2], dtype='float32')
1247
            out = paddle.static.nn.conv3d_transpose(
1248
                input=img, num_filters=12, filter_size=12, use_cudnn=True
1249
            )
L
lujun 已提交
1250
            static_rlt = self.get_static_graph_result(
1251 1252
                feed={'pixel': input_array}, fetch_list=[out]
            )[0]
L
lujun 已提交
1253 1254
        with self.static_graph():
            img = layers.data(name='pixel', shape=[3, 2, 2, 2], dtype='float32')
1255 1256
            conv3d_transpose = paddle.nn.Conv3DTranspose(
                in_channels=3, out_channels=12, kernel_size=12
1257
            )
L
lujun 已提交
1258 1259
            out = conv3d_transpose(img)
            static_rlt2 = self.get_static_graph_result(
1260 1261
                feed={'pixel': input_array}, fetch_list=[out]
            )[0]
L
lujun 已提交
1262
        with self.dynamic_graph():
1263
            with _test_eager_guard():
1264 1265 1266 1267
                conv3d_transpose = paddle.nn.Conv3DTranspose(
                    in_channels=3,
                    out_channels=12,
                    kernel_size=12,
1268
                )
1269 1270 1271
                dy_eager_rlt = conv3d_transpose(base.to_variable(input_array))
                dy_eager_rlt_value = dy_eager_rlt.numpy()

1272 1273
            conv3d_transpose = paddle.nn.Conv3DTranspose(
                in_channels=3, out_channels=12, kernel_size=12
1274
            )
L
lujun 已提交
1275
            dy_rlt = conv3d_transpose(base.to_variable(input_array))
1276
            dy_rlt_value = dy_rlt.numpy()
1277 1278 1279
        np.testing.assert_allclose(static_rlt2, static_rlt, rtol=1e-05)
        np.testing.assert_allclose(dy_rlt_value, static_rlt, rtol=1e-05)
        np.testing.assert_allclose(dy_eager_rlt_value, static_rlt, rtol=1e-05)
L
lujun 已提交
1280

1281
        with self.dynamic_graph():
1282 1283 1284 1285 1286
            with _test_eager_guard():
                images = np.ones([2, 3, 6, 6, 6], dtype='float32')
                custom_weight = np.random.randn(3, 3, 2, 2, 2).astype("float32")
                weight_attr = fluid.ParamAttr(
                    initializer=fluid.initializer.NumpyArrayInitializer(
1287 1288 1289
                        custom_weight
                    )
                )
1290 1291 1292 1293
                conv3d1 = paddle.nn.Conv3DTranspose(
                    in_channels=3,
                    out_channels=3,
                    kernel_size=2,
1294 1295
                    bias_attr='eager_conv3d1_b',
                )
1296 1297 1298 1299 1300
                conv3d2 = paddle.nn.Conv3DTranspose(
                    in_channels=3,
                    out_channels=3,
                    kernel_size=2,
                    weight_attr=weight_attr,
1301 1302
                    bias_attr='eager_conv3d2_b',
                )
1303 1304 1305
                dy_ret1 = conv3d1(base.to_variable(images))
                dy_ret2 = conv3d2(base.to_variable(images))
                self.assertFalse(
1306 1307
                    np.array_equal(dy_ret1.numpy(), dy_ret2.numpy())
                )
1308 1309 1310 1311

                conv3d1_weight_np = conv3d1.weight.numpy()
                conv3d1_bias = conv3d1.bias
                self.assertFalse(
1312 1313
                    np.array_equal(conv3d1_weight_np, conv3d2.weight.numpy())
                )
1314
                conv3d2.weight.set_value(conv3d1_weight_np)
1315 1316 1317
                np.testing.assert_array_equal(
                    conv3d1_weight_np, conv3d2.weight.numpy()
                )
1318 1319 1320
                conv3d1.bias.set_value(conv3d1_bias)
                dy_ret1 = conv3d1(base.to_variable(images))
                dy_ret2 = conv3d2(base.to_variable(images))
1321
                np.testing.assert_array_equal(dy_ret1.numpy(), dy_ret2.numpy())
1322 1323 1324

                conv3d2.weight = conv3d1.weight
                conv3d2.bias = conv3d1.bias
1325 1326 1327 1328 1329 1330
                np.testing.assert_array_equal(
                    conv3d1.weight.numpy(), conv3d2.weight.numpy()
                )
                np.testing.assert_array_equal(
                    conv3d1.bias.numpy(), conv3d2.bias.numpy()
                )
1331

1332 1333
            images = np.ones([2, 3, 6, 6, 6], dtype='float32')
            custom_weight = np.random.randn(3, 3, 2, 2, 2).astype("float32")
1334 1335 1336 1337 1338
            weight_attr = fluid.ParamAttr(
                initializer=fluid.initializer.NumpyArrayInitializer(
                    custom_weight
                )
            )
1339 1340 1341 1342
            conv3d1 = paddle.nn.Conv3DTranspose(
                in_channels=3,
                out_channels=3,
                kernel_size=2,
1343 1344
                bias_attr='conv3d1_b',
            )
1345 1346 1347 1348 1349
            conv3d2 = paddle.nn.Conv3DTranspose(
                in_channels=3,
                out_channels=3,
                kernel_size=2,
                weight_attr=weight_attr,
1350 1351
                bias_attr='conv3d2_b',
            )
1352 1353 1354 1355 1356 1357 1358
            dy_ret1 = conv3d1(base.to_variable(images))
            dy_ret2 = conv3d2(base.to_variable(images))
            self.assertFalse(np.array_equal(dy_ret1.numpy(), dy_ret2.numpy()))

            conv3d1_weight_np = conv3d1.weight.numpy()
            conv3d1_bias = conv3d1.bias
            self.assertFalse(
1359 1360
                np.array_equal(conv3d1_weight_np, conv3d2.weight.numpy())
            )
1361
            conv3d2.weight.set_value(conv3d1_weight_np)
1362 1363 1364
            np.testing.assert_array_equal(
                conv3d1_weight_np, conv3d2.weight.numpy()
            )
1365 1366 1367
            conv3d1.bias.set_value(conv3d1_bias)
            dy_ret1 = conv3d1(base.to_variable(images))
            dy_ret2 = conv3d2(base.to_variable(images))
1368
            np.testing.assert_array_equal(dy_ret1.numpy(), dy_ret2.numpy())
1369 1370 1371

            conv3d2.weight = conv3d1.weight
            conv3d2.bias = conv3d1.bias
1372 1373 1374 1375 1376 1377
            np.testing.assert_array_equal(
                conv3d1.weight.numpy(), conv3d2.weight.numpy()
            )
            np.testing.assert_array_equal(
                conv3d1.bias.numpy(), conv3d2.bias.numpy()
            )
1378

1379
    def func_while_loop(self):
1380 1381 1382 1383 1384
        with self.static_graph():
            i = layers.fill_constant(shape=[1], dtype='int64', value=0)
            ten = layers.fill_constant(shape=[1], dtype='int64', value=10)

            def cond(i):
L
LiYuRio 已提交
1385
                return paddle.less_than(i, ten)
1386 1387 1388 1389

            def body(i):
                return i + 1

1390
            out = paddle.static.nn.while_loop(cond, body, [i])
1391 1392 1393 1394 1395 1396
            static_ret = self.get_static_graph_result(feed={}, fetch_list=out)

        with self.dynamic_graph():
            i = layers.fill_constant(shape=[1], dtype='int64', value=0)
            ten = layers.fill_constant(shape=[1], dtype='int64', value=10)

1397
            def cond1(i):
L
LiYuRio 已提交
1398
                return paddle.less_than(i, ten)
1399

1400
            def body1(i):
1401 1402
                return i + 1

1403
            dy_ret = paddle.static.nn.while_loop(cond1, body1, [i])
1404 1405 1406 1407 1408 1409
            with self.assertRaises(ValueError):
                j = layers.fill_constant(shape=[1], dtype='int64', value=0)

                def body2(i):
                    return i + 1, i + 2

1410
                paddle.static.nn.while_loop(cond1, body2, [j])
1411

1412
        np.testing.assert_array_equal(static_ret[0], dy_ret[0].numpy())
1413

1414 1415 1416 1417 1418
    def test_while_loop(self):
        with _test_eager_guard():
            self.func_while_loop()
        self.func_while_loop()

1419 1420 1421 1422 1423 1424 1425
    def test_compare(self):
        value_a = np.arange(3)
        value_b = np.arange(3)
        # less than
        with self.static_graph():
            a = layers.data(name='a', shape=[1], dtype='int64')
            b = layers.data(name='b', shape=[1], dtype='int64')
L
LiYuRio 已提交
1426
            cond = paddle.less_than(x=a, y=b)
1427 1428 1429
            static_ret = self.get_static_graph_result(
                feed={"a": value_a, "b": value_b}, fetch_list=[cond]
            )[0]
1430
        with self.dynamic_graph():
1431 1432 1433
            with _test_eager_guard():
                da = base.to_variable(value_a)
                db = base.to_variable(value_b)
L
LiYuRio 已提交
1434
                dcond = paddle.less_than(x=da, y=db)
1435 1436 1437 1438

                for i in range(len(static_ret)):
                    self.assertTrue(dcond.numpy()[i] == static_ret[i])

1439 1440
            da = base.to_variable(value_a)
            db = base.to_variable(value_b)
L
LiYuRio 已提交
1441
            dcond = paddle.less_than(x=da, y=db)
1442

1443 1444
            for i in range(len(static_ret)):
                self.assertTrue(dcond.numpy()[i] == static_ret[i])
1445 1446 1447 1448 1449

        # less equal
        with self.static_graph():
            a1 = layers.data(name='a1', shape=[1], dtype='int64')
            b1 = layers.data(name='b1', shape=[1], dtype='int64')
1450
            cond1 = paddle.less_equal(x=a1, y=b1)
1451 1452 1453
            static_ret1 = self.get_static_graph_result(
                feed={"a1": value_a, "b1": value_b}, fetch_list=[cond1]
            )[0]
1454
        with self.dynamic_graph():
1455 1456 1457
            with _test_eager_guard():
                da1 = base.to_variable(value_a)
                db1 = base.to_variable(value_b)
1458
                dcond1 = paddle.less_equal(x=da1, y=db1)
1459 1460 1461 1462

                for i in range(len(static_ret1)):
                    self.assertTrue(dcond1.numpy()[i] == static_ret1[i])

1463 1464
            da1 = base.to_variable(value_a)
            db1 = base.to_variable(value_b)
1465
            dcond1 = paddle.less_equal(x=da1, y=db1)
1466 1467 1468 1469

            for i in range(len(static_ret1)):
                self.assertTrue(dcond1.numpy()[i] == static_ret1[i])

1470
        # greater than
1471 1472 1473
        with self.static_graph():
            a2 = layers.data(name='a2', shape=[1], dtype='int64')
            b2 = layers.data(name='b2', shape=[1], dtype='int64')
1474
            cond2 = paddle.greater_than(x=a2, y=b2)
1475 1476 1477
            static_ret2 = self.get_static_graph_result(
                feed={"a2": value_a, "b2": value_b}, fetch_list=[cond2]
            )[0]
1478
        with self.dynamic_graph():
1479 1480 1481
            with _test_eager_guard():
                da2 = base.to_variable(value_a)
                db2 = base.to_variable(value_b)
1482
                dcond2 = paddle.greater_than(x=da2, y=db2)
1483 1484 1485 1486

                for i in range(len(static_ret2)):
                    self.assertTrue(dcond2.numpy()[i] == static_ret2[i])

1487 1488
            da2 = base.to_variable(value_a)
            db2 = base.to_variable(value_b)
1489
            dcond2 = paddle.greater_than(x=da2, y=db2)
1490 1491 1492 1493

            for i in range(len(static_ret2)):
                self.assertTrue(dcond2.numpy()[i] == static_ret2[i])

1494
        # greater equal
1495 1496 1497
        with self.static_graph():
            a3 = layers.data(name='a3', shape=[1], dtype='int64')
            b3 = layers.data(name='b3', shape=[1], dtype='int64')
1498
            cond3 = paddle.greater_equal(x=a3, y=b3)
1499 1500 1501
            static_ret3 = self.get_static_graph_result(
                feed={"a3": value_a, "b3": value_b}, fetch_list=[cond3]
            )[0]
1502
        with self.dynamic_graph():
1503 1504 1505
            with _test_eager_guard():
                da3 = base.to_variable(value_a)
                db3 = base.to_variable(value_b)
1506
                dcond3 = paddle.greater_equal(x=da3, y=db3)
1507 1508 1509 1510

                for i in range(len(static_ret3)):
                    self.assertTrue(dcond3.numpy()[i] == static_ret3[i])

1511 1512
            da3 = base.to_variable(value_a)
            db3 = base.to_variable(value_b)
1513
            dcond3 = paddle.greater_equal(x=da3, y=db3)
1514 1515 1516 1517 1518 1519 1520 1521

            for i in range(len(static_ret3)):
                self.assertTrue(dcond3.numpy()[i] == static_ret3[i])

        # equal
        with self.static_graph():
            a4 = layers.data(name='a4', shape=[1], dtype='int64')
            b4 = layers.data(name='b4', shape=[1], dtype='int64')
1522
            cond4 = paddle.equal(x=a4, y=b4)
1523 1524 1525
            static_ret4 = self.get_static_graph_result(
                feed={"a4": value_a, "b4": value_b}, fetch_list=[cond4]
            )[0]
1526
        with self.dynamic_graph():
1527 1528 1529
            with _test_eager_guard():
                da4 = base.to_variable(value_a)
                db4 = base.to_variable(value_b)
1530
                dcond4 = paddle.equal(x=da4, y=db4)
1531 1532 1533 1534

                for i in range(len(static_ret4)):
                    self.assertTrue(dcond4.numpy()[i] == static_ret4[i])

1535 1536
            da4 = base.to_variable(value_a)
            db4 = base.to_variable(value_b)
1537
            dcond4 = paddle.equal(x=da4, y=db4)
1538 1539 1540 1541 1542 1543 1544 1545

            for i in range(len(static_ret4)):
                self.assertTrue(dcond4.numpy()[i] == static_ret4[i])

        # not equal
        with self.static_graph():
            a5 = layers.data(name='a5', shape=[1], dtype='int64')
            b5 = layers.data(name='b5', shape=[1], dtype='int64')
1546
            cond5 = paddle.equal(x=a5, y=b5)
1547 1548 1549
            static_ret5 = self.get_static_graph_result(
                feed={"a5": value_a, "b5": value_b}, fetch_list=[cond5]
            )[0]
1550
        with self.dynamic_graph():
1551 1552 1553
            with _test_eager_guard():
                da5 = base.to_variable(value_a)
                db5 = base.to_variable(value_b)
1554
                dcond5 = paddle.equal(x=da5, y=db5)
1555 1556 1557 1558

                for i in range(len(static_ret5)):
                    self.assertTrue(dcond5.numpy()[i] == static_ret5[i])

1559 1560
            da5 = base.to_variable(value_a)
            db5 = base.to_variable(value_b)
1561
            dcond5 = paddle.equal(x=da5, y=db5)
1562 1563 1564 1565

            for i in range(len(static_ret5)):
                self.assertTrue(dcond5.numpy()[i] == static_ret5[i])

1566 1567
    def test_cond(self):
        def less_than_branch(a, b):
1568
            return paddle.add(a, b)
1569 1570

        def greater_equal_branch(a, b):
1571
            return paddle.subtract(a, b)
1572 1573

        with self.static_graph():
1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589
            a = fluid.layers.fill_constant(
                shape=[1], dtype='float32', value=0.1
            )
            b = fluid.layers.fill_constant(
                shape=[1], dtype='float32', value=0.23
            )
            out = fluid.layers.cond(
                a >= b,
                lambda: greater_equal_branch(a, b),
                lambda: less_than_branch(a, b),
            )
            place = (
                fluid.CUDAPlace(0)
                if core.is_compiled_with_cuda()
                else fluid.CPUPlace()
            )
1590 1591 1592 1593 1594
            exe = fluid.Executor(place)
            ret = exe.run(fetch_list=[out])
            static_res = ret[0]

        with self.dynamic_graph():
1595 1596 1597
            with _test_eager_guard():
                a = fluid.dygraph.to_variable(np.array([0.1]).astype('float32'))
                b = fluid.dygraph.to_variable(
1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609
                    np.array([0.23]).astype('float32')
                )
                out = layers.cond(
                    a < b,
                    lambda: less_than_branch(a, b),
                    lambda: greater_equal_branch(a, b),
                )
                out2 = layers.cond(
                    a >= b,
                    lambda: greater_equal_branch(a, b),
                    lambda: less_than_branch(a, b),
                )
1610 1611
                eager_dynamic_res = out.numpy()
                eager_dynamic_res2 = out2.numpy()
1612 1613 1614
                np.testing.assert_array_equal(
                    eager_dynamic_res, eager_dynamic_res2
                )
1615 1616 1617 1618 1619
                with self.assertRaises(TypeError):
                    layers.cond(a < b, 'str', 'str')
                with self.assertRaises(TypeError):
                    layers.cond(a >= b, 'str', 'str')

1620 1621
            a = fluid.dygraph.to_variable(np.array([0.1]).astype('float32'))
            b = fluid.dygraph.to_variable(np.array([0.23]).astype('float32'))
1622 1623 1624 1625 1626 1627 1628 1629 1630 1631
            out = layers.cond(
                a < b,
                lambda: less_than_branch(a, b),
                lambda: greater_equal_branch(a, b),
            )
            out2 = layers.cond(
                a >= b,
                lambda: greater_equal_branch(a, b),
                lambda: less_than_branch(a, b),
            )
1632 1633
            dynamic_res = out.numpy()
            dynamic_res2 = out2.numpy()
1634
            np.testing.assert_array_equal(dynamic_res, dynamic_res2)
1635 1636 1637 1638 1639
            with self.assertRaises(TypeError):
                layers.cond(a < b, 'str', 'str')
            with self.assertRaises(TypeError):
                layers.cond(a >= b, 'str', 'str')

1640 1641
        np.testing.assert_array_equal(static_res, dynamic_res)
        np.testing.assert_array_equal(static_res, eager_dynamic_res)
1642

1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657
    def test_case(self):
        def fn_1():
            return layers.fill_constant(shape=[1, 2], dtype='float32', value=1)

        def fn_2():
            return layers.fill_constant(shape=[2, 2], dtype='int32', value=2)

        def fn_3():
            return layers.fill_constant(shape=[3], dtype='int32', value=3)

        with self.static_graph():
            x = layers.fill_constant(shape=[1], dtype='float32', value=0.3)
            y = layers.fill_constant(shape=[1], dtype='float32', value=0.1)
            z = layers.fill_constant(shape=[1], dtype='float32', value=0.2)

L
LiYuRio 已提交
1658 1659
            pred_1 = paddle.less_than(z, x)  # true: 0.2 < 0.3
            pred_2 = paddle.less_than(x, y)  # false: 0.3 < 0.1
1660
            pred_3 = paddle.equal(x, y)  # false: 0.3 == 0.1
1661

1662
            out_1 = paddle.static.nn.case(
1663 1664
                pred_fn_pairs=[(pred_1, fn_1), (pred_2, fn_2)], default=fn_3
            )
1665 1666 1667
            out_2 = paddle.static.nn.case(
                pred_fn_pairs=[(pred_2, fn_2), (pred_3, fn_3)]
            )
1668

1669 1670 1671 1672 1673
            place = (
                fluid.CUDAPlace(0)
                if core.is_compiled_with_cuda()
                else fluid.CPUPlace()
            )
1674 1675 1676 1677
            exe = fluid.Executor(place)
            static_res1, static_res2 = exe.run(fetch_list=[out_1, out_2])

        with self.dynamic_graph():
1678 1679 1680 1681 1682
            with _test_eager_guard():
                x = layers.fill_constant(shape=[1], dtype='float32', value=0.3)
                y = layers.fill_constant(shape=[1], dtype='float32', value=0.1)
                z = layers.fill_constant(shape=[1], dtype='float32', value=0.2)

L
LiYuRio 已提交
1683 1684
                pred_1 = paddle.less_than(z, x)  # true: 0.2 < 0.3
                pred_2 = paddle.less_than(x, y)  # false: 0.3 < 0.1
1685
                pred_3 = paddle.equal(x, y)  # false: 0.3 == 0.1
1686

1687
                out_1 = paddle.static.nn.case(
1688 1689
                    pred_fn_pairs=[(pred_1, fn_1), (pred_2, fn_2)], default=fn_3
                )
1690
                out_2 = paddle.static.nn.case(
1691 1692
                    pred_fn_pairs=[(pred_2, fn_2), (pred_3, fn_3)]
                )
1693 1694 1695
                eager_dynamic_res1 = out_1.numpy()
                eager_dynamic_res2 = out_2.numpy()

1696 1697 1698 1699
            x = layers.fill_constant(shape=[1], dtype='float32', value=0.3)
            y = layers.fill_constant(shape=[1], dtype='float32', value=0.1)
            z = layers.fill_constant(shape=[1], dtype='float32', value=0.2)

L
LiYuRio 已提交
1700 1701
            pred_1 = paddle.less_than(z, x)  # true: 0.2 < 0.3
            pred_2 = paddle.less_than(x, y)  # false: 0.3 < 0.1
1702
            pred_3 = paddle.equal(x, y)  # false: 0.3 == 0.1
1703

1704
            out_1 = paddle.static.nn.case(
1705 1706
                pred_fn_pairs=[(pred_1, fn_1), (pred_2, fn_2)], default=fn_3
            )
1707 1708 1709
            out_2 = paddle.static.nn.case(
                pred_fn_pairs=[(pred_2, fn_2), (pred_3, fn_3)]
            )
1710 1711 1712
            dynamic_res1 = out_1.numpy()
            dynamic_res2 = out_2.numpy()

1713 1714 1715 1716
        np.testing.assert_array_equal(static_res1, dynamic_res1)
        np.testing.assert_array_equal(static_res2, dynamic_res2)
        np.testing.assert_array_equal(static_res1, eager_dynamic_res1)
        np.testing.assert_array_equal(static_res2, eager_dynamic_res2)
1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731

    def test_switch_case(self):
        def fn_1():
            return layers.fill_constant(shape=[1, 2], dtype='float32', value=1)

        def fn_2():
            return layers.fill_constant(shape=[2, 2], dtype='int32', value=2)

        def fn_3():
            return layers.fill_constant(shape=[3], dtype='int32', value=3)

        with self.static_graph():
            index_1 = layers.fill_constant(shape=[1], dtype='int32', value=1)
            index_2 = layers.fill_constant(shape=[1], dtype='int32', value=2)

1732
            out_1 = paddle.static.nn.switch_case(
1733 1734 1735 1736
                branch_index=index_1,
                branch_fns={1: fn_1, 2: fn_2},
                default=fn_3,
            )
1737
            out_2 = paddle.static.nn.switch_case(
1738 1739 1740 1741
                branch_index=index_2,
                branch_fns=[(1, fn_1), (2, fn_2)],
                default=fn_3,
            )
1742
            out_3 = paddle.static.nn.switch_case(
1743 1744 1745 1746 1747 1748 1749 1750 1751
                branch_index=index_2,
                branch_fns=[(0, fn_1), (4, fn_2), (7, fn_3)],
            )

            place = (
                fluid.CUDAPlace(0)
                if core.is_compiled_with_cuda()
                else fluid.CPUPlace()
            )
1752 1753
            exe = fluid.Executor(place)
            static_res1, static_res2, static_res3 = exe.run(
1754 1755
                fetch_list=[out_1, out_2, out_3]
            )
1756 1757

        with self.dynamic_graph():
1758
            with _test_eager_guard():
1759 1760 1761 1762 1763 1764 1765
                index_1 = layers.fill_constant(
                    shape=[1], dtype='int32', value=1
                )
                index_2 = layers.fill_constant(
                    shape=[1], dtype='int32', value=2
                )

1766
                out_1 = paddle.static.nn.switch_case(
1767 1768 1769 1770
                    branch_index=index_1,
                    branch_fns={1: fn_1, 2: fn_2},
                    default=fn_3,
                )
1771
                out_2 = paddle.static.nn.switch_case(
1772 1773 1774 1775
                    branch_index=index_2,
                    branch_fns=[(1, fn_1), (2, fn_2)],
                    default=fn_3,
                )
1776
                out_3 = paddle.static.nn.switch_case(
1777 1778 1779
                    branch_index=index_2,
                    branch_fns=[(0, fn_1), (4, fn_2), (7, fn_3)],
                )
1780 1781 1782 1783 1784

                eager_dynamic_res1 = out_1.numpy()
                eager_dynamic_res2 = out_2.numpy()
                eager_dynamic_res3 = out_3.numpy()

1785 1786 1787
            index_1 = layers.fill_constant(shape=[1], dtype='int32', value=1)
            index_2 = layers.fill_constant(shape=[1], dtype='int32', value=2)

1788
            out_1 = paddle.static.nn.switch_case(
1789 1790 1791 1792
                branch_index=index_1,
                branch_fns={1: fn_1, 2: fn_2},
                default=fn_3,
            )
1793
            out_2 = paddle.static.nn.switch_case(
1794 1795 1796 1797
                branch_index=index_2,
                branch_fns=[(1, fn_1), (2, fn_2)],
                default=fn_3,
            )
1798
            out_3 = paddle.static.nn.switch_case(
1799 1800 1801
                branch_index=index_2,
                branch_fns=[(0, fn_1), (4, fn_2), (7, fn_3)],
            )
1802 1803 1804 1805 1806

            dynamic_res1 = out_1.numpy()
            dynamic_res2 = out_2.numpy()
            dynamic_res3 = out_3.numpy()

1807 1808 1809 1810 1811 1812
        np.testing.assert_array_equal(static_res1, dynamic_res1)
        np.testing.assert_array_equal(static_res2, dynamic_res2)
        np.testing.assert_array_equal(static_res3, dynamic_res3)
        np.testing.assert_array_equal(static_res1, eager_dynamic_res1)
        np.testing.assert_array_equal(static_res2, eager_dynamic_res2)
        np.testing.assert_array_equal(static_res3, eager_dynamic_res3)
1813

1814 1815 1816 1817
    def test_crop_tensor(self):
        with self.static_graph():
            x = fluid.layers.data(name="x1", shape=[6, 5, 8])

1818 1819 1820 1821 1822 1823
            dim1 = fluid.layers.data(
                name="dim1", shape=[1], append_batch_size=False
            )
            dim2 = fluid.layers.data(
                name="dim2", shape=[1], append_batch_size=False
            )
1824
            crop_shape1 = (1, 2, 4, 4)
1825 1826 1827
            crop_shape2 = fluid.layers.data(
                name="crop_shape", shape=[4], append_batch_size=False
            )
1828 1829
            crop_shape3 = [-1, dim1, dim2, 4]
            crop_offsets1 = [0, 0, 1, 0]
1830 1831 1832
            crop_offsets2 = fluid.layers.data(
                name="crop_offset", shape=[4], append_batch_size=False
            )
1833 1834
            crop_offsets3 = [0, dim1, dim2, 0]

1835 1836 1837
            out1 = paddle.crop(x, shape=crop_shape1, offsets=crop_offsets1)
            out2 = paddle.crop(x, shape=crop_shape2, offsets=crop_offsets2)
            out3 = paddle.crop(x, shape=crop_shape3, offsets=crop_offsets3)
1838 1839 1840 1841 1842

            self.assertIsNotNone(out1)
            self.assertIsNotNone(out2)
            self.assertIsNotNone(out3)

1843 1844 1845
    def test_shard_index(self):
        with self.static_graph():
            x = fluid.layers.data(name="label", shape=[4, 1], dtype='int64')
1846
            shard_label = paddle.shard_index(
1847 1848
                input=x, index_num=20, nshards=2, shard_id=0
            )
1849 1850 1851

        self.assertIsNotNone(shard_label)

1852 1853 1854 1855 1856 1857 1858
    def test_accuracy(self):
        x = np.random.rand(3, 32, 32).astype("float32")
        y = np.array([[1], [0], [1]])
        with self.static_graph():
            data = fluid.data(name="input", shape=[-1, 32, 32], dtype="float32")
            label = fluid.data(name="label", shape=[-1, 1], dtype="int")
            fc_out = fluid.layers.fc(input=data, size=10)
1859
            predict = paddle.nn.functional.softmax(fc_out)
1860
            result = paddle.static.accuracy(input=predict, label=label, k=5)
1861 1862 1863 1864
            place = fluid.CPUPlace()
            exe = fluid.Executor(place)

            exe.run(fluid.default_startup_program())
L
Leo Chen 已提交
1865 1866
            # x = np.random.rand(3, 32, 32).astype("float32")
            # y = np.array([[1], [0], [1]])
1867 1868 1869
            static_out = exe.run(
                feed={"input": x, "label": y}, fetch_list=result[0]
            )
1870

L
Leo Chen 已提交
1871
        with self.dynamic_graph(force_to_use_cpu=True):
1872 1873 1874
            data = base.to_variable(x)
            label = base.to_variable(y)
            fc_out = fluid.layers.fc(data, size=10)
1875
            predict = paddle.nn.functional.softmax(fc_out)
1876 1877 1878
            dynamic_out = paddle.static.accuracy(
                input=predict, label=label, k=5
            )
1879

1880
        np.testing.assert_array_equal(static_out[0], dynamic_out.numpy())
1881

Y
Yu Yang 已提交
1882

1883
class TestBook(LayerTest):
H
hong 已提交
1884 1885
    def setUp(self):
        self.only_static_set = set({"make_word_embedding"})
1886 1887 1888 1889 1890 1891 1892
        self.not_compare_static_dygraph_set = set(
            {
                "make_gaussian_random",
                "make_kldiv_loss",
                "make_uniform_random_batch_size_like",
            }
        )
1893
        self.all_close_compare = set({"make_spectral_norm"})
H
hong 已提交
1894

1895
    def func_all_layers(self):
1896 1897 1898 1899 1900
        attrs = (getattr(self, name) for name in dir(self))
        methods = filter(inspect.ismethod, attrs)
        for method in methods:
            if not method.__name__.startswith('make_'):
                continue
M
minqiyang 已提交
1901 1902 1903
            self._low_data_bound = 0
            self._high_data_bound = 2
            self._batch_size = 2
1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915
            self._feed_dict = {}
            self._force_to_use_cpu = False
            with self.static_graph():
                static_var = method()
                if isinstance(static_var, tuple):
                    static_var = static_var[0]

                if static_var is not None:
                    fetch_list = [static_var.name]
                    static_result = self.get_static_graph_result(
                        feed=self._feed_dict,
                        fetch_list=fetch_list,
1916 1917
                        force_to_use_cpu=self._force_to_use_cpu,
                    )
H
hong 已提交
1918

1919 1920
                else:
                    continue
H
hong 已提交
1921 1922
            if method.__name__ in self.only_static_set:
                continue
1923 1924 1925 1926 1927

            with self.dynamic_graph(self._force_to_use_cpu):
                dy_result = method()
                if isinstance(dy_result, tuple):
                    dy_result = dy_result[0]
1928
                dy_result_value = dy_result.numpy()
1929

1930
            if method.__name__ in self.all_close_compare:
1931 1932 1933 1934 1935 1936
                np.testing.assert_allclose(
                    static_result[0],
                    dy_result_value,
                    rtol=1e-05,
                    atol=0,
                    err_msg='Result of function [{}] compare failed'.format(
1937 1938 1939
                        method.__name__
                    ),
                )
1940 1941
                continue

H
hong 已提交
1942
            if method.__name__ not in self.not_compare_static_dygraph_set:
1943 1944 1945 1946
                np.testing.assert_array_equal(
                    static_result[0],
                    dy_result_value,
                    err_msg='Result of function [{}] not equal'.format(
1947 1948 1949
                        method.__name__
                    ),
                )
1950

1951 1952 1953 1954 1955
    def test_all_layers(self):
        with _test_eager_guard():
            self.func_all_layers()
        self.func_all_layers()

1956 1957 1958
    def _get_np_data(self, shape, dtype, append_batch_size=True):
        np.random.seed(self.seed)
        if append_batch_size:
M
minqiyang 已提交
1959
            shape = [self._batch_size] + shape
1960 1961 1962 1963 1964
        if dtype == 'float32':
            return np.random.random(shape).astype(dtype)
        elif dtype == 'float64':
            return np.random.random(shape).astype(dtype)
        elif dtype == 'int32':
1965 1966 1967
            return np.random.randint(
                self._low_data_bound, self._high_data_bound, shape
            ).astype(dtype)
1968
        elif dtype == 'int64':
1969 1970 1971 1972 1973 1974 1975
            return np.random.randint(
                self._low_data_bound, self._high_data_bound, shape
            ).astype(dtype)

    def _get_data(
        self, name, shape, dtype, set_feed_dict=True, append_batch_size=True
    ):
1976
        if base.enabled():
1977 1978 1979 1980 1981
            return base.to_variable(
                value=self._get_np_data(shape, dtype, append_batch_size),
                name=name,
                zero_copy=False,
            )
1982 1983
        else:
            if set_feed_dict:
1984
                self._feed_dict[name] = self._get_np_data(
1985 1986 1987 1988 1989 1990 1991 1992
                    shape, dtype, append_batch_size
                )
            return layers.data(
                name=name,
                shape=shape,
                dtype=dtype,
                append_batch_size=append_batch_size,
            )
1993 1994

    def make_fit_a_line(self):
1995 1996 1997 1998
        with program_guard(
            fluid.default_main_program(),
            startup_program=fluid.default_startup_program(),
        ):
1999
            x = self._get_data(name='x', shape=[13], dtype='float32')
Y
Yu Yang 已提交
2000
            y_predict = layers.fc(input=x, size=1, act=None)
2001
            y = self._get_data(name='y', shape=[1], dtype='float32')
2002 2003 2004
            cost = paddle.nn.functional.square_error_cost(
                input=y_predict, label=y
            )
2005
            avg_cost = paddle.mean(cost)
2006
            return avg_cost
Y
Yu Yang 已提交
2007

2008
    def make_recognize_digits_mlp(self):
2009 2010 2011
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
Y
Yu Yang 已提交
2012
            # Change g_program, so the rest layers use `g_program`
2013 2014
            images = self._get_data(name='pixel', shape=[784], dtype='float32')
            label = self._get_data(name='label', shape=[1], dtype='int64')
Y
Yu Yang 已提交
2015 2016
            hidden1 = layers.fc(input=images, size=128, act='relu')
            hidden2 = layers.fc(input=hidden1, size=64, act='relu')
2017 2018 2019 2020 2021 2022
            predict = layers.fc(
                input=[hidden2, hidden1],
                size=10,
                act='softmax',
                param_attr=["sftmax.w1", "sftmax.w2"],
            )
Y
Yu Yang 已提交
2023
            cost = layers.cross_entropy(input=predict, label=label)
2024
            avg_cost = paddle.mean(cost)
2025
            return avg_cost
Y
Yu Yang 已提交
2026

2027
    def make_conv2d_transpose(self):
2028 2029 2030
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
2031
            img = self._get_data(name='pixel', shape=[3, 2, 2], dtype='float32')
2032
            return paddle.static.nn.conv2d_transpose(
2033 2034
                input=img, num_filters=10, output_size=28
            )
2035

2036
    def make_recognize_digits_conv(self):
2037 2038 2039 2040 2041 2042
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
            images = self._get_data(
                name='pixel', shape=[1, 28, 28], dtype='float32'
            )
2043
            label = self._get_data(name='label', shape=[1], dtype='int64')
2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059
            conv_pool_1 = nets.simple_img_conv_pool(
                input=images,
                filter_size=5,
                num_filters=2,
                pool_size=2,
                pool_stride=2,
                act="relu",
            )
            conv_pool_2 = nets.simple_img_conv_pool(
                input=conv_pool_1,
                filter_size=5,
                num_filters=4,
                pool_size=2,
                pool_stride=2,
                act="relu",
            )
Y
Yu Yang 已提交
2060 2061 2062

            predict = layers.fc(input=conv_pool_2, size=10, act="softmax")
            cost = layers.cross_entropy(input=predict, label=label)
2063
            avg_cost = paddle.mean(cost)
2064
            return avg_cost
Y
Yu Yang 已提交
2065

2066
    def make_word_embedding(self):
2067 2068 2069
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
Y
Yu Yang 已提交
2070 2071
            dict_size = 10000
            embed_size = 32
2072
            first_word = self._get_data(name='firstw', shape=[1], dtype='int64')
2073 2074 2075
            second_word = self._get_data(
                name='secondw', shape=[1], dtype='int64'
            )
2076 2077 2078
            third_word = self._get_data(name='thirdw', shape=[1], dtype='int64')
            forth_word = self._get_data(name='forthw', shape=[1], dtype='int64')
            next_word = self._get_data(name='nextw', shape=[1], dtype='int64')
Y
Yu Yang 已提交
2079

2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104
            embed_first = layers.embedding(
                input=first_word,
                size=[dict_size, embed_size],
                dtype='float32',
                param_attr='shared_w',
            )
            embed_second = layers.embedding(
                input=second_word,
                size=[dict_size, embed_size],
                dtype='float32',
                param_attr='shared_w',
            )

            embed_third = layers.embedding(
                input=third_word,
                size=[dict_size, embed_size],
                dtype='float32',
                param_attr='shared_w',
            )
            embed_forth = layers.embedding(
                input=forth_word,
                size=[dict_size, embed_size],
                dtype='float32',
                param_attr='shared_w',
            )
Y
Yu Yang 已提交
2105 2106 2107

            concat_embed = layers.concat(
                input=[embed_first, embed_second, embed_third, embed_forth],
2108 2109
                axis=1,
            )
Y
Yu Yang 已提交
2110 2111

            hidden1 = layers.fc(input=concat_embed, size=256, act='sigmoid')
2112 2113 2114
            predict_word = layers.fc(
                input=hidden1, size=dict_size, act='softmax'
            )
Y
Yu Yang 已提交
2115
            cost = layers.cross_entropy(input=predict_word, label=next_word)
2116
            avg_cost = paddle.mean(cost)
2117
            return avg_cost
Y
Yu Yang 已提交
2118

2119
    def make_pool2d(self):
2120 2121 2122
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
2123
            x = self._get_data(name='x', shape=[3, 224, 224], dtype='float32')
C
ccrrong 已提交
2124 2125
            return paddle.nn.functional.max_pool2d(
                x, kernel_size=[5, 3], stride=[1, 2], padding=(2, 1)
2126
            )
2127

K
Kaipeng Deng 已提交
2128
    def make_pool2d_infershape(self):
2129 2130 2131
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
K
Kaipeng Deng 已提交
2132
            theta = self._get_data("theta", shape=[2, 3], dtype='float32')
2133 2134 2135
            x = paddle.nn.functional.affine_grid(
                theta, out_shape=[2, 3, 244, 244]
            )
C
ccrrong 已提交
2136 2137
            return paddle.nn.functional.max_pool2d(
                x, kernel_size=[5, 3], stride=[1, 2], padding=(2, 1)
2138
            )
K
Kaipeng Deng 已提交
2139

2140
    def make_lstm_unit(self):
2141 2142 2143 2144 2145 2146
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
            x_t_data = self._get_data(
                name='x_t_data', shape=[10, 10], dtype='float32'
            )
Y
yangyaming 已提交
2147
            x_t = layers.fc(input=x_t_data, size=10)
2148 2149 2150
            prev_hidden_data = self._get_data(
                name='prev_hidden_data', shape=[10, 30], dtype='float32'
            )
Y
yangyaming 已提交
2151
            prev_hidden = layers.fc(input=prev_hidden_data, size=30)
2152 2153 2154
            prev_cell_data = self._get_data(
                name='prev_cell', shape=[10, 30], dtype='float32'
            )
Y
yangyaming 已提交
2155
            prev_cell = layers.fc(input=prev_cell_data, size=30)
2156 2157 2158
            return layers.lstm_unit(
                x_t=x_t, hidden_t_prev=prev_hidden, cell_t_prev=prev_cell
            )
2159

2160
    def make_softmax(self):
2161 2162 2163
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
2164
            data = self._get_data(name='data', shape=[10], dtype='float32')
D
dangqingqing 已提交
2165
            hid = layers.fc(input=data, size=20)
2166
            return paddle.nn.functional.softmax(hid, axis=1)
D
dangqingqing 已提交
2167

2168
    @prog_scope()
2169
    def make_nce(self):
Y
Yang Yu 已提交
2170 2171
        window_size = 5
        words = []
2172
        for i in range(window_size):
Y
Yang Yu 已提交
2173
            words.append(
2174 2175 2176 2177
                self._get_data(
                    name='word_{0}'.format(i), shape=[1], dtype='int64'
                )
            )
Y
Yang Yu 已提交
2178 2179

        dict_size = 10000
M
minqiyang 已提交
2180
        label_word = int(window_size // 2) + 1
Y
Yang Yu 已提交
2181 2182

        embs = []
2183
        for i in range(window_size):
Y
Yang Yu 已提交
2184 2185 2186
            if i == label_word:
                continue

2187 2188 2189 2190 2191 2192
            emb = layers.embedding(
                input=words[i],
                size=[dict_size, 32],
                param_attr='emb.w',
                is_sparse=True,
            )
Y
Yang Yu 已提交
2193 2194 2195 2196

            embs.append(emb)

        embs = layers.concat(input=embs, axis=1)
2197
        loss = paddle.static.nn.nce(
2198 2199 2200 2201 2202 2203
            input=embs,
            label=words[label_word],
            num_total_classes=dict_size,
            param_attr='nce.w',
            bias_attr='nce.b',
        )
2204
        avg_loss = paddle.mean(loss)
2205
        return avg_loss
Y
Yang Yu 已提交
2206

2207
    def make_multiplex(self):
2208 2209 2210
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
2211 2212 2213
            x1 = self._get_data(name='x1', shape=[4], dtype='float32')
            x2 = self._get_data(name='x2', shape=[4], dtype='float32')
            index = self._get_data(name='index', shape=[1], dtype='int32')
2214
            out = paddle.multiplex(inputs=[x1, x2], index=index)
2215
            return out
2216 2217

    def make_softmax_with_cross_entropy(self):
2218 2219 2220
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
2221 2222
            x = self._get_data(name='x', shape=[16], dtype='float32')
            y = self._get_data(name='label', shape=[1], dtype='int64')
2223
            loss, softmax = paddle.nn.functional.softmax_with_cross_entropy(
2224 2225
                x, y, return_softmax=True
            )
2226 2227 2228
            self.assertIsNotNone(loss)
            self.assertIsNotNone(softmax)

2229
            loss = paddle.nn.functional.softmax_with_cross_entropy(x, y)
2230 2231 2232 2233 2234 2235
            self.assertIsNotNone(loss)

            x1 = self._get_data(name='x1', shape=[16, 32, 64], dtype='float32')
            y1 = self._get_data(name='label1', shape=[1, 32, 64], dtype='int64')
            y2 = self._get_data(name='label2', shape=[16, 1, 64], dtype='int64')
            y3 = self._get_data(name='label3', shape=[16, 32, 1], dtype='int64')
2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247
            loss1 = paddle.nn.functional.softmax_with_cross_entropy(
                x1, y1, axis=1
            )
            loss2 = paddle.nn.functional.softmax_with_cross_entropy(
                x1, y2, axis=2
            )
            loss3 = paddle.nn.functional.softmax_with_cross_entropy(
                x1, y3, axis=3
            )
            loss4 = paddle.nn.functional.softmax_with_cross_entropy(
                x1, y3, axis=-1
            )
2248 2249 2250 2251
            self.assertIsNotNone(loss1)
            self.assertIsNotNone(loss2)
            self.assertIsNotNone(loss3)
            self.assertIsNotNone(loss4)
2252
            return loss4
2253 2254

    def make_scatter(self):
2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
            x = self._get_data(
                name='x', shape=[3, 3], append_batch_size=False, dtype='float32'
            )
            idx = self._get_data(
                name='idx', shape=[2], append_batch_size=False, dtype='int32'
            )
            updates = self._get_data(
                name='updates',
                shape=[2, 3],
                append_batch_size=False,
                dtype='float32',
            )
2270
            out = paddle.scatter(x, index=idx, updates=updates)
2271
            return out
Y
yangyaming 已提交
2272

2273 2274 2275 2276
    def make_one_hot(self):
        with fluid.framework._dygraph_place_guard(place=fluid.CPUPlace()):
            label = self._get_data(name="label", shape=[1], dtype="int32")
            one_hot_label = layers.one_hot(input=label, depth=10)
2277
            return one_hot_label
2278

2279 2280 2281 2282 2283
    def make_label_smooth(self):
        # TODO(minqiyang): support gpu ut
        self._force_to_use_cpu = True
        with fluid.framework._dygraph_place_guard(place=fluid.CPUPlace()):
            label = self._get_data(name="label", shape=[1], dtype="int32")
2284
            one_hot_label = layers.one_hot(input=label, depth=10)
2285
            smooth_label = F.label_smooth(label=one_hot_label, epsilon=0.1)
2286
            return smooth_label
2287

2288
    def make_topk(self):
2289 2290 2291
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
2292
            data = self._get_data(name="label", shape=[200], dtype="float32")
2293
            values, indices = paddle.topk(data, k=5)
2294 2295
            return values
            return indices
J
jerrywgz 已提交
2296

2297
    def make_l2_normalize(self):
2298 2299 2300
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
2301
            x = self._get_data(name='x', shape=[8, 7, 10], dtype="float32")
2302
            output = layers.l2_normalize(x, axis=1)
2303
            return output
2304

2305
    def make_shape(self):
2306 2307 2308 2309 2310 2311
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
            input = self._get_data(
                name="input", shape=[3, 100, 100], dtype="float32"
            )
2
201716010711 已提交
2312
            out = paddle.shape(input)
2313
            return out
B
Bai Yifan 已提交
2314

2315
    def make_pad2d(self):
2316 2317 2318 2319 2320 2321
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
            input = self._get_data(
                name="input", shape=[3, 100, 100], dtype="float32"
            )
傅剑寒 已提交
2322 2323 2324

            tmp_pad = paddle.nn.Pad2D(
                padding=[1, 2, 3, 4],
2325 2326 2327 2328
                mode='reflect',
                data_format='NCHW',
                name="shape",
            )
傅剑寒 已提交
2329
            out = tmp_pad(input)
2330
            return out
W
whs 已提交
2331

K
Kaipeng Deng 已提交
2332
    def make_mish(self):
2333 2334 2335
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
K
Kaipeng Deng 已提交
2336
            input = self._get_data(name="input", shape=[16], dtype="float32")
2337
            out = paddle.nn.functional.mish(input, name='mish')
2338
            return out
K
Kaipeng Deng 已提交
2339

2340
    def make_cross_entropy(self):
2341 2342 2343
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
2344 2345
            x = self._get_data(name="x", shape=[30, 10], dtype="float32")
            label = self._get_data(name="label", shape=[30, 1], dtype="int64")
2346 2347
            mode = 'channel'
            out = layers.cross_entropy(x, label, False, 4)
2348
            return out
2349

2350
    def make_uniform_random_batch_size_like(self):
2351 2352 2353 2354 2355 2356
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
            input = self._get_data(
                name="input", shape=[13, 11], dtype='float32'
            )
2357
            out = random.uniform_random_batch_size_like(input, [-1, 11])
2358
            return out
G
fix  
gongweibao 已提交
2359

2360
    def make_gaussian_random(self):
2361 2362 2363
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
2364
            out = random.gaussian(shape=[20, 30])
2365
            return out
G
fix  
gongweibao 已提交
2366

2367
    def make_sum(self):
2368 2369 2370 2371 2372 2373
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
            input = self._get_data(
                name="input", shape=[13, 11], dtype='float32'
            )
G
fix  
gongweibao 已提交
2374

2375
            out = paddle.add_n(input)
2376
            return out
G
fix  
gongweibao 已提交
2377

2378
    def make_slice(self):
G
fix  
gongweibao 已提交
2379 2380 2381 2382
        starts = [1, 0, 2]
        ends = [3, 3, 4]
        axes = [0, 1, 2]

2383 2384 2385 2386 2387 2388
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
            input = self._get_data(
                name="input", shape=[3, 4, 5, 6], dtype='float32'
            )
G
fix  
gongweibao 已提交
2389

2
201716010711 已提交
2390
            out = paddle.slice(input, axes=axes, starts=starts, ends=ends)
2391
            return out
G
merge  
gongweibao 已提交
2392

2393
    def make_scale_variable(self):
2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
            input = self._get_data(
                name="input", shape=[3, 4, 5, 6], dtype='float32'
            )
            scale_var = self._get_data(
                name="scale",
                shape=[1],
                dtype='float32',
                append_batch_size=False,
            )
2
201716010711 已提交
2406
            out = paddle.scale(input, scale=scale_var)
2407 2408
            return out

2409
    def make_bilinear_tensor_product_layer(self):
2410 2411 2412
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
2413 2414 2415
            data = self._get_data(name='data', shape=[4], dtype="float32")

            theta = self._get_data(name="theta", shape=[5], dtype="float32")
2416 2417 2418
            out = paddle.static.nn.common.bilinear_tensor_product(
                data, theta, 6
            )
2419
            return out
2420 2421

    def make_batch_norm(self):
2422 2423 2424 2425 2426 2427
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
            data = self._get_data(
                name='data', shape=[32, 128, 128], dtype="float32"
            )
2428
            out = paddle.static.nn.batch_norm(data)
2429
            return out
2430

2431
    def make_batch_norm_momentum_variable(self):
2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
            data = self._get_data(
                name='data', shape=[32, 128, 128], dtype="float32"
            )
            momentum = self._get_data(
                name='momentum',
                shape=[1],
                dtype='float32',
                append_batch_size=False,
            )
2444
            out = paddle.static.nn.batch_norm(data, momentum=momentum)
2445
            return out
2446

2447
    def make_range(self):
2448 2449 2450
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
C
ccrrong 已提交
2451 2452 2453
            paddle.arange(0, 10, 2, 'int32')
            paddle.arange(0.1, 10.0, 0.2, 'float32')
            paddle.arange(0.1, 10.0, 0.2, 'float64')
2454 2455 2456
            start = layers.fill_constant(shape=[1], value=0.1, dtype="float32")
            end = layers.fill_constant(shape=[1], value=10.0, dtype="float32")
            step = layers.fill_constant(shape=[1], value=0.2, dtype="float32")
C
ccrrong 已提交
2457
            y = paddle.arange(start, end, step, 'float64')
2458 2459 2460
            return y

    def make_spectral_norm(self):
2461 2462 2463 2464 2465 2466 2467 2468 2469
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
            weight = self._get_data(
                name='weight',
                shape=[2, 3, 32, 32],
                dtype="float32",
                append_batch_size=False,
            )
2470
            out = layers.spectral_norm(weight, dim=1, power_iters=1)
2471
            return out
2472 2473

    def make_kldiv_loss(self):
2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
            x = self._get_data(
                name='x',
                shape=[32, 128, 128],
                dtype="float32",
                append_batch_size=False,
            )
            target = self._get_data(
                name='target',
                shape=[32, 128, 128],
                dtype="float32",
                append_batch_size=False,
            )
2489 2490 2491
            loss = paddle.nn.functional.kl_div(
                input=x, label=target, reduction='batchmean'
            )
2492
            return loss
2493

M
minqiyang 已提交
2494
    def make_pixel_shuffle(self):
2495 2496 2497
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
M
minqiyang 已提交
2498
            x = self._get_data(name="X", shape=[9, 4, 4], dtype="float32")
2499
            out = paddle.nn.functional.pixel_shuffle(x, upscale_factor=3)
2500
            return out
M
minqiyang 已提交
2501

R
ruri 已提交
2502
    def make_mse_loss(self):
2503 2504 2505
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
R
ruri 已提交
2506 2507
            x = self._get_data(name="X", shape=[1], dtype="float32")
            y = self._get_data(name="Y", shape=[1], dtype="float32")
2508
            out = paddle.nn.functional.mse_loss(input=x, label=y)
2509
            return out
R
ruri 已提交
2510

2511
    def make_square_error_cost(self):
2512 2513 2514
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
2515 2516
            x = self._get_data(name="X", shape=[1], dtype="float32")
            y = self._get_data(name="Y", shape=[1], dtype="float32")
2517
            out = paddle.nn.functional.square_error_cost(input=x, label=y)
2518
            return out
2519

2520 2521 2522 2523
    def test_dynamic_lstmp(self):
        # TODO(minqiyang): dygraph do not support lod now
        with self.static_graph():
            hidden_dim, proj_dim = 16, 8
2524 2525 2526
            seq_data = layers.data(
                name='seq_data', shape=[10, 10], dtype='float32', lod_level=1
            )
2527 2528
            fc_out = layers.fc(input=seq_data, size=4 * hidden_dim)
            self.assertIsNotNone(
2529 2530 2531 2532
                layers.dynamic_lstmp(
                    input=fc_out, size=4 * hidden_dim, proj_size=proj_dim
                )
            )
2533 2534 2535 2536

    def test_lod_reset(self):
        # TODO(minqiyang): dygraph do not support lod now
        with self.static_graph():
2537
            # case 1
2538
            x = layers.data(name='x', shape=[10], dtype='float32')
2539 2540 2541
            y = layers.data(
                name='y', shape=[10, 20], dtype='float32', lod_level=2
            )
2542 2543 2544
            z = layers.lod_reset(x=x, y=y)
            self.assertTrue(z.lod_level == 2)
            # case 2
2545
            lod_tensor_in = layers.data(name='lod_in', shape=[1], dtype='int32')
2546 2547 2548 2549 2550 2551
            z = layers.lod_reset(x=x, y=lod_tensor_in)
            self.assertTrue(z.lod_level == 1)
            # case 3
            z = layers.lod_reset(x=x, target_lod=[1, 2, 3])
            self.assertTrue(z.lod_level == 1)
            return z
2552

W
whs 已提交
2553
    def test_affine_grid(self):
2554
        with self.static_graph():
W
whs 已提交
2555
            data = layers.data(name='data', shape=[2, 3, 3], dtype="float32")
2556
            out = paddle.argsort(x=data, axis=1)
W
whs 已提交
2557 2558

            theta = layers.data(name="theta", shape=[2, 3], dtype="float32")
2559
            out_shape = layers.data(name="out_shape", shape=[-1], dtype="int32")
2560 2561
            data_0 = paddle.nn.functional.affine_grid(theta, out_shape)
            data_1 = paddle.nn.functional.affine_grid(theta, [5, 3, 28, 28])
W
whs 已提交
2562 2563 2564

            self.assertIsNotNone(data_0)
            self.assertIsNotNone(data_1)
D
dengkaipeng 已提交
2565

W
wangchaochaohu 已提交
2566 2567 2568 2569 2570 2571 2572
    def test_stridedslice(self):
        axes = [0, 1, 2]
        starts = [1, 0, 2]
        ends = [3, 3, 4]
        strides = [1, 1, 1]
        with self.static_graph():
            x = layers.data(name="x", shape=[245, 30, 30], dtype="float32")
2
201716010711 已提交
2573
            out = paddle.strided_slice(
2574 2575
                x, axes=axes, starts=starts, ends=ends, strides=strides
            )
W
wangchaochaohu 已提交
2576 2577
            return out

2578 2579
    def test_fill_constant_batch_size_like(self):
        with self.static_graph():
2580 2581 2582 2583 2584 2585
            like = fluid.layers.fill_constant(
                shape=[1, 200], value=10, dtype='int64'
            )
            out = layers.fill_constant_batch_size_like(
                input=like, shape=[2, 3300], value=1315454564656, dtype='int64'
            )
2586 2587
            return out

2588 2589 2590 2591
    def test_sequence_expand(self):
        # TODO(minqiyang): dygraph do not support lod now
        with self.static_graph():
            x = layers.data(name='x', shape=[10], dtype='float32')
2592 2593 2594 2595
            y = layers.data(
                name='y', shape=[10, 20], dtype='float32', lod_level=2
            )
            return layers.sequence_expand(x=x, y=y, ref_level=1)
2596

2597 2598 2599 2600 2601
    def test_sequence_reshape(self):
        # TODO(minqiyang): dygraph do not support lod now
        with self.static_graph():
            x = layers.data(name='x', shape=[8], dtype='float32', lod_level=1)
            out = layers.sequence_reshape(input=x, new_dim=16)
2602
            return out
2603

2604 2605 2606 2607
    def test_sequence_unpad(self):
        # TODO(minqiyang): dygraph do not support lod now
        with self.static_graph():
            x = layers.data(name='x', shape=[10, 5], dtype='float32')
2608
            length = layers.data(name='length', shape=[], dtype='int64')
2609
            return layers.sequence_unpad(x=x, length=length)
2610

2611 2612 2613
    def test_sequence_softmax(self):
        # TODO(minqiyang): dygraph do not support lod now
        with self.static_graph():
2614 2615 2616
            seq_data = layers.data(
                name='seq_data', shape=[10, 10], dtype='float32', lod_level=1
            )
2617
            seq = layers.fc(input=seq_data, size=20)
2618
            return layers.sequence_softmax(seq)
2619

2620 2621 2622 2623 2624
    def test_sequence_unsqueeze(self):
        # TODO(minqiyang): dygraph do not support lod now
        with self.static_graph():
            x = layers.data(name='x', shape=[8, 2], dtype='float32')
            out = layers.unsqueeze(input=x, axes=[1])
2625
            return out
2626

2627 2628 2629
    def test_sequence_scatter(self):
        # TODO(minqiyang): dygraph do not support lod now
        with self.static_graph():
2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646
            x = layers.data(
                name='x', shape=[3, 6], append_batch_size=False, dtype='float32'
            )
            idx = layers.data(
                name='idx',
                shape=[12, 1],
                append_batch_size=False,
                dtype='int32',
                lod_level=1,
            )
            updates = layers.data(
                name='updates',
                shape=[12, 1],
                append_batch_size=False,
                dtype='float32',
                lod_level=1,
            )
2647
            out = layers.sequence_scatter(input=x, index=idx, updates=updates)
2648
            return out
W
whs 已提交
2649

2650 2651 2652 2653
    def test_sequence_slice(self):
        # TODO(minqiyang): dygraph do not support lod now
        with self.static_graph():
            import numpy as np
2654 2655 2656 2657

            seqs = layers.data(
                name='x', shape=[10, 5], dtype='float32', lod_level=1
            )
2658 2659
            offset = layers.assign(input=np.array([[0, 1]]).astype('int32'))
            length = layers.assign(input=np.array([[2, 1]]).astype('int32'))
2660 2661 2662 2663
            out = layers.sequence_slice(
                input=seqs, offset=offset, length=length
            )
            return out
W
whs 已提交
2664

Z
zhoushiyu 已提交
2665 2666 2667
    def test_shuffle_batch(self):
        # TODO(minqiyang): dygraph do not support lod now
        with self.static_graph():
2668 2669 2670
            x = layers.data(
                name='X', shape=[4, 50], dtype='float32', lod_level=0
            )
Z
zhoushiyu 已提交
2671 2672 2673 2674 2675
            out1 = fluid.contrib.layers.shuffle_batch(x)
            default_main_program().random_seed = 1000
            out2 = fluid.contrib.layers.shuffle_batch(x)
            self.assertIsNotNone(out1)
            self.assertIsNotNone(out2)
2676
            return out1
Z
zhoushiyu 已提交
2677

2678 2679 2680 2681
    def test_partial_sum(self):
        with self.static_graph():
            x = fluid.data(name="x", shape=[None, 3], dtype="float32")
            y = fluid.data(name="y", shape=[None, 3], dtype="float32")
2682 2683 2684 2685
            sum = fluid.contrib.layers.partial_sum(
                [x, y], start_index=0, length=2
            )
            return sum
2686

S
ShenLiang 已提交
2687 2688 2689 2690 2691 2692 2693 2694 2695
    def test_batch_fc(self):
        with self.static_graph():
            input = fluid.data(name="input", shape=[16, 2, 3], dtype="float32")
            out = fluid.contrib.layers.batch_fc(
                input=input,
                param_size=[16, 3, 10],
                param_attr=fluid.ParamAttr(
                    learning_rate=1.0,
                    name="w_0",
2696 2697
                    initializer=fluid.initializer.Xavier(uniform=False),
                ),
S
ShenLiang 已提交
2698 2699 2700 2701
                bias_size=[16, 10],
                bias_attr=fluid.ParamAttr(
                    learning_rate=1.0,
                    name="b_0",
2702 2703 2704 2705 2706
                    initializer=fluid.initializer.Xavier(uniform=False),
                ),
                act="relu",
            )
        return out
S
ShenLiang 已提交
2707

S
ShenLiang 已提交
2708 2709 2710
    def test_rank_attention(self):
        with self.static_graph():
            input = fluid.data(name="input", shape=[None, 2], dtype="float32")
2711 2712 2713
            rank_offset = fluid.data(
                name="rank_offset", shape=[None, 7], dtype="int32"
            )
S
ShenLiang 已提交
2714 2715 2716 2717 2718 2719 2720
            out = fluid.contrib.layers.rank_attention(
                input=input,
                rank_offset=rank_offset,
                rank_param_shape=[18, 3],
                rank_param_attr=fluid.ParamAttr(
                    learning_rate=1.0,
                    name="ubm_rank_param.w_0",
2721 2722 2723 2724 2725
                    initializer=fluid.initializer.Xavier(uniform=False),
                ),
                max_rank=3,
            )
            return out
S
ShenLiang 已提交
2726

2727 2728 2729 2730 2731 2732 2733 2734 2735 2736
    def test_sequence_enumerate(self):
        # TODO(minqiyang): dygraph do not support lod now
        with self.static_graph():
            x = layers.data(name="input", shape=[1], dtype='int32', lod_level=1)
            out = layers.sequence_enumerate(input=x, win_size=2, pad_value=0)

    def test_roi_perspective_transform(self):
        # TODO(minqiyang): dygraph do not support lod now
        with self.static_graph():
            x = layers.data(name="x", shape=[256, 30, 30], dtype="float32")
2737 2738 2739
            rois = layers.data(
                name="rois", shape=[8], dtype="float32", lod_level=1
            )
2740
            output = layers.roi_perspective_transform(x, rois, 7, 7, 0.6)
2741
            return output
2742 2743 2744 2745 2746 2747

    def test_row_conv(self):
        # TODO(minqiyang): dygraph do not support lod now
        with self.static_graph():
            x = layers.data(name='x', shape=[16], dtype='float32', lod_level=1)
            out = layers.row_conv(input=x, future_context_size=2)
2748
            return out
2749 2750 2751 2752

    def test_simple_conv2d(self):
        # TODO(minqiyang): dygraph do not support layers with param now
        with self.static_graph():
2753 2754 2755 2756 2757 2758
            images = layers.data(
                name='pixel', shape=[3, 48, 48], dtype='float32'
            )
            return layers.conv2d(
                input=images, num_filters=3, filter_size=[4, 4]
            )
2759 2760 2761 2762 2763

    def test_squeeze(self):
        # TODO(minqiyang): dygraph do not support layers with param now
        with self.static_graph():
            x = layers.data(name='x', shape=[1, 1, 4], dtype='float32')
2764
            out = paddle.squeeze(x, axis=[2])
2765
            return out
2766 2767 2768 2769

    def test_flatten(self):
        # TODO(minqiyang): dygraph do not support op without kernel now
        with self.static_graph():
2770 2771 2772 2773 2774 2775
            x = layers.data(
                name='x',
                append_batch_size=False,
                shape=[4, 4, 3],
                dtype="float32",
            )
2776
            out = paddle.flatten(x, 1, -1, name="flatten")
2777
            return out
2778

Z
zhoukunsheng 已提交
2779 2780 2781
    def test_linspace(self):
        program = Program()
        with program_guard(program):
2782
            out = paddle.linspace(20, 10, 5, 'float64')
Z
zhoukunsheng 已提交
2783 2784 2785
            self.assertIsNotNone(out)
        print(str(program))

2786 2787 2788
    def test_unfold(self):
        with self.static_graph():
            x = layers.data(name='x', shape=[3, 20, 20], dtype='float32')
2789
            out = paddle.nn.functional.unfold(x, [3, 3], 1, 1, 1)
2790
            return out
2791

2792 2793 2794 2795
    def test_partial_concat(self):
        with self.static_graph():
            x = fluid.data(name="x", shape=[None, 3], dtype="float32")
            y = fluid.data(name="y", shape=[None, 3], dtype="float32")
2796 2797 2798 2799 2800 2801
            concat1 = fluid.contrib.layers.partial_concat(
                [x, y], start_index=0, length=2
            )
            concat2 = fluid.contrib.layers.partial_concat(
                x, start_index=0, length=-1
            )
2802 2803
            return concat1, concat2

2804
    def test_addmm(self):
2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
            input = layers.data(
                name='input_data',
                shape=[3, 3],
                append_batch_size=False,
                dtype='float32',
            )
            x = layers.data(
                name='x', shape=[3, 2], append_batch_size=False, dtype='float32'
            )
            y = layers.data(
                name='y', shape=[2, 3], append_batch_size=False, dtype='float32'
            )
2820 2821

            out = paddle.addmm(input=input, x=x, y=y)
2822
            return out
2823

2824
    def test_retinanet_detection_output(self):
2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
            bboxes = layers.data(
                name='bboxes',
                shape=[1, 21, 4],
                append_batch_size=False,
                dtype='float32',
            )
            scores = layers.data(
                name='scores',
                shape=[1, 21, 10],
                append_batch_size=False,
                dtype='float32',
            )
            anchors = layers.data(
                name='anchors',
                shape=[21, 4],
                append_batch_size=False,
                dtype='float32',
            )
            im_info = layers.data(
                name="im_info",
                shape=[1, 3],
                append_batch_size=False,
                dtype='float32',
            )
2852 2853 2854 2855 2856 2857 2858 2859 2860
            nmsed_outs = layers.retinanet_detection_output(
                bboxes=[bboxes, bboxes],
                scores=[scores, scores],
                anchors=[anchors, anchors],
                im_info=im_info,
                score_threshold=0.05,
                nms_top_k=1000,
                keep_top_k=100,
                nms_threshold=0.3,
2861 2862 2863
                nms_eta=1.0,
            )
            return nmsed_outs
2864

2865 2866 2867
    def test_warpctc_with_padding(self):
        # TODO(minqiyang): dygraph do not support lod now
        with self.static_graph():
2868
            input_length = paddle.static.data(
2869 2870
                name='logits_length', shape=[11], dtype='int64'
            )
2871
            label_length = paddle.static.data(
2872 2873
                name='labels_length', shape=[12], dtype='int64'
            )
2874 2875 2876 2877
            label = paddle.static.data(
                name='label', shape=[12, 1], dtype='int32'
            )
            predict = paddle.static.data(
2878 2879
                name='predict', shape=[4, 4, 8], dtype='float32'
            )
2880 2881 2882 2883 2884 2885
            output = paddle.nn.functional.ctc_loss(
                log_probs=predict,
                labels=label,
                input_lengths=input_length,
                label_lengths=label_length,
                reduction='none',
2886 2887
            )
            return output
2888

2889 2890 2891 2892
    def test_basic_gru(self):
        input_size = 128
        hidden_size = 256
        with self.static_graph():
2893 2894 2895 2896 2897 2898 2899 2900 2901
            input = fluid.data(
                name="input", shape=[None, None, input_size], dtype='float32'
            )
            pre_hidden = fluid.data(
                name="pre_hidden", shape=[None, hidden_size], dtype='float32'
            )
            sequence_length = fluid.data(
                name="sequence_length", shape=[None], dtype='int32'
            )
2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912

            for bidirectional in [True, False]:
                for batch_first in [True, False]:
                    rnn_out, last_hidden = fluid.contrib.layers.basic_gru(
                        input,
                        pre_hidden,
                        hidden_size=256,
                        num_layers=2,
                        sequence_length=sequence_length,
                        dropout_prob=0.5,
                        bidirectional=bidirectional,
2913 2914
                        batch_first=batch_first,
                    )
2915

Y
Yu Yang 已提交
2916

2917 2918
class ExampleNet(paddle.nn.Layer):
    def __init__(self):
2919
        super().__init__()
2920
        self.weight = self.create_parameter(
2921 2922
            shape=[1, 1], attr=paddle.ParamAttr(trainable=False)
        )
2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935

    def forward(self):
        # only for test parameter trainable attr
        pass


class TestLayerParameterTrainableSet(unittest.TestCase):
    def test_layer_parameter_set(self):
        with fluid.dygraph.guard():
            net = ExampleNet()
            self.assertFalse(net.weight.trainable)


2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952
class TestLayerTrainingAttribute(unittest.TestCase):
    def test_set_train_eval_in_dynamic_mode(self):
        with fluid.dygraph.guard():
            net = paddle.nn.Dropout()
            net.train()
            self.assertTrue(net.training)
            net.eval()
            self.assertFalse(net.training)

    def test_set_train_eval_in_static_mode(self):
        net = paddle.nn.Dropout()
        net.train()
        self.assertTrue(net.training)
        net.eval()
        self.assertFalse(net.training)


J
Jiabin Yang 已提交
2953 2954
class MyLayer(paddle.nn.Layer):
    def __init__(self):
2955
        super().__init__()
J
Jiabin Yang 已提交
2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966
        self._linear = paddle.nn.Linear(1, 1)
        self._dropout = paddle.nn.Dropout(p=0.5)

    def forward(self, input):
        temp = self._linear(input)
        temp = self._dropout(temp)
        return temp


class MySuperLayer(paddle.nn.Layer):
    def __init__(self):
2967
        super().__init__()
J
Jiabin Yang 已提交
2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982
        self._mylayer = MyLayer()

    def forward(self, input):
        temp = self._mylayer(input)
        return temp


class TestSubLayerCount(unittest.TestCase):
    def test_sublayer(self):
        with fluid.dygraph.guard():
            mySuperlayer = MySuperLayer()
            self.assertTrue(len(mySuperlayer.sublayers()) == 3)
            self.assertTrue(len(mySuperlayer.sublayers(include_self=True)) == 4)


Y
Yu Yang 已提交
2983
if __name__ == '__main__':
2984
    paddle.enable_static()
Y
Yu Yang 已提交
2985
    unittest.main()