test_layers.py 115.6 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 1847 1848
            shard_label = fluid.layers.shard_index(
                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')
2124 2125 2126
            return layers.pool2d(
                x, pool_size=[5, 3], pool_stride=[1, 2], pool_padding=(2, 1)
            )
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]
            )
2136 2137 2138
            return layers.pool2d(
                x, pool_size=[5, 3], pool_stride=[1, 2], pool_padding=(2, 1)
            )
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_polygon_box_transform(self):
2298 2299 2300
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
2301
            x = self._get_data(name='x', shape=[8, 4, 4], dtype="float32")
2302
            output = layers.polygon_box_transform(input=x)
2303
            return output
2304

2305
    def make_l2_normalize(self):
2306 2307 2308
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
2309
            x = self._get_data(name='x', shape=[8, 7, 10], dtype="float32")
2310
            output = layers.l2_normalize(x, axis=1)
2311
            return output
2312

2313
    def make_shape(self):
2314 2315 2316 2317 2318 2319
        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 已提交
2320
            out = paddle.shape(input)
2321
            return out
B
Bai Yifan 已提交
2322

2323
    def make_pad2d(self):
2324 2325 2326 2327 2328 2329
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
            input = self._get_data(
                name="input", shape=[3, 100, 100], dtype="float32"
            )
傅剑寒 已提交
2330 2331 2332

            tmp_pad = paddle.nn.Pad2D(
                padding=[1, 2, 3, 4],
2333 2334 2335 2336
                mode='reflect',
                data_format='NCHW',
                name="shape",
            )
傅剑寒 已提交
2337
            out = tmp_pad(input)
2338
            return out
W
whs 已提交
2339

K
Kaipeng Deng 已提交
2340
    def make_mish(self):
2341 2342 2343
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
K
Kaipeng Deng 已提交
2344 2345
            input = self._get_data(name="input", shape=[16], dtype="float32")
            out = layers.mish(input, name='mish')
2346
            return out
K
Kaipeng Deng 已提交
2347

2348
    def make_cross_entropy(self):
2349 2350 2351
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
2352 2353
            x = self._get_data(name="x", shape=[30, 10], dtype="float32")
            label = self._get_data(name="label", shape=[30, 1], dtype="int64")
2354 2355
            mode = 'channel'
            out = layers.cross_entropy(x, label, False, 4)
2356
            return out
2357

2358
    def make_uniform_random_batch_size_like(self):
2359 2360 2361 2362 2363 2364
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
            input = self._get_data(
                name="input", shape=[13, 11], dtype='float32'
            )
2365
            out = random.uniform_random_batch_size_like(input, [-1, 11])
2366
            return out
G
fix  
gongweibao 已提交
2367

2368
    def make_gaussian_random(self):
2369 2370 2371
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
2372
            out = random.gaussian(shape=[20, 30])
2373
            return out
G
fix  
gongweibao 已提交
2374

2375
    def make_sum(self):
2376 2377 2378 2379 2380 2381
        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 已提交
2382

2383
            out = paddle.add_n(input)
2384
            return out
G
fix  
gongweibao 已提交
2385

2386
    def make_slice(self):
G
fix  
gongweibao 已提交
2387 2388 2389 2390
        starts = [1, 0, 2]
        ends = [3, 3, 4]
        axes = [0, 1, 2]

2391 2392 2393 2394 2395 2396
        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 已提交
2397

2
201716010711 已提交
2398
            out = paddle.slice(input, axes=axes, starts=starts, ends=ends)
2399
            return out
G
merge  
gongweibao 已提交
2400

2401
    def make_scale_variable(self):
2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413
        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 已提交
2414
            out = paddle.scale(input, scale=scale_var)
2415 2416
            return out

M
minqiyang 已提交
2417
    def make_iou_similarity(self):
2418 2419 2420
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
M
minqiyang 已提交
2421 2422
            x = self._get_data(name="x", shape=[4], dtype="float32")
            y = self._get_data(name="y", shape=[4], dtype="float32")
X
Xin Pan 已提交
2423
            out = layers.iou_similarity(x, y, name='iou_similarity')
2424
            return out
2425 2426

    def make_bilinear_tensor_product_layer(self):
2427 2428 2429
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
2430 2431 2432
            data = self._get_data(name='data', shape=[4], dtype="float32")

            theta = self._get_data(name="theta", shape=[5], dtype="float32")
2433 2434 2435
            out = paddle.static.nn.common.bilinear_tensor_product(
                data, theta, 6
            )
2436
            return out
2437 2438

    def make_batch_norm(self):
2439 2440 2441 2442 2443 2444
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
            data = self._get_data(
                name='data', shape=[32, 128, 128], dtype="float32"
            )
2445
            out = paddle.static.nn.batch_norm(data)
2446
            return out
2447

2448
    def make_batch_norm_momentum_variable(self):
2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460
        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,
            )
2461
            out = paddle.static.nn.batch_norm(data, momentum=momentum)
2462
            return out
2463

2464
    def make_range(self):
2465 2466 2467
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
C
ccrrong 已提交
2468 2469 2470
            paddle.arange(0, 10, 2, 'int32')
            paddle.arange(0.1, 10.0, 0.2, 'float32')
            paddle.arange(0.1, 10.0, 0.2, 'float64')
2471 2472 2473
            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 已提交
2474
            y = paddle.arange(start, end, step, 'float64')
2475 2476 2477
            return y

    def make_spectral_norm(self):
2478 2479 2480 2481 2482 2483 2484 2485 2486
        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,
            )
2487
            out = layers.spectral_norm(weight, dim=1, power_iters=1)
2488
            return out
2489 2490

    def make_kldiv_loss(self):
2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505
        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,
            )
2506 2507 2508
            loss = paddle.nn.functional.kl_div(
                input=x, label=target, reduction='batchmean'
            )
2509
            return loss
2510

M
minqiyang 已提交
2511
    def make_pixel_shuffle(self):
2512 2513 2514
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
M
minqiyang 已提交
2515
            x = self._get_data(name="X", shape=[9, 4, 4], dtype="float32")
2516
            out = paddle.nn.functional.pixel_shuffle(x, upscale_factor=3)
2517
            return out
M
minqiyang 已提交
2518

R
ruri 已提交
2519
    def make_mse_loss(self):
2520 2521 2522
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
R
ruri 已提交
2523 2524
            x = self._get_data(name="X", shape=[1], dtype="float32")
            y = self._get_data(name="Y", shape=[1], dtype="float32")
2525
            out = paddle.nn.functional.mse_loss(input=x, label=y)
2526
            return out
R
ruri 已提交
2527

2528
    def make_square_error_cost(self):
2529 2530 2531
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
2532 2533
            x = self._get_data(name="X", shape=[1], dtype="float32")
            y = self._get_data(name="Y", shape=[1], dtype="float32")
2534
            out = paddle.nn.functional.square_error_cost(input=x, label=y)
2535
            return out
2536

2537 2538 2539 2540
    def test_dynamic_lstmp(self):
        # TODO(minqiyang): dygraph do not support lod now
        with self.static_graph():
            hidden_dim, proj_dim = 16, 8
2541 2542 2543
            seq_data = layers.data(
                name='seq_data', shape=[10, 10], dtype='float32', lod_level=1
            )
2544 2545
            fc_out = layers.fc(input=seq_data, size=4 * hidden_dim)
            self.assertIsNotNone(
2546 2547 2548 2549
                layers.dynamic_lstmp(
                    input=fc_out, size=4 * hidden_dim, proj_size=proj_dim
                )
            )
2550 2551 2552 2553

    def test_lod_reset(self):
        # TODO(minqiyang): dygraph do not support lod now
        with self.static_graph():
2554
            # case 1
2555
            x = layers.data(name='x', shape=[10], dtype='float32')
2556 2557 2558
            y = layers.data(
                name='y', shape=[10, 20], dtype='float32', lod_level=2
            )
2559 2560 2561
            z = layers.lod_reset(x=x, y=y)
            self.assertTrue(z.lod_level == 2)
            # case 2
2562
            lod_tensor_in = layers.data(name='lod_in', shape=[1], dtype='int32')
2563 2564 2565 2566 2567 2568
            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
2569

W
whs 已提交
2570
    def test_affine_grid(self):
2571
        with self.static_graph():
W
whs 已提交
2572
            data = layers.data(name='data', shape=[2, 3, 3], dtype="float32")
2573
            out = paddle.argsort(x=data, axis=1)
W
whs 已提交
2574 2575

            theta = layers.data(name="theta", shape=[2, 3], dtype="float32")
2576
            out_shape = layers.data(name="out_shape", shape=[-1], dtype="int32")
2577 2578
            data_0 = paddle.nn.functional.affine_grid(theta, out_shape)
            data_1 = paddle.nn.functional.affine_grid(theta, [5, 3, 28, 28])
W
whs 已提交
2579 2580 2581

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

W
wangchaochaohu 已提交
2583 2584 2585 2586 2587 2588 2589
    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 已提交
2590
            out = paddle.strided_slice(
2591 2592
                x, axes=axes, starts=starts, ends=ends, strides=strides
            )
W
wangchaochaohu 已提交
2593 2594
            return out

2595 2596
    def test_fill_constant_batch_size_like(self):
        with self.static_graph():
2597 2598 2599 2600 2601 2602
            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'
            )
2603 2604
            return out

2605 2606 2607 2608
    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')
2609 2610 2611 2612
            y = layers.data(
                name='y', shape=[10, 20], dtype='float32', lod_level=2
            )
            return layers.sequence_expand(x=x, y=y, ref_level=1)
2613

2614 2615 2616 2617 2618
    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)
2619
            return out
2620

2621 2622 2623 2624
    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')
2625
            length = layers.data(name='length', shape=[], dtype='int64')
2626
            return layers.sequence_unpad(x=x, length=length)
2627

2628 2629 2630
    def test_sequence_softmax(self):
        # TODO(minqiyang): dygraph do not support lod now
        with self.static_graph():
2631 2632 2633
            seq_data = layers.data(
                name='seq_data', shape=[10, 10], dtype='float32', lod_level=1
            )
2634
            seq = layers.fc(input=seq_data, size=20)
2635
            return layers.sequence_softmax(seq)
2636

2637 2638 2639 2640 2641
    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])
2642
            return out
2643

2644 2645 2646
    def test_sequence_scatter(self):
        # TODO(minqiyang): dygraph do not support lod now
        with self.static_graph():
2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663
            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,
            )
2664
            out = layers.sequence_scatter(input=x, index=idx, updates=updates)
2665
            return out
W
whs 已提交
2666

2667 2668 2669 2670
    def test_sequence_slice(self):
        # TODO(minqiyang): dygraph do not support lod now
        with self.static_graph():
            import numpy as np
2671 2672 2673 2674

            seqs = layers.data(
                name='x', shape=[10, 5], dtype='float32', lod_level=1
            )
2675 2676
            offset = layers.assign(input=np.array([[0, 1]]).astype('int32'))
            length = layers.assign(input=np.array([[2, 1]]).astype('int32'))
2677 2678 2679 2680
            out = layers.sequence_slice(
                input=seqs, offset=offset, length=length
            )
            return out
W
whs 已提交
2681

Z
zhoushiyu 已提交
2682 2683 2684
    def test_shuffle_batch(self):
        # TODO(minqiyang): dygraph do not support lod now
        with self.static_graph():
2685 2686 2687
            x = layers.data(
                name='X', shape=[4, 50], dtype='float32', lod_level=0
            )
Z
zhoushiyu 已提交
2688 2689 2690 2691 2692
            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)
2693
            return out1
Z
zhoushiyu 已提交
2694

2695 2696 2697 2698
    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")
2699 2700 2701 2702
            sum = fluid.contrib.layers.partial_sum(
                [x, y], start_index=0, length=2
            )
            return sum
2703

S
ShenLiang 已提交
2704 2705 2706 2707 2708 2709 2710 2711 2712
    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",
2713 2714
                    initializer=fluid.initializer.Xavier(uniform=False),
                ),
S
ShenLiang 已提交
2715 2716 2717 2718
                bias_size=[16, 10],
                bias_attr=fluid.ParamAttr(
                    learning_rate=1.0,
                    name="b_0",
2719 2720 2721 2722 2723
                    initializer=fluid.initializer.Xavier(uniform=False),
                ),
                act="relu",
            )
        return out
S
ShenLiang 已提交
2724

S
ShenLiang 已提交
2725 2726 2727
    def test_rank_attention(self):
        with self.static_graph():
            input = fluid.data(name="input", shape=[None, 2], dtype="float32")
2728 2729 2730
            rank_offset = fluid.data(
                name="rank_offset", shape=[None, 7], dtype="int32"
            )
S
ShenLiang 已提交
2731 2732 2733 2734 2735 2736 2737
            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",
2738 2739 2740 2741 2742
                    initializer=fluid.initializer.Xavier(uniform=False),
                ),
                max_rank=3,
            )
            return out
S
ShenLiang 已提交
2743

2744 2745 2746 2747 2748 2749 2750 2751 2752 2753
    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")
2754 2755 2756
            rois = layers.data(
                name="rois", shape=[8], dtype="float32", lod_level=1
            )
2757
            output = layers.roi_perspective_transform(x, rois, 7, 7, 0.6)
2758
            return output
2759 2760 2761 2762 2763 2764

    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)
2765
            return out
2766 2767 2768 2769

    def test_simple_conv2d(self):
        # TODO(minqiyang): dygraph do not support layers with param now
        with self.static_graph():
2770 2771 2772 2773 2774 2775
            images = layers.data(
                name='pixel', shape=[3, 48, 48], dtype='float32'
            )
            return layers.conv2d(
                input=images, num_filters=3, filter_size=[4, 4]
            )
2776 2777 2778 2779 2780

    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')
2781
            out = paddle.squeeze(x, axis=[2])
2782
            return out
2783 2784 2785 2786

    def test_flatten(self):
        # TODO(minqiyang): dygraph do not support op without kernel now
        with self.static_graph():
2787 2788 2789 2790 2791 2792
            x = layers.data(
                name='x',
                append_batch_size=False,
                shape=[4, 4, 3],
                dtype="float32",
            )
2793
            out = paddle.flatten(x, 1, -1, name="flatten")
2794
            return out
2795

Z
zhoukunsheng 已提交
2796 2797 2798
    def test_linspace(self):
        program = Program()
        with program_guard(program):
2799
            out = paddle.linspace(20, 10, 5, 'float64')
Z
zhoukunsheng 已提交
2800 2801 2802
            self.assertIsNotNone(out)
        print(str(program))

2803 2804 2805 2806
    def test_unfold(self):
        with self.static_graph():
            x = layers.data(name='x', shape=[3, 20, 20], dtype='float32')
            out = layers.unfold(x, [3, 3], 1, 1, 1)
2807
            return out
2808

2809 2810 2811 2812
    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")
2813 2814 2815 2816 2817 2818
            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
            )
2819 2820
            return concat1, concat2

C
cjt222 已提交
2821
    def test_deform_roi_pooling(self):
2822 2823 2824 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 2852 2853
        with program_guard(
            fluid.default_main_program(), fluid.default_startup_program()
        ):
            input = layers.data(
                name='input',
                shape=[2, 3, 32, 32],
                dtype='float32',
                append_batch_size=False,
            )
            rois = layers.data(
                name="rois", shape=[4], dtype='float32', lod_level=1
            )
            trans = layers.data(
                name="trans",
                shape=[2, 3, 32, 32],
                dtype='float32',
                append_batch_size=False,
            )
            out = layers.deformable_roi_pooling(
                input=input,
                rois=rois,
                trans=trans,
                no_trans=False,
                spatial_scale=1.0,
                group_size=(1, 1),
                pooled_height=8,
                pooled_width=8,
                part_size=(8, 8),
                sample_per_part=4,
                trans_std=0.1,
            )
        return out
C
cjt222 已提交
2854

2855
    def test_addmm(self):
2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870
        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'
            )
2871 2872

            out = paddle.addmm(input=input, x=x, y=y)
2873
            return out
2874

2875
    def test_retinanet_detection_output(self):
2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902
        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',
            )
2903 2904 2905 2906 2907 2908 2909 2910 2911
            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,
2912 2913 2914
                nms_eta=1.0,
            )
            return nmsed_outs
2915

2916 2917 2918
    def test_warpctc_with_padding(self):
        # TODO(minqiyang): dygraph do not support lod now
        with self.static_graph():
2919
            input_length = paddle.static.data(
2920 2921
                name='logits_length', shape=[11], dtype='int64'
            )
2922
            label_length = paddle.static.data(
2923 2924
                name='labels_length', shape=[12], dtype='int64'
            )
2925 2926 2927 2928
            label = paddle.static.data(
                name='label', shape=[12, 1], dtype='int32'
            )
            predict = paddle.static.data(
2929 2930
                name='predict', shape=[4, 4, 8], dtype='float32'
            )
2931 2932 2933 2934 2935 2936
            output = paddle.nn.functional.ctc_loss(
                log_probs=predict,
                labels=label,
                input_lengths=input_length,
                label_lengths=label_length,
                reduction='none',
2937 2938
            )
            return output
2939

2940 2941 2942 2943
    def test_basic_gru(self):
        input_size = 128
        hidden_size = 256
        with self.static_graph():
2944 2945 2946 2947 2948 2949 2950 2951 2952
            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'
            )
2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963

            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,
2964 2965
                        batch_first=batch_first,
                    )
2966

Y
Yu Yang 已提交
2967

2968 2969 2970 2971
class TestMetricsDetectionMap(unittest.TestCase):
    def test_detection_map(self):
        program = fluid.Program()
        with program_guard(program):
2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992
            detect_res = fluid.layers.data(
                name='detect_res',
                shape=[10, 6],
                append_batch_size=False,
                dtype='float32',
            )
            label = fluid.layers.data(
                name='label',
                shape=[10, 1],
                append_batch_size=False,
                dtype='float32',
            )
            box = fluid.layers.data(
                name='bbox',
                shape=[10, 4],
                append_batch_size=False,
                dtype='float32',
            )
            map_eval = fluid.metrics.DetectionMAP(
                detect_res, label, box, class_num=21
            )
2993 2994 2995 2996 2997 2998
            cur_map, accm_map = map_eval.get_map_var()
            self.assertIsNotNone(cur_map)
            self.assertIsNotNone(accm_map)
        print(str(program))


2999 3000
class ExampleNet(paddle.nn.Layer):
    def __init__(self):
3001
        super().__init__()
3002
        self.weight = self.create_parameter(
3003 3004
            shape=[1, 1], attr=paddle.ParamAttr(trainable=False)
        )
3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017

    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)


3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034
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 已提交
3035 3036
class MyLayer(paddle.nn.Layer):
    def __init__(self):
3037
        super().__init__()
J
Jiabin Yang 已提交
3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048
        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):
3049
        super().__init__()
J
Jiabin Yang 已提交
3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064
        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 已提交
3065
if __name__ == '__main__':
3066
    paddle.enable_static()
Y
Yu Yang 已提交
3067
    unittest.main()