test_layers.py 17.8 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.

Y
Yu Yang 已提交
15
from __future__ import print_function
Q
Qiao Longfei 已提交
16 17
import unittest

18
import paddle.fluid.layers as layers
19
from paddle.fluid.layers.device import get_places
20 21 22
import paddle.fluid.nets as nets
from paddle.fluid.framework import Program, program_guard, default_main_program
from paddle.fluid.param_attr import ParamAttr
23
from . import decorators
Y
Yu Yang 已提交
24 25 26 27


class TestBook(unittest.TestCase):
    def test_fit_a_line(self):
28
        program = Program()
Y
Yu Yang 已提交
29 30 31 32 33
        with program_guard(program, startup_program=Program()):
            x = layers.data(name='x', shape=[13], dtype='float32')
            y_predict = layers.fc(input=x, size=1, act=None)
            y = layers.data(name='y', shape=[1], dtype='float32')
            cost = layers.square_error_cost(input=y_predict, label=y)
Y
Yu Yang 已提交
34
            avg_cost = layers.mean(cost)
Y
Yu Yang 已提交
35
            self.assertIsNotNone(avg_cost)
Y
Yu Yang 已提交
36

Y
Yu Yang 已提交
37
        print(str(program))
Y
Yu Yang 已提交
38 39

    def test_recognize_digits_mlp(self):
40
        program = Program()
Y
Yu Yang 已提交
41 42 43 44 45 46
        with program_guard(program, startup_program=Program()):
            # Change g_program, so the rest layers use `g_program`
            images = layers.data(name='pixel', shape=[784], dtype='float32')
            label = layers.data(name='label', shape=[1], dtype='int32')
            hidden1 = layers.fc(input=images, size=128, act='relu')
            hidden2 = layers.fc(input=hidden1, size=64, act='relu')
47 48 49 50
            predict = layers.fc(input=[hidden2, hidden1],
                                size=10,
                                act='softmax',
                                param_attr=["sftmax.w1", "sftmax.w2"])
Y
Yu Yang 已提交
51
            cost = layers.cross_entropy(input=predict, label=label)
Y
Yu Yang 已提交
52
            avg_cost = layers.mean(cost)
Y
Yu Yang 已提交
53 54 55
            self.assertIsNotNone(avg_cost)

        print(str(program))
56 57

    def test_simple_conv2d(self):
F
fengjiayi 已提交
58
        program = Program()
Y
Yu Yang 已提交
59 60 61 62 63
        with program_guard(program, startup_program=Program()):
            images = layers.data(name='pixel', shape=[3, 48, 48], dtype='int32')
            layers.conv2d(input=images, num_filters=3, filter_size=[4, 4])

        print(str(program))
Y
Yu Yang 已提交
64

65 66
    def test_conv2d_transpose(self):
        program = Program()
Y
Yu Yang 已提交
67 68 69 70
        with program_guard(program):
            img = layers.data(name='pixel', shape=[3, 2, 2], dtype='float32')
            layers.conv2d_transpose(input=img, num_filters=10, output_size=28)
        print(str(program))
71

F
fengjiayi 已提交
72
    def test_recognize_digits_conv(self):
F
fengjiayi 已提交
73
        program = Program()
Y
Yu Yang 已提交
74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94
        with program_guard(program, startup_program=Program()):
            images = layers.data(
                name='pixel', shape=[1, 28, 28], dtype='float32')
            label = layers.data(name='label', shape=[1], dtype='int32')
            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")

            predict = layers.fc(input=conv_pool_2, size=10, act="softmax")
            cost = layers.cross_entropy(input=predict, label=label)
Y
Yu Yang 已提交
95
            avg_cost = layers.mean(cost)
Y
Yu Yang 已提交
96 97

        print(str(program))
98

Q
QI JUN 已提交
99 100
    def test_word_embedding(self):
        program = Program()
Y
Yu Yang 已提交
101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140
        with program_guard(program, startup_program=Program()):
            dict_size = 10000
            embed_size = 32
            first_word = layers.data(name='firstw', shape=[1], dtype='int64')
            second_word = layers.data(name='secondw', shape=[1], dtype='int64')
            third_word = layers.data(name='thirdw', shape=[1], dtype='int64')
            forth_word = layers.data(name='forthw', shape=[1], dtype='int64')
            next_word = layers.data(name='nextw', shape=[1], dtype='int64')

            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')

            concat_embed = layers.concat(
                input=[embed_first, embed_second, embed_third, embed_forth],
                axis=1)

            hidden1 = layers.fc(input=concat_embed, size=256, act='sigmoid')
            predict_word = layers.fc(input=hidden1,
                                     size=dict_size,
                                     act='softmax')
            cost = layers.cross_entropy(input=predict_word, label=next_word)
Y
Yu Yang 已提交
141
            avg_cost = layers.mean(cost)
Y
Yu Yang 已提交
142 143 144
            self.assertIsNotNone(avg_cost)

        print(str(program))
Q
Qiao Longfei 已提交
145 146 147

    def test_linear_chain_crf(self):
        program = Program()
Y
Yu Yang 已提交
148
        with program_guard(program, startup_program=Program()):
Q
Qiao Longfei 已提交
149
            label_dict_len = 10
Y
Yu Yang 已提交
150 151 152
            images = layers.data(name='pixel', shape=[784], dtype='float32')
            label = layers.data(name='label', shape=[1], dtype='int32')
            hidden = layers.fc(input=images, size=128)
Q
Qiao Longfei 已提交
153 154 155 156
            crf = layers.linear_chain_crf(
                input=hidden, label=label, param_attr=ParamAttr(name="crfw"))
            crf_decode = layers.crf_decoding(
                input=hidden, param_attr=ParamAttr(name="crfw"))
Q
Qiao Longfei 已提交
157 158 159 160 161
            layers.chunk_eval(
                input=crf_decode,
                label=label,
                chunk_scheme="IOB",
                num_chunk_types=(label_dict_len - 1) / 2)
Q
qiaolongfei 已提交
162 163
            self.assertFalse(crf is None)
            self.assertFalse(crf_decode is None)
Y
Yu Yang 已提交
164 165

        print(str(program))
Q
QI JUN 已提交
166

167 168 169 170 171 172 173 174 175 176
    def test_sigmoid_cross_entropy(self):
        program = Program()
        with program_guard(program):
            dat = layers.data(name='data', shape=[10], dtype='float32')
            lbl = layers.data(name='label', shape=[10], dtype='float32')
            self.assertIsNotNone(
                layers.sigmoid_cross_entropy_with_logits(
                    x=dat, label=lbl))
        print(str(program))

W
weixing02 已提交
177 178 179
    def test_hsigmoid(self):
        program = Program()
        with program_guard(program):
W
weixing02 已提交
180 181
            x = layers.data(name='x', shape=[2], dtype='float32')
            y = layers.data(name='y', shape=[2], dtype='int64')
W
weixing02 已提交
182 183 184 185 186
            self.assertIsNotNone(
                layers.hsigmoid(
                    input=x, label=y, num_classes=2))
        print(str(program))

Y
yangyaming 已提交
187
    def test_sequence_expand(self):
Y
yangyaming 已提交
188 189 190 191
        program = Program()
        with program_guard(program):
            x = layers.data(name='x', shape=[10], dtype='float32')
            y = layers.data(
Y
yangyaming 已提交
192 193
                name='y', shape=[10, 20], dtype='float32', lod_level=2)
            self.assertIsNotNone(layers.sequence_expand(x=x, y=y, ref_level=1))
Y
yangyaming 已提交
194 195
        print(str(program))

Y
yangyaming 已提交
196 197 198 199 200 201 202
    def test_lstm_unit(self):
        program = Program()
        with program_guard(program):
            x_t_data = layers.data(
                name='x_t_data', shape=[10, 10], dtype='float32')
            x_t = layers.fc(input=x_t_data, size=10)
            prev_hidden_data = layers.data(
Y
yangyaming 已提交
203 204
                name='prev_hidden_data', shape=[10, 30], dtype='float32')
            prev_hidden = layers.fc(input=prev_hidden_data, size=30)
Y
yangyaming 已提交
205 206 207 208 209 210 211 212
            prev_cell_data = layers.data(
                name='prev_cell', shape=[10, 30], dtype='float32')
            prev_cell = layers.fc(input=prev_cell_data, size=30)
            self.assertIsNotNone(
                layers.lstm_unit(
                    x_t=x_t, hidden_t_prev=prev_hidden, cell_t_prev=prev_cell))
        print(str(program))

213 214 215 216 217 218 219 220 221 222 223 224
    def test_dynamic_lstmp(self):
        program = Program()
        with program_guard(program):
            hidden_dim, proj_dim = 16, 8
            seq_data = layers.data(
                name='seq_data', shape=[10, 10], dtype='float32', lod_level=1)
            fc_out = layers.fc(input=seq_data, size=4 * hidden_dim)
            self.assertIsNotNone(
                layers.dynamic_lstmp(
                    input=fc_out, size=4 * hidden_dim, proj_size=proj_dim))
        print(str(program))

Y
yangyaming 已提交
225 226 227 228 229 230
    def test_sequence_softmax(self):
        program = Program()
        with program_guard(program):
            seq_data = layers.data(
                name='seq_data', shape=[10, 10], dtype='float32', lod_level=1)
            seq = layers.fc(input=seq_data, size=20)
231
            self.assertIsNotNone(layers.sequence_softmax(seq))
Y
yangyaming 已提交
232 233
        print(str(program))

D
dangqingqing 已提交
234 235 236 237 238
    def test_softmax(self):
        program = Program()
        with program_guard(program):
            data = layers.data(name='data', shape=[10], dtype='float32')
            hid = layers.fc(input=data, size=20)
239
            self.assertIsNotNone(layers.softmax(hid))
D
dangqingqing 已提交
240 241
        print(str(program))

D
dragonwarrior 已提交
242 243 244 245 246 247 248
    def test_lrn(self):
        program = Program()
        with program_guard(program):
            data = layers.data(name='data', shape=[6, 2, 2], dtype='float32')
            self.assertIsNotNone(layers.lrn(data))
        print(str(program))

Q
qijun 已提交
249 250 251
    def test_get_places(self):
        program = Program()
        with program_guard(program):
252
            x = get_places(device_count=4)
Y
Yang Yu 已提交
253
            self.assertIsNotNone(x)
Q
qijun 已提交
254 255
        print(str(program))

256 257 258 259 260 261 262 263
    def test_sequence_reshape(self):
        program = Program()
        with program_guard(program):
            x = layers.data(name='x', shape=[8], dtype='float32', lod_level=1)
            out = layers.sequence_reshape(input=x, new_dim=16)
            self.assertIsNotNone(out)
        print(str(program))

W
wanghaoshuang 已提交
264 265 266 267
    def test_im2sequence(self):
        program = Program()
        with program_guard(program):
            x = layers.data(name='x', shape=[3, 128, 128], dtype='float32')
268
            y = layers.data(name='y', shape=[], dtype='float32')
W
wanghaoshuang 已提交
269
            output = layers.im2sequence(
270 271 272 273 274
                input=x,
                input_image_size=y,
                stride=[1, 1],
                filter_size=[2, 2],
                out_stride=[1, 1])
W
wanghaoshuang 已提交
275 276 277
            self.assertIsNotNone(output)
        print(str(program))

Y
Yang Yu 已提交
278 279 280 281
    @decorators.prog_scope()
    def test_nce(self):
        window_size = 5
        words = []
282
        for i in range(window_size):
Y
Yang Yu 已提交
283 284 285 286 287 288 289 290
            words.append(
                layers.data(
                    name='word_{0}'.format(i), shape=[1], dtype='int64'))

        dict_size = 10000
        label_word = int(window_size / 2) + 1

        embs = []
291
        for i in range(window_size):
Y
Yang Yu 已提交
292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308
            if i == label_word:
                continue

            emb = layers.embedding(
                input=words[i],
                size=[dict_size, 32],
                param_attr='emb.w',
                is_sparse=True)

            embs.append(emb)

        embs = layers.concat(input=embs, axis=1)
        loss = layers.nce(input=embs,
                          label=words[label_word],
                          num_total_classes=dict_size,
                          param_attr='nce.w',
                          bias_attr='nce.b')
Y
Yu Yang 已提交
309
        avg_loss = layers.mean(loss)
Y
Yang Yu 已提交
310 311 312
        self.assertIsNotNone(avg_loss)
        print(str(default_main_program()))

Y
yangyaming 已提交
313 314 315 316 317 318 319 320
    def test_row_conv(self):
        program = Program()
        with program_guard(program):
            x = layers.data(name='x', shape=[16], dtype='float32', lod_level=1)
            out = layers.row_conv(input=x, future_context_size=2)
            self.assertIsNotNone(out)
        print(str(program))

321 322 323 324 325 326 327 328 329 330
    def test_multiplex(self):
        program = Program()
        with program_guard(program):
            x1 = layers.data(name='x1', shape=[4], dtype='float32')
            x2 = layers.data(name='x2', shape=[4], dtype='float32')
            index = layers.data(name='index', shape=[1], dtype='int32')
            out = layers.multiplex(inputs=[x1, x2], index=index)
            self.assertIsNotNone(out)
        print(str(program))

331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348
    def test_softmax_with_cross_entropy(self):
        program = Program()
        with program_guard(program):
            x = layers.data(name='x', shape=[16], dtype='float32')
            y = layers.data(name='label', shape=[1], dtype='int64')
            loss = layers.softmax_with_cross_entropy(x, y)
            self.assertIsNotNone(loss)
        print(str(program))

    def test_smooth_l1(self):
        program = Program()
        with program_guard(program):
            x = layers.data(name='x', shape=[4], dtype='float32')
            y = layers.data(name='label', shape=[4], dtype='float32')
            loss = layers.smooth_l1(x, y)
            self.assertIsNotNone(loss)
        print(str(program))

Y
yangyaming 已提交
349 350 351 352 353 354 355 356 357
    def test_lod_reset(self):
        program = Program()
        with program_guard(program):
            x = layers.data(name='x', shape=[10], dtype='float32')
            y = layers.data(
                name='y', shape=[10, 20], dtype='float32', lod_level=2)
            print(layers.lod_reset(x=x, y=y))
        print(str(program))

358 359 360 361 362 363 364 365 366 367
    def test_label_smooth(self):
        program = Program()
        with program_guard(program):
            label = layers.data(name="label", shape=[1], dtype="float32")
            one_hot_label = layers.one_hot(input=label, depth=10)
            smooth_label = layers.label_smooth(
                label=one_hot_label, epsilon=0.1, dtype="float32")
            self.assertIsNotNone(smooth_label)
        print(str(program))

Q
qingqing01 已提交
368 369 370 371 372 373 374 375 376
    def test_topk(self):
        program = Program()
        with program_guard(program):
            data = layers.data(name="label", shape=[200], dtype="float32")
            values, indices = layers.topk(data, k=5)
            self.assertIsNotNone(values)
            self.assertIsNotNone(indices)
        print(str(program))

377 378 379 380 381 382 383 384 385 386
    def test_roi_pool(self):
        program = Program()
        with program_guard(program):
            x = layers.data(name="x", shape=[256, 30, 30], dtype="float32")
            rois = layers.data(
                name="rois", shape=[4], dtype="float32", lod_level=1)
            output = layers.roi_pool(x, rois, 7, 7, 0.6)
            self.assertIsNotNone(output)
        print(str(program))

B
baiyf 已提交
387
    def test_resize_bilinear(self):
388 389 390
        program = Program()
        with program_guard(program):
            x = layers.data(name='x', shape=[3, 9, 6], dtype="float32")
B
baiyf 已提交
391
            output = layers.resize_bilinear(x, out_shape=[12, 12])
392
            self.assertIsNotNone(output)
B
baiyf 已提交
393
            output = layers.resize_bilinear(x, scale=3)
394 395 396
            self.assertIsNotNone(output)
        print(str(program))

397 398 399 400 401 402 403 404
    def test_polygon_box_transform(self):
        program = Program()
        with program_guard(program):
            x = layers.data(name='x', shape=[8, 4, 4], dtype="float32")
            output = layers.polygon_box_transform(input=x)
            self.assertIsNotNone(output)
        print(str(program))

405 406 407 408 409 410
    def test_l2_normalize(self):
        program = Program()
        with program_guard(program):
            x = layers.data(name='x', shape=[8, 7, 10], dtype="float32")
            output = layers.l2_normalize(x, axis=1)

Q
qingqing01 已提交
411 412 413 414 415 416 417 418
    def test_maxout(self):
        program = Program()
        with program_guard(program):
            data = layers.data(name='x', shape=[8, 6, 6], dtype="float32")
            output = layers.maxout(x=data, groups=2)
            self.assertIsNotNone(output)
        print(str(program))

W
whs 已提交
419
    def test_crop(self):
420 421 422 423 424 425 426 427
        program = Program()
        with program_guard(program):
            x = layers.data(name='x', shape=[3, 5], dtype="float32")
            y = layers.data(name='y', shape=[2, 3], dtype="float32")
            output = layers.crop(x, shape=y)
            self.assertIsNotNone(output)
        print(str(program))

W
whs 已提交
428 429 430 431 432 433 434 435 436
    def test_mean_iou(self):
        program = Program()
        with program_guard(program):
            x = layers.data(name='x', shape=[16], dtype='float32')
            y = layers.data(name='label', shape=[1], dtype='int64')
            iou = layers.mean_iou(x, y, 2)
            self.assertIsNotNone(iou)
        print(str(program))

437 438 439 440 441 442 443 444 445
    def test_argsort(self):
        program = Program()
        with program_guard(program):
            data = layers.data(name='x', shape=[2, 3, 3], dtype="float32")
            out, ids = layers.argsort(input=data, axis=1)
            self.assertIsNotNone(out)
            self.assertIsNotNone(ids)
        print(str(program))

446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467
    def test_rank_loss(self):
        program = Program()
        with program_guard(program):
            label = layers.data(
                name='label',
                append_batch_size=False,
                shape=[16, 1],
                dtype="float32")
            left = layers.data(
                name='left',
                append_batch_size=False,
                shape=[16, 1],
                dtype="float32")
            right = layers.data(
                name='right',
                append_batch_size=False,
                shape=[16, 1],
                dtype="float32")
            out = layers.rank_loss(label, left, right, name="rank_loss")
            self.assertIsNotNone(out)
        print(str(program))

Y
Yu Yang 已提交
468 469 470

if __name__ == '__main__':
    unittest.main()