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


16 17 18 19
import errno
import os
import pickle
import tempfile
H
hong 已提交
20
import unittest
21 22 23 24

import numpy as np
from test_imperative_base import new_program_scope

25
import paddle
H
hong 已提交
26 27 28 29 30
import paddle.fluid as fluid
import paddle.fluid.core as core
import paddle.fluid.framework as framework
from paddle.fluid.optimizer import Adam

31 32
paddle.enable_static()

H
hong 已提交
33 34

class SimpleLSTMRNN(fluid.Layer):
35 36 37 38 39 40 41 42 43
    def __init__(
        self,
        name_scope,
        hidden_size,
        num_steps,
        num_layers=2,
        init_scale=0.1,
        dropout=None,
    ):
44
        super().__init__()
H
hong 已提交
45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62
        self._hidden_size = hidden_size
        self._num_layers = num_layers
        self._init_scale = init_scale
        self._dropout = dropout
        self._input = None
        self._num_steps = num_steps
        self.cell_array = []
        self.hidden_array = []

        self.weight_1_arr = []
        self.weight_2_arr = []
        self.bias_arr = []
        self.mask_array = []

        for i in range(self._num_layers):
            weight_1 = self.create_parameter(
                attr=fluid.ParamAttr(
                    initializer=fluid.initializer.UniformInitializer(
63 64 65
                        low=-self._init_scale, high=self._init_scale
                    )
                ),
H
hong 已提交
66 67 68
                shape=[self._hidden_size * 2, self._hidden_size * 4],
                dtype="float32",
                default_initializer=fluid.initializer.UniformInitializer(
69 70 71
                    low=-self._init_scale, high=self._init_scale
                ),
            )
H
hong 已提交
72 73 74 75
            self.weight_1_arr.append(self.add_parameter('w_%d' % i, weight_1))
            bias_1 = self.create_parameter(
                attr=fluid.ParamAttr(
                    initializer=fluid.initializer.UniformInitializer(
76 77 78
                        low=-self._init_scale, high=self._init_scale
                    )
                ),
H
hong 已提交
79 80
                shape=[self._hidden_size * 4],
                dtype="float32",
81 82
                default_initializer=fluid.initializer.Constant(0.0),
            )
H
hong 已提交
83 84 85 86 87 88 89
            self.bias_arr.append(self.add_parameter('b_%d' % i, bias_1))

    def forward(self, input_embedding, init_hidden=None, init_cell=None):
        self.cell_array = []
        self.hidden_array = []

        for i in range(self._num_layers):
2
201716010711 已提交
90
            pre_hidden = paddle.slice(
91 92
                init_hidden, axes=[0], starts=[i], ends=[i + 1]
            )
2
201716010711 已提交
93
            pre_cell = paddle.slice(
94 95
                init_cell, axes=[0], starts=[i], ends=[i + 1]
            )
96
            pre_hidden = paddle.reshape(
97 98
                pre_hidden, shape=[-1, self._hidden_size]
            )
99
            pre_cell = paddle.reshape(pre_cell, shape=[-1, self._hidden_size])
H
hong 已提交
100 101 102 103 104
            self.hidden_array.append(pre_hidden)
            self.cell_array.append(pre_cell)

        res = []
        for index in range(self._num_steps):
2
201716010711 已提交
105
            self._input = paddle.slice(
106 107
                input_embedding, axes=[1], starts=[index], ends=[index + 1]
            )
108
            self._input = paddle.reshape(
109 110
                self._input, shape=[-1, self._hidden_size]
            )
H
hong 已提交
111 112 113 114 115 116 117 118 119
            for k in range(self._num_layers):
                pre_hidden = self.hidden_array[k]
                pre_cell = self.cell_array[k]
                weight_1 = self.weight_1_arr[k]
                bias = self.bias_arr[k]

                nn = fluid.layers.concat([self._input, pre_hidden], 1)
                gate_input = fluid.layers.matmul(x=nn, y=weight_1)

120
                gate_input = paddle.add(gate_input, bias)
121 122 123
                i, j, f, o = fluid.layers.split(
                    gate_input, num_or_sections=4, dim=-1
                )
124 125 126 127
                c = pre_cell * paddle.nn.functional.sigmoid(
                    f
                ) + paddle.nn.functional.sigmoid(i) * paddle.tanh(j)
                m = paddle.tanh(c) * paddle.nn.functional.sigmoid(o)
H
hong 已提交
128 129 130 131 132 133 134 135
                self.hidden_array[k] = m
                self.cell_array[k] = c
                self._input = m

                if self._dropout is not None and self._dropout > 0.0:
                    self._input = fluid.layers.dropout(
                        self._input,
                        dropout_prob=self._dropout,
136 137
                        dropout_implementation='upscale_in_train',
                    )
H
hong 已提交
138
            res.append(
139
                paddle.reshape(self._input, shape=[1, -1, self._hidden_size])
140
            )
H
hong 已提交
141
        real_res = fluid.layers.concat(res, 0)
142
        real_res = paddle.transpose(x=real_res, perm=[1, 0, 2])
H
hong 已提交
143
        last_hidden = fluid.layers.concat(self.hidden_array, 1)
144
        last_hidden = paddle.reshape(
145 146
            last_hidden, shape=[-1, self._num_layers, self._hidden_size]
        )
147
        last_hidden = paddle.transpose(x=last_hidden, perm=[1, 0, 2])
H
hong 已提交
148
        last_cell = fluid.layers.concat(self.cell_array, 1)
149
        last_cell = paddle.reshape(
150 151
            last_cell, shape=[-1, self._num_layers, self._hidden_size]
        )
152
        last_cell = paddle.transpose(x=last_cell, perm=[1, 0, 2])
H
hong 已提交
153 154 155 156
        return real_res, last_hidden, last_cell


class PtbModel(fluid.Layer):
157 158 159 160 161 162 163 164 165 166
    def __init__(
        self,
        name_scope,
        hidden_size,
        vocab_size,
        num_layers=2,
        num_steps=20,
        init_scale=0.1,
        dropout=None,
    ):
167
        super().__init__()
H
hong 已提交
168 169 170 171 172 173
        self.hidden_size = hidden_size
        self.vocab_size = vocab_size
        self.init_scale = init_scale
        self.num_layers = num_layers
        self.num_steps = num_steps
        self.dropout = dropout
174 175 176 177 178 179 180 181
        self.simple_lstm_rnn = SimpleLSTMRNN(
            self.full_name(),
            hidden_size,
            num_steps,
            num_layers=num_layers,
            init_scale=init_scale,
            dropout=dropout,
        )
182 183 184 185
        self.embedding = paddle.nn.Embedding(
            num_embeddings=vocab_size,
            embedding_dim=hidden_size,
            weight_attr=fluid.ParamAttr(
H
hong 已提交
186 187
                name='embedding_para',
                initializer=fluid.initializer.UniformInitializer(
188 189 190 191
                    low=-init_scale, high=init_scale
                ),
            ),
        )
H
hong 已提交
192 193 194 195 196
        self.softmax_weight = self.create_parameter(
            attr=fluid.ParamAttr(),
            shape=[self.hidden_size, self.vocab_size],
            dtype="float32",
            default_initializer=fluid.initializer.UniformInitializer(
197 198 199
                low=-self.init_scale, high=self.init_scale
            ),
        )
H
hong 已提交
200 201 202 203 204
        self.softmax_bias = self.create_parameter(
            attr=fluid.ParamAttr(),
            shape=[self.vocab_size],
            dtype="float32",
            default_initializer=fluid.initializer.UniformInitializer(
205 206 207
                low=-self.init_scale, high=self.init_scale
            ),
        )
H
hong 已提交
208 209

    def forward(self, input, label, init_hidden, init_cell):
210
        init_h = paddle.reshape(
211 212
            init_hidden, shape=[self.num_layers, -1, self.hidden_size]
        )
H
hong 已提交
213

214
        init_c = paddle.reshape(
215 216
            init_cell, shape=[self.num_layers, -1, self.hidden_size]
        )
H
hong 已提交
217

218 219
        # NPU 'tok_k' kernel only support `int32` dtype, so cast `input` from `int64` to `int32`.
        input = fluid.layers.cast(input, "int32")
H
hong 已提交
220
        x_emb = self.embedding(input)
221
        x_emb = paddle.reshape(
222 223
            x_emb, shape=[-1, self.num_steps, self.hidden_size]
        )
H
hong 已提交
224 225 226 227
        if self.dropout is not None and self.dropout > 0.0:
            x_emb = fluid.layers.dropout(
                x_emb,
                dropout_prob=self.drop_out,
228 229
                dropout_implementation='upscale_in_train',
            )
230
        rnn_out, last_hidden, last_cell = self.simple_lstm_rnn(
231 232
            x_emb, init_h, init_c
        )
H
hong 已提交
233

234
        rnn_out = paddle.reshape(
235 236
            rnn_out, shape=[-1, self.num_steps, self.hidden_size]
        )
H
hong 已提交
237
        projection = fluid.layers.matmul(rnn_out, self.softmax_weight)
238
        projection = paddle.add(projection, self.softmax_bias)
239
        projection = paddle.reshape(projection, shape=[-1, self.vocab_size])
240 241 242
        loss = fluid.layers.softmax_with_cross_entropy(
            logits=projection, label=label, soft_label=False
        )
243
        loss = paddle.reshape(loss, shape=[-1, self.num_steps])
244
        loss = paddle.mean(loss, axis=[0])
245
        loss = paddle.sum(loss)
H
hong 已提交
246 247 248 249

        return loss, last_hidden, last_cell


250
class TestSaveLoadBase(unittest.TestCase):
251
    def set_place(self):
252 253 254 255 256
        return (
            fluid.CPUPlace()
            if not core.is_compiled_with_cuda()
            else fluid.CUDAPlace(0)
        )
257

H
hong 已提交
258 259 260 261 262 263 264 265 266
    def test_ptb_rnn_cpu_float32(self):
        seed = 90
        hidden_size = 10
        vocab_size = 1000
        num_layers = 1
        num_steps = 3
        init_scale = 0.1
        batch_size = 4
        batch_num = 200
267
        temp_dir = tempfile.TemporaryDirectory()
H
hong 已提交
268 269 270 271

        with new_program_scope():
            fluid.default_startup_program().random_seed = seed
            fluid.default_main_program().random_seed = seed
272 273 274 275 276 277 278 279
            ptb_model = PtbModel(
                "ptb_model",
                hidden_size=hidden_size,
                vocab_size=vocab_size,
                num_layers=num_layers,
                num_steps=num_steps,
                init_scale=init_scale,
            )
H
hong 已提交
280

281
            place = self.set_place()
H
hong 已提交
282 283
            exe = fluid.Executor(place)
            sgd = Adam(learning_rate=1e-3)
284 285 286
            x = fluid.layers.data(
                name="x", shape=[-1, num_steps], dtype='int64'
            )
H
hong 已提交
287
            y = fluid.layers.data(name="y", shape=[-1, 1], dtype='float32')
288 289 290 291 292 293
            init_hidden = fluid.layers.data(
                name="init_hidden", shape=[1], dtype='float32'
            )
            init_cell = fluid.layers.data(
                name="init_cell", shape=[1], dtype='float32'
            )
H
hong 已提交
294 295

            static_loss, static_last_hidden, static_last_cell = ptb_model(
296 297
                x, y, init_hidden, init_cell
            )
H
hong 已提交
298 299 300 301 302 303 304 305 306 307 308 309 310 311 312
            sgd.minimize(static_loss)
            static_param_updated = dict()
            static_param_init = dict()

            out = exe.run(framework.default_startup_program())

            static_loss_value = None
            static_last_cell_value = None
            static_last_hidden_value = None
            for i in range(batch_num):
                x_data = np.arange(12).reshape(4, 3).astype('int64')
                y_data = np.arange(1, 13).reshape(4, 3).astype('int64')
                x_data = x_data.reshape((-1, num_steps, 1))
                y_data = y_data.reshape((-1, 1))
                init_hidden_data = np.zeros(
313 314 315 316 317
                    (num_layers, batch_size, hidden_size), dtype='float32'
                )
                init_cell_data = np.zeros(
                    (num_layers, batch_size, hidden_size), dtype='float32'
                )
H
hong 已提交
318
                fetch_list = [static_loss, static_last_hidden, static_last_cell]
319 320 321 322 323 324 325 326 327 328
                out = exe.run(
                    fluid.default_main_program(),
                    feed={
                        "x": x_data,
                        "y": y_data,
                        "init_hidden": init_hidden_data,
                        "init_cell": init_cell_data,
                    },
                    fetch_list=fetch_list,
                )
H
hong 已提交
329 330 331 332 333 334 335 336
                static_loss_value = out[0]
                static_last_hidden_value = out[1]
                static_last_cell_value = out[2]

            # get value before save
            main_program = framework.default_main_program()
            base_map = {}
            for var in main_program.list_vars():
337
                if isinstance(var, framework.Parameter) or var.persistable:
338 339 340
                    t = np.array(
                        fluid.global_scope().find_var(var.name).get_tensor()
                    )
T
tianshuo78520a 已提交
341
                    # make sure all the paramerter or optimizer var have been update
H
hong 已提交
342 343 344
                    self.assertTrue(np.sum(np.abs(t)) != 0)
                    base_map[var.name] = t

345
            fluid.save(main_program, os.path.join(temp_dir.name, "test_1"))
H
hong 已提交
346 347 348

            # set var to zero
            for var in main_program.list_vars():
349
                if isinstance(var, framework.Parameter) or var.persistable:
H
hong 已提交
350 351 352
                    ten = fluid.global_scope().find_var(var.name).get_tensor()
                    ten.set(np.zeros_like(np.array(ten)), place)

353 354 355
                    new_t = np.array(
                        fluid.global_scope().find_var(var.name).get_tensor()
                    )
T
tianshuo78520a 已提交
356
                    # make sure all the paramerter or optimizer var have been set to zero
H
hong 已提交
357 358
                    self.assertTrue(np.sum(np.abs(new_t)) == 0)

359 360 361 362 363
            fluid.load(
                main_program,
                os.path.join(temp_dir.name, "test_1.pdparams"),
                exe,
            )
H
hong 已提交
364 365

            for var in main_program.list_vars():
366
                if isinstance(var, framework.Parameter) or var.persistable:
367 368 369
                    new_t = np.array(
                        fluid.global_scope().find_var(var.name).get_tensor()
                    )
H
hong 已提交
370
                    base_t = base_map[var.name]
371
                    np.testing.assert_array_equal(new_t, base_t)
372
            temp_dir.cleanup()
H
hong 已提交
373 374


375
class TestSaveLoadPartial(unittest.TestCase):
376
    def set_place(self):
377 378 379 380 381
        return (
            fluid.CPUPlace()
            if not core.is_compiled_with_cuda()
            else fluid.CUDAPlace(0)
        )
382

H
hong 已提交
383 384 385 386 387 388 389 390 391
    def test_ptb_rnn_cpu_float32(self):
        seed = 90
        hidden_size = 10
        vocab_size = 1000
        num_layers = 1
        num_steps = 3
        init_scale = 0.1
        batch_size = 4
        batch_num = 200
392
        temp_dir = tempfile.TemporaryDirectory()
H
hong 已提交
393 394 395 396

        with new_program_scope():
            fluid.default_startup_program().random_seed = seed
            fluid.default_main_program().random_seed = seed
397 398 399 400 401 402 403 404
            ptb_model = PtbModel(
                "ptb_model",
                hidden_size=hidden_size,
                vocab_size=vocab_size,
                num_layers=num_layers,
                num_steps=num_steps,
                init_scale=init_scale,
            )
H
hong 已提交
405

406
            place = self.set_place()
H
hong 已提交
407 408
            exe = fluid.Executor(place)
            sgd = Adam(learning_rate=1e-3)
409 410 411
            x = fluid.layers.data(
                name="x", shape=[-1, num_steps], dtype='int64'
            )
H
hong 已提交
412
            y = fluid.layers.data(name="y", shape=[-1, 1], dtype='float32')
413 414 415 416 417 418
            init_hidden = fluid.layers.data(
                name="init_hidden", shape=[1], dtype='float32'
            )
            init_cell = fluid.layers.data(
                name="init_cell", shape=[1], dtype='float32'
            )
H
hong 已提交
419 420

            static_loss, static_last_hidden, static_last_cell = ptb_model(
421 422
                x, y, init_hidden, init_cell
            )
H
hong 已提交
423 424 425

            test_program = fluid.default_main_program().clone(for_test=True)

426 427 428 429 430 431
            add_1 = fluid.layers.fc(
                static_last_hidden,
                size=hidden_size,
                num_flatten_dims=2,
                bias_attr=False,
            )
H
hong 已提交
432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447

            sgd.minimize(static_loss)
            static_param_updated = dict()
            static_param_init = dict()

            out = exe.run(framework.default_startup_program())

            static_loss_value = None
            static_last_cell_value = None
            static_last_hidden_value = None
            for i in range(batch_num):
                x_data = np.arange(12).reshape(4, 3).astype('int64')
                y_data = np.arange(1, 13).reshape(4, 3).astype('int64')
                x_data = x_data.reshape((-1, num_steps, 1))
                y_data = y_data.reshape((-1, 1))
                init_hidden_data = np.zeros(
448 449 450 451 452
                    (num_layers, batch_size, hidden_size), dtype='float32'
                )
                init_cell_data = np.zeros(
                    (num_layers, batch_size, hidden_size), dtype='float32'
                )
H
hong 已提交
453
                fetch_list = [static_loss, static_last_hidden, static_last_cell]
454 455 456 457 458 459 460 461 462 463
                out = exe.run(
                    fluid.default_main_program(),
                    feed={
                        "x": x_data,
                        "y": y_data,
                        "init_hidden": init_hidden_data,
                        "init_cell": init_cell_data,
                    },
                    fetch_list=fetch_list,
                )
H
hong 已提交
464 465 466 467 468 469 470 471
                static_loss_value = out[0]
                static_last_hidden_value = out[1]
                static_last_cell_value = out[2]

            # get value before save
            main_program = framework.default_main_program()
            base_map = {}
            for var in main_program.list_vars():
472
                if isinstance(var, framework.Parameter) or var.persistable:
473 474 475
                    t = np.array(
                        fluid.global_scope().find_var(var.name).get_tensor()
                    )
T
tianshuo78520a 已提交
476
                    # make sure all the paramerter or optimizer var have been update
H
hong 已提交
477 478 479
                    self.assertTrue(np.sum(np.abs(t)) != 0)
                    base_map[var.name] = t

480
            fluid.save(main_program, os.path.join(temp_dir.name, "test_1"))
H
hong 已提交
481 482 483

            # set var to zero
            for var in main_program.list_vars():
484
                if isinstance(var, framework.Parameter) or var.persistable:
H
hong 已提交
485 486 487
                    ten = fluid.global_scope().find_var(var.name).get_tensor()
                    ten.set(np.zeros_like(np.array(ten)), place)

488 489 490
                    new_t = np.array(
                        fluid.global_scope().find_var(var.name).get_tensor()
                    )
T
tianshuo78520a 已提交
491
                    # make sure all the paramerter or optimizer var have been set to zero
H
hong 已提交
492 493
                    self.assertTrue(np.sum(np.abs(new_t)) == 0)

494 495 496
            fluid.load(
                test_program, os.path.join(temp_dir.name, "test_1.pdopt"), None
            )
H
hong 已提交
497 498

            for var in test_program.list_vars():
499
                if isinstance(var, framework.Parameter) or var.persistable:
500 501 502
                    new_t = np.array(
                        fluid.global_scope().find_var(var.name).get_tensor()
                    )
H
hong 已提交
503
                    base_t = base_map[var.name]
504
                    np.testing.assert_array_equal(new_t, base_t)
505 506 507 508 509
            fluid.load(
                test_program,
                os.path.join(temp_dir.name, "test_1.pdmodel"),
                None,
            )
510
            temp_dir.cleanup()
H
hong 已提交
511 512


513
class TestSaveLoadSetStateDict(unittest.TestCase):
514
    def set_place(self):
515 516 517 518 519
        return (
            fluid.CPUPlace()
            if not core.is_compiled_with_cuda()
            else fluid.CUDAPlace(0)
        )
520

521 522 523 524 525 526 527 528 529
    def test_ptb_rnn_cpu_float32(self):
        seed = 90
        hidden_size = 10
        vocab_size = 1000
        num_layers = 1
        num_steps = 3
        init_scale = 0.1
        batch_size = 4
        batch_num = 200
530
        temp_dir = tempfile.TemporaryDirectory()
531 532 533 534

        with new_program_scope():
            fluid.default_startup_program().random_seed = seed
            fluid.default_main_program().random_seed = seed
535 536 537 538 539 540 541 542
            ptb_model = PtbModel(
                "ptb_model",
                hidden_size=hidden_size,
                vocab_size=vocab_size,
                num_layers=num_layers,
                num_steps=num_steps,
                init_scale=init_scale,
            )
543

544
            place = self.set_place()
545 546
            exe = fluid.Executor(place)
            sgd = Adam(learning_rate=1e-3)
547 548 549
            x = fluid.layers.data(
                name="x", shape=[-1, num_steps], dtype='int64'
            )
550
            y = fluid.layers.data(name="y", shape=[-1, 1], dtype='float32')
551 552 553 554 555 556
            init_hidden = fluid.layers.data(
                name="init_hidden", shape=[1], dtype='float32'
            )
            init_cell = fluid.layers.data(
                name="init_cell", shape=[1], dtype='float32'
            )
557 558

            static_loss, static_last_hidden, static_last_cell = ptb_model(
559 560
                x, y, init_hidden, init_cell
            )
561 562 563 564 565 566 567 568 569 570 571 572 573 574 575
            sgd.minimize(static_loss)
            static_param_updated = dict()
            static_param_init = dict()

            out = exe.run(framework.default_startup_program())

            static_loss_value = None
            static_last_cell_value = None
            static_last_hidden_value = None
            for i in range(batch_num):
                x_data = np.arange(12).reshape(4, 3).astype('int64')
                y_data = np.arange(1, 13).reshape(4, 3).astype('int64')
                x_data = x_data.reshape((-1, num_steps, 1))
                y_data = y_data.reshape((-1, 1))
                init_hidden_data = np.zeros(
576 577 578 579 580
                    (num_layers, batch_size, hidden_size), dtype='float32'
                )
                init_cell_data = np.zeros(
                    (num_layers, batch_size, hidden_size), dtype='float32'
                )
581
                fetch_list = [static_loss, static_last_hidden, static_last_cell]
582 583 584 585 586 587 588 589 590 591
                out = exe.run(
                    fluid.default_main_program(),
                    feed={
                        "x": x_data,
                        "y": y_data,
                        "init_hidden": init_hidden_data,
                        "init_cell": init_cell_data,
                    },
                    fetch_list=fetch_list,
                )
592 593 594 595 596 597 598 599 600
                static_loss_value = out[0]
                static_last_hidden_value = out[1]
                static_last_cell_value = out[2]

            # get value before save
            main_program = framework.default_main_program()
            base_map = {}
            for var in main_program.list_vars():
                if isinstance(var, framework.Parameter) or var.persistable:
601 602 603
                    t = np.array(
                        fluid.global_scope().find_var(var.name).get_tensor()
                    )
T
tianshuo78520a 已提交
604
                    # make sure all the paramerter or optimizer var have been update
605 606 607
                    self.assertTrue(np.sum(np.abs(t)) != 0)
                    base_map[var.name] = t

608
            fluid.save(main_program, os.path.join(temp_dir.name, "test_1"))
609 610 611 612 613 614 615

            # set var to zero
            for var in main_program.list_vars():
                if isinstance(var, framework.Parameter) or var.persistable:
                    ten = fluid.global_scope().find_var(var.name).get_tensor()
                    ten.set(np.zeros_like(np.array(ten)), place)

616 617 618
                    new_t = np.array(
                        fluid.global_scope().find_var(var.name).get_tensor()
                    )
T
tianshuo78520a 已提交
619
                    # make sure all the paramerter or optimizer var have been set to zero
620 621
                    self.assertTrue(np.sum(np.abs(new_t)) == 0)

622
            fluid.load(main_program, os.path.join(temp_dir.name, "test_1"), exe)
623 624 625

            for var in main_program.list_vars():
                if isinstance(var, framework.Parameter) or var.persistable:
626 627 628
                    new_t = np.array(
                        fluid.global_scope().find_var(var.name).get_tensor()
                    )
629
                    base_t = base_map[var.name]
630
                    np.testing.assert_array_equal(new_t, base_t)
631
            temp_dir.cleanup()
632 633 634


class TestProgramStatePartial(unittest.TestCase):
635
    def set_place(self):
636 637 638 639 640
        return (
            fluid.CPUPlace()
            if not core.is_compiled_with_cuda()
            else fluid.CUDAPlace(0)
        )
641

642 643 644 645 646 647 648 649 650
    def test_ptb_rnn_cpu_float32(self):
        seed = 90
        hidden_size = 10
        vocab_size = 1000
        num_layers = 1
        num_steps = 3
        init_scale = 0.1
        batch_size = 4
        batch_num = 200
651
        temp_dir = tempfile.TemporaryDirectory()
652 653 654 655

        with new_program_scope():
            fluid.default_startup_program().random_seed = seed
            fluid.default_main_program().random_seed = seed
656 657 658 659 660 661 662 663
            ptb_model = PtbModel(
                "ptb_model",
                hidden_size=hidden_size,
                vocab_size=vocab_size,
                num_layers=num_layers,
                num_steps=num_steps,
                init_scale=init_scale,
            )
664

665
            place = self.set_place()
666 667
            exe = fluid.Executor(place)
            sgd = Adam(learning_rate=1e-3)
668 669 670
            x = fluid.layers.data(
                name="x", shape=[-1, num_steps], dtype='int64'
            )
671
            y = fluid.layers.data(name="y", shape=[-1, 1], dtype='float32')
672 673 674 675 676 677
            init_hidden = fluid.layers.data(
                name="init_hidden", shape=[1], dtype='float32'
            )
            init_cell = fluid.layers.data(
                name="init_cell", shape=[1], dtype='float32'
            )
678 679

            static_loss, static_last_hidden, static_last_cell = ptb_model(
680 681
                x, y, init_hidden, init_cell
            )
682 683 684

            test_program = fluid.default_main_program().clone(for_test=True)

685 686 687 688 689 690
            add_1 = fluid.layers.fc(
                static_last_hidden,
                size=hidden_size,
                num_flatten_dims=2,
                bias_attr=False,
            )
691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706

            sgd.minimize(static_loss)
            static_param_updated = dict()
            static_param_init = dict()

            out = exe.run(framework.default_startup_program())

            static_loss_value = None
            static_last_cell_value = None
            static_last_hidden_value = None
            for i in range(batch_num):
                x_data = np.arange(12).reshape(4, 3).astype('int64')
                y_data = np.arange(1, 13).reshape(4, 3).astype('int64')
                x_data = x_data.reshape((-1, num_steps, 1))
                y_data = y_data.reshape((-1, 1))
                init_hidden_data = np.zeros(
707 708 709 710 711
                    (num_layers, batch_size, hidden_size), dtype='float32'
                )
                init_cell_data = np.zeros(
                    (num_layers, batch_size, hidden_size), dtype='float32'
                )
712
                fetch_list = [static_loss, static_last_hidden, static_last_cell]
713 714 715 716 717 718 719 720 721 722
                out = exe.run(
                    fluid.default_main_program(),
                    feed={
                        "x": x_data,
                        "y": y_data,
                        "init_hidden": init_hidden_data,
                        "init_cell": init_cell_data,
                    },
                    fetch_list=fetch_list,
                )
723 724 725 726 727 728 729 730 731
                static_loss_value = out[0]
                static_last_hidden_value = out[1]
                static_last_cell_value = out[2]

            # get value before save
            main_program = framework.default_main_program()
            base_map = {}
            for var in main_program.list_vars():
                if isinstance(var, framework.Parameter) or var.persistable:
732 733 734
                    t = np.array(
                        fluid.global_scope().find_var(var.name).get_tensor()
                    )
T
tianshuo78520a 已提交
735
                    # make sure all the paramerter or optimizer var have been update
736 737 738
                    self.assertTrue(np.sum(np.abs(t)) != 0)
                    base_map[var.name] = t

739
            fluid.save(main_program, os.path.join(temp_dir.name, 'test_1'))
740 741 742 743 744 745 746

            # set var to zero
            for var in main_program.list_vars():
                if isinstance(var, framework.Parameter) or var.persistable:
                    ten = fluid.global_scope().find_var(var.name).get_tensor()
                    ten.set(np.zeros_like(np.array(ten)), place)

747 748 749
                    new_t = np.array(
                        fluid.global_scope().find_var(var.name).get_tensor()
                    )
T
tianshuo78520a 已提交
750
                    # make sure all the paramerter or optimizer var have been set to zero
751 752
                    self.assertTrue(np.sum(np.abs(new_t)) == 0)

753
            # fluid.load(test_program, "./test_1", None )
754
            program_state = fluid.load_program_state(
755 756
                os.path.join(temp_dir.name, 'test_1')
            )
H
hong 已提交
757 758

            program_state_1 = fluid.load_program_state(
759 760
                os.path.join(temp_dir.name, 'test_1.pdparams')
            )
H
hong 已提交
761 762

            program_state_2 = fluid.load_program_state(
763 764
                os.path.join(temp_dir.name, 'test_1.pdopt')
            )
H
hong 已提交
765 766

            program_state_3 = fluid.load_program_state(
767 768
                os.path.join(temp_dir.name, 'test_1.pdmodel')
            )
H
hong 已提交
769

770 771 772 773
            fluid.set_program_state(test_program, program_state)

            for var in test_program.list_vars():
                if isinstance(var, framework.Parameter) or var.persistable:
774 775 776
                    new_t = np.array(
                        fluid.global_scope().find_var(var.name).get_tensor()
                    )
777
                    base_t = base_map[var.name]
778
                    np.testing.assert_array_equal(new_t, base_t)
779

H
hong 已提交
780 781 782 783 784 785
            # check 1
            for var in main_program.list_vars():
                if isinstance(var, framework.Parameter) or var.persistable:
                    ten = fluid.global_scope().find_var(var.name).get_tensor()
                    ten.set(np.zeros_like(np.array(ten)), place)

786 787 788
                    new_t = np.array(
                        fluid.global_scope().find_var(var.name).get_tensor()
                    )
T
tianshuo78520a 已提交
789
                    # make sure all the paramerter or optimizer var have been set to zero
H
hong 已提交
790 791 792 793 794 795
                    self.assertTrue(np.sum(np.abs(new_t)) == 0)

            fluid.set_program_state(test_program, program_state_1)

            for var in test_program.list_vars():
                if isinstance(var, framework.Parameter) or var.persistable:
796 797 798
                    new_t = np.array(
                        fluid.global_scope().find_var(var.name).get_tensor()
                    )
H
hong 已提交
799
                    base_t = base_map[var.name]
800
                    np.testing.assert_array_equal(new_t, base_t)
H
hong 已提交
801 802 803 804 805 806 807

            # check 2
            for var in main_program.list_vars():
                if isinstance(var, framework.Parameter) or var.persistable:
                    ten = fluid.global_scope().find_var(var.name).get_tensor()
                    ten.set(np.zeros_like(np.array(ten)), place)

808 809 810
                    new_t = np.array(
                        fluid.global_scope().find_var(var.name).get_tensor()
                    )
T
tianshuo78520a 已提交
811
                    # make sure all the paramerter or optimizer var have been set to zero
H
hong 已提交
812 813 814 815 816 817
                    self.assertTrue(np.sum(np.abs(new_t)) == 0)

            fluid.set_program_state(test_program, program_state_2)

            for var in test_program.list_vars():
                if isinstance(var, framework.Parameter) or var.persistable:
818 819 820
                    new_t = np.array(
                        fluid.global_scope().find_var(var.name).get_tensor()
                    )
H
hong 已提交
821
                    base_t = base_map[var.name]
822
                    np.testing.assert_array_equal(new_t, base_t)
H
hong 已提交
823 824 825 826 827 828 829

            # check 3
            for var in main_program.list_vars():
                if isinstance(var, framework.Parameter) or var.persistable:
                    ten = fluid.global_scope().find_var(var.name).get_tensor()
                    ten.set(np.zeros_like(np.array(ten)), place)

830 831 832
                    new_t = np.array(
                        fluid.global_scope().find_var(var.name).get_tensor()
                    )
T
tianshuo78520a 已提交
833
                    # make sure all the paramerter or optimizer var have been set to zero
H
hong 已提交
834 835 836 837 838 839
                    self.assertTrue(np.sum(np.abs(new_t)) == 0)

            fluid.set_program_state(test_program, program_state_3)

            for var in test_program.list_vars():
                if isinstance(var, framework.Parameter) or var.persistable:
840 841 842
                    new_t = np.array(
                        fluid.global_scope().find_var(var.name).get_tensor()
                    )
H
hong 已提交
843
                    base_t = base_map[var.name]
844
                    np.testing.assert_array_equal(new_t, base_t)
845
            temp_dir.cleanup()
H
hong 已提交
846

847 848

class TestVariableInit(unittest.TestCase):
849
    def set_place(self):
850 851 852 853 854
        return (
            fluid.CPUPlace()
            if not core.is_compiled_with_cuda()
            else fluid.CUDAPlace(0)
        )
855

856 857 858 859 860 861
    def test_variable_init(self):

        x = fluid.data(name="x", shape=[10, 10], dtype='float32')
        y = fluid.layers.fc(x, 10)
        z = fluid.layers.fc(y, 10)

862
        place = self.set_place()
863 864 865
        exe = fluid.Executor(place)
        exe.run(fluid.default_startup_program())

866
        temp_dir = tempfile.TemporaryDirectory()
867 868 869 870
        fluid.save(
            fluid.default_main_program(),
            os.path.join(temp_dir.name, "test_path"),
        )
871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888

        def set_var(var, ndarray):
            t = var.get_tensor()
            p = t._place()
            if p.is_cpu_place():
                place = paddle.fluid.CPUPlace()
            elif p.is_cuda_pinned_place():
                place = paddle.fluid.CUDAPinnedPlace()
            else:
                p = paddle.fluid.core.Place()
                p.set_place(t._place())
                place = paddle.fluid.CUDAPlace(p.gpu_device_id())

            t.set(ndarray, place)

        program = fluid.default_main_program()
        new_scope = fluid.core.Scope()

889
        place = self.set_place()
890
        exe = fluid.Executor(place)
891 892 893
        parameter_list = list(
            filter(fluid.io.is_parameter, program.list_vars())
        )
894

895 896 897
        fluid.core._create_loaded_parameter(
            parameter_list, new_scope, exe._default_executor
        )
898
        parameter_file_name = os.path.join(temp_dir.name, "test_path.pdparams")
899 900 901 902
        with open(parameter_file_name, 'rb') as f:
            load_dict = pickle.load(f)

        for v in parameter_list:
903 904 905 906 907
            assert (
                v.name in load_dict
            ), "Can not find [{}] in model file [{}]".format(
                v.name, parameter_file_name
            )
908 909 910 911
            new_v = new_scope.find_var(v.name)
            set_var(new_v, load_dict[v.name])

        opt_list = list(
912 913
            filter(fluid.io.is_belong_to_optimizer, program.list_vars())
        )
914

915 916 917
        fluid.core._create_loaded_parameter(
            opt_list, new_scope, exe._default_executor
        )
918
        opt_file_name = os.path.join(temp_dir.name, "test_path.pdopt")
919 920 921 922
        with open(opt_file_name, 'rb') as f:
            load_dict = pickle.load(f)

        for v in opt_list:
923 924 925 926 927
            assert (
                v.name in load_dict
            ), "Can not find [{}] in model file [{}]".format(
                v.name, opt_file_name
            )
928 929 930 931 932 933 934

            new_v = new_scope.find_var(v.name)
            set_var(new_v, load_dict[v.name])

        base_map = {}
        for var in program.list_vars():
            if isinstance(var, framework.Parameter) or var.persistable:
935 936 937
                t = np.array(
                    fluid.global_scope().find_var(var.name).get_tensor()
                )
T
tianshuo78520a 已提交
938
                # make sure all the paramerter or optimizer var have been update
939 940 941 942 943 944 945
                base_map[var.name] = t

        for var in program.list_vars():
            if isinstance(var, framework.Parameter) or var.persistable:
                new_t = np.array(new_scope.find_var(var.name).get_tensor())
                base_t = base_map[var.name]

946
                np.testing.assert_array_equal(new_t, base_t)
947
        temp_dir.cleanup()
948 949


H
hong 已提交
950 951 952 953 954
class TestLoadFromOldInterface(unittest.TestCase):
    def setUp(self):
        if os.path.exists("test_path.pdparams"):
            os.remove("test_path.pdparams")

955 956 957
        if os.path.exists("test_static_load_var_list.pdparams"):
            os.remove("test_static_load_var_list.pdparams")

958 959
        self.temp_dir = tempfile.TemporaryDirectory()

960
    def set_place(self):
961 962 963 964 965
        return (
            fluid.CPUPlace()
            if not core.is_compiled_with_cuda()
            else fluid.CUDAPlace(0)
        )
966

967 968 969
    def tearDown(self):
        self.temp_dir.cleanup()

H
hong 已提交
970 971 972 973 974 975 976 977 978 979 980 981 982
    def test_load_from_old_interface(self):
        seed = 90
        hidden_size = 10
        vocab_size = 1000
        num_layers = 1
        num_steps = 3
        init_scale = 0.1
        batch_size = 4
        batch_num = 200

        with new_program_scope():
            fluid.default_startup_program().random_seed = seed
            fluid.default_main_program().random_seed = seed
983 984 985 986 987 988 989 990
            ptb_model = PtbModel(
                "ptb_model",
                hidden_size=hidden_size,
                vocab_size=vocab_size,
                num_layers=num_layers,
                num_steps=num_steps,
                init_scale=init_scale,
            )
H
hong 已提交
991

992
            place = self.set_place()
H
hong 已提交
993 994
            exe = fluid.Executor(place)
            sgd = Adam(learning_rate=1e-3)
995 996 997
            x = fluid.layers.data(
                name="x", shape=[-1, num_steps], dtype='int64'
            )
H
hong 已提交
998
            y = fluid.layers.data(name="y", shape=[-1, 1], dtype='float32')
999 1000 1001 1002 1003 1004
            init_hidden = fluid.layers.data(
                name="init_hidden", shape=[1], dtype='float32'
            )
            init_cell = fluid.layers.data(
                name="init_cell", shape=[1], dtype='float32'
            )
H
hong 已提交
1005 1006

            static_loss, static_last_hidden, static_last_cell = ptb_model(
1007 1008
                x, y, init_hidden, init_cell
            )
H
hong 已提交
1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025

            test_clone_program = fluid.default_main_program().clone()
            sgd.minimize(static_loss)
            static_param_updated = dict()
            static_param_init = dict()

            out = exe.run(framework.default_startup_program())

            static_loss_value = None
            static_last_cell_value = None
            static_last_hidden_value = None
            for i in range(batch_num):
                x_data = np.arange(12).reshape(4, 3).astype('int64')
                y_data = np.arange(1, 13).reshape(4, 3).astype('int64')
                x_data = x_data.reshape((-1, num_steps, 1))
                y_data = y_data.reshape((-1, 1))
                init_hidden_data = np.zeros(
1026 1027 1028 1029 1030
                    (num_layers, batch_size, hidden_size), dtype='float32'
                )
                init_cell_data = np.zeros(
                    (num_layers, batch_size, hidden_size), dtype='float32'
                )
H
hong 已提交
1031
                fetch_list = [static_loss, static_last_hidden, static_last_cell]
1032 1033 1034 1035 1036 1037 1038 1039 1040 1041
                out = exe.run(
                    fluid.default_main_program(),
                    feed={
                        "x": x_data,
                        "y": y_data,
                        "init_hidden": init_hidden_data,
                        "init_cell": init_cell_data,
                    },
                    fetch_list=fetch_list,
                )
H
hong 已提交
1042 1043 1044 1045 1046 1047 1048 1049 1050
                static_loss_value = out[0]
                static_last_hidden_value = out[1]
                static_last_cell_value = out[2]

            # get value before save
            main_program = framework.default_main_program()
            base_map = {}
            for var in main_program.list_vars():
                if isinstance(var, framework.Parameter) or var.persistable:
1051 1052 1053
                    t = np.array(
                        fluid.global_scope().find_var(var.name).get_tensor()
                    )
T
tianshuo78520a 已提交
1054
                    # make sure all the paramerter or optimizer var have been update
H
hong 已提交
1055 1056 1057
                    self.assertTrue(np.sum(np.abs(t)) != 0)
                    base_map[var.name] = t

1058
            # fluid.save(main_program, "./test_1")
1059
            paddle.distributed.io.save_persistables(
1060 1061
                exe, os.path.join(self.temp_dir.name, "test_path"), main_program
            )
H
hong 已提交
1062 1063 1064 1065 1066 1067 1068

            # set var to zero
            for var in main_program.list_vars():
                if isinstance(var, framework.Parameter) or var.persistable:
                    ten = fluid.global_scope().find_var(var.name).get_tensor()
                    ten.set(np.zeros_like(np.array(ten)), place)

1069 1070 1071
                    new_t = np.array(
                        fluid.global_scope().find_var(var.name).get_tensor()
                    )
T
tianshuo78520a 已提交
1072
                    # make sure all the paramerter or optimizer var have been set to zero
H
hong 已提交
1073 1074
                    self.assertTrue(np.sum(np.abs(new_t)) == 0)

1075 1076 1077
            fluid.load(
                main_program, os.path.join(self.temp_dir.name, "test_path"), exe
            )
H
hong 已提交
1078 1079 1080

            for var in main_program.list_vars():
                if isinstance(var, framework.Parameter) or var.persistable:
1081 1082 1083
                    new_t = np.array(
                        fluid.global_scope().find_var(var.name).get_tensor()
                    )
H
hong 已提交
1084
                    base_t = base_map[var.name]
1085
                    np.testing.assert_array_equal(new_t, base_t)
H
hong 已提交
1086 1087 1088 1089 1090 1091 1092 1093 1094

            for var in main_program.list_vars():
                if isinstance(var, framework.Parameter) or var.persistable:
                    ten = fluid.global_scope().find_var(var.name).get_tensor()
                    old_shape = np.array(ten).shape
                    new_shape = [e + 10 for e in old_shape]

                    var.desc.set_shape(new_shape)
            with self.assertRaises(RuntimeError):
1095 1096 1097 1098 1099
                fluid.load(
                    main_program,
                    os.path.join(self.temp_dir.name, "test_path"),
                    exe,
                )
H
hong 已提交
1100

T
tianshuo78520a 已提交
1101
            # check unused parameter
H
hong 已提交
1102

1103 1104 1105 1106 1107
            fluid.load(
                test_clone_program,
                os.path.join(self.temp_dir.name, "test_path"),
                exe,
            )
H
hong 已提交
1108

1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121
    def test_load_from_old_interface_var_list(self):
        seed = 90
        hidden_size = 10
        vocab_size = 1000
        num_layers = 1
        num_steps = 3
        init_scale = 0.1
        batch_size = 4
        batch_num = 200

        with new_program_scope():
            fluid.default_startup_program().random_seed = seed
            fluid.default_main_program().random_seed = seed
1122 1123 1124 1125 1126 1127 1128 1129
            ptb_model = PtbModel(
                "ptb_model",
                hidden_size=hidden_size,
                vocab_size=vocab_size,
                num_layers=num_layers,
                num_steps=num_steps,
                init_scale=init_scale,
            )
1130

1131
            place = self.set_place()
1132 1133
            exe = fluid.Executor(place)
            sgd = Adam(learning_rate=1e-3)
1134 1135 1136
            x = fluid.layers.data(
                name="x", shape=[-1, num_steps], dtype='int64'
            )
1137
            y = fluid.layers.data(name="y", shape=[-1, 1], dtype='float32')
1138 1139 1140 1141 1142 1143
            init_hidden = fluid.layers.data(
                name="init_hidden", shape=[1], dtype='float32'
            )
            init_cell = fluid.layers.data(
                name="init_cell", shape=[1], dtype='float32'
            )
1144 1145

            static_loss, static_last_hidden, static_last_cell = ptb_model(
1146 1147
                x, y, init_hidden, init_cell
            )
1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164

            test_clone_program = fluid.default_main_program().clone()
            sgd.minimize(static_loss)
            static_param_updated = dict()
            static_param_init = dict()

            out = exe.run(framework.default_startup_program())

            static_loss_value = None
            static_last_cell_value = None
            static_last_hidden_value = None
            for i in range(batch_num):
                x_data = np.arange(12).reshape(4, 3).astype('int64')
                y_data = np.arange(1, 13).reshape(4, 3).astype('int64')
                x_data = x_data.reshape((-1, num_steps, 1))
                y_data = y_data.reshape((-1, 1))
                init_hidden_data = np.zeros(
1165 1166 1167 1168 1169
                    (num_layers, batch_size, hidden_size), dtype='float32'
                )
                init_cell_data = np.zeros(
                    (num_layers, batch_size, hidden_size), dtype='float32'
                )
1170
                fetch_list = [static_loss, static_last_hidden, static_last_cell]
1171 1172 1173 1174 1175 1176 1177 1178 1179 1180
                out = exe.run(
                    fluid.default_main_program(),
                    feed={
                        "x": x_data,
                        "y": y_data,
                        "init_hidden": init_hidden_data,
                        "init_cell": init_cell_data,
                    },
                    fetch_list=fetch_list,
                )
1181 1182 1183 1184 1185 1186 1187 1188 1189
                static_loss_value = out[0]
                static_last_hidden_value = out[1]
                static_last_cell_value = out[2]

            # get value before save
            main_program = framework.default_main_program()
            base_map = {}
            for var in main_program.list_vars():
                if isinstance(var, framework.Parameter) or var.persistable:
1190 1191 1192
                    t = np.array(
                        fluid.global_scope().find_var(var.name).get_tensor()
                    )
1193 1194 1195 1196
                    # make sure all the paramerter or optimizer var have been update
                    self.assertTrue(np.sum(np.abs(t)) != 0)
                    base_map[var.name] = t

1197
            # fluid.save(main_program, "./test_1")
1198
            paddle.distributed.io.save_persistables(
1199 1200
                exe,
                os.path.join(self.temp_dir.name, "test_static_load_var_list"),
1201 1202
                main_program,
            )
1203

1204
            # set var to zero
1205 1206 1207 1208 1209 1210 1211 1212
            var_list = []
            for i, var in enumerate(main_program.list_vars()):
                if isinstance(var, framework.Parameter) or var.persistable:
                    if i % 2 == 0:
                        var_list.append(var)
                    ten = fluid.global_scope().find_var(var.name).get_tensor()
                    ten.set(np.zeros_like(np.array(ten)), place)

1213 1214 1215
                    new_t = np.array(
                        fluid.global_scope().find_var(var.name).get_tensor()
                    )
1216 1217 1218
                    # make sure all the paramerter or optimizer var have been set to zero
                    self.assertTrue(np.sum(np.abs(new_t)) == 0)

1219 1220 1221
            fluid.load(
                main_program,
                os.path.join(self.temp_dir.name, "test_static_load_var_list"),
1222 1223 1224
                exe,
                var_list,
            )
1225 1226 1227
            var_list_names = [var.name for var in var_list]
            for var in main_program.list_vars():
                if isinstance(var, framework.Parameter) or var.persistable:
1228 1229 1230
                    new_t = np.array(
                        fluid.global_scope().find_var(var.name).get_tensor()
                    )
1231 1232 1233
                    if var.name in var_list_names:
                        # loaded vars
                        base_t = base_map[var.name]
1234
                        np.testing.assert_array_equal(new_t, base_t)
1235
                    else:
1236
                        # not loaded vars
1237 1238
                        self.assertTrue(np.sum(np.abs(new_t)) == 0)

H
hong 已提交
1239 1240

class TestLoadFromOldInterfaceSingleFile(unittest.TestCase):
1241
    def set_place(self):
1242 1243 1244 1245 1246
        return (
            fluid.CPUPlace()
            if not core.is_compiled_with_cuda()
            else fluid.CUDAPlace(0)
        )
1247

H
hong 已提交
1248 1249 1250 1251 1252 1253 1254 1255 1256
    def test_load_from_old_interface(self):
        seed = 90
        hidden_size = 10
        vocab_size = 1000
        num_layers = 1
        num_steps = 3
        init_scale = 0.1
        batch_size = 4
        batch_num = 200
1257
        temp_dir = tempfile.TemporaryDirectory()
H
hong 已提交
1258 1259 1260 1261

        with new_program_scope():
            fluid.default_startup_program().random_seed = seed
            fluid.default_main_program().random_seed = seed
1262 1263 1264 1265 1266 1267 1268 1269
            ptb_model = PtbModel(
                "ptb_model",
                hidden_size=hidden_size,
                vocab_size=vocab_size,
                num_layers=num_layers,
                num_steps=num_steps,
                init_scale=init_scale,
            )
H
hong 已提交
1270

1271
            place = self.set_place()
H
hong 已提交
1272 1273
            exe = fluid.Executor(place)
            sgd = Adam(learning_rate=1e-3)
1274 1275 1276
            x = fluid.layers.data(
                name="x", shape=[-1, num_steps], dtype='int64'
            )
H
hong 已提交
1277
            y = fluid.layers.data(name="y", shape=[-1, 1], dtype='float32')
1278 1279 1280 1281 1282 1283
            init_hidden = fluid.layers.data(
                name="init_hidden", shape=[1], dtype='float32'
            )
            init_cell = fluid.layers.data(
                name="init_cell", shape=[1], dtype='float32'
            )
H
hong 已提交
1284 1285

            static_loss, static_last_hidden, static_last_cell = ptb_model(
1286 1287
                x, y, init_hidden, init_cell
            )
H
hong 已提交
1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302
            sgd.minimize(static_loss)
            static_param_updated = dict()
            static_param_init = dict()

            out = exe.run(framework.default_startup_program())

            static_loss_value = None
            static_last_cell_value = None
            static_last_hidden_value = None
            for i in range(batch_num):
                x_data = np.arange(12).reshape(4, 3).astype('int64')
                y_data = np.arange(1, 13).reshape(4, 3).astype('int64')
                x_data = x_data.reshape((-1, num_steps, 1))
                y_data = y_data.reshape((-1, 1))
                init_hidden_data = np.zeros(
1303 1304 1305 1306 1307
                    (num_layers, batch_size, hidden_size), dtype='float32'
                )
                init_cell_data = np.zeros(
                    (num_layers, batch_size, hidden_size), dtype='float32'
                )
H
hong 已提交
1308
                fetch_list = [static_loss, static_last_hidden, static_last_cell]
1309 1310 1311 1312 1313 1314 1315 1316 1317 1318
                out = exe.run(
                    fluid.default_main_program(),
                    feed={
                        "x": x_data,
                        "y": y_data,
                        "init_hidden": init_hidden_data,
                        "init_cell": init_cell_data,
                    },
                    fetch_list=fetch_list,
                )
H
hong 已提交
1319 1320 1321 1322 1323 1324 1325 1326 1327
                static_loss_value = out[0]
                static_last_hidden_value = out[1]
                static_last_cell_value = out[2]

            # get value before save
            main_program = framework.default_main_program()
            base_map = {}
            for var in main_program.list_vars():
                if isinstance(var, framework.Parameter) or var.persistable:
1328 1329 1330
                    t = np.array(
                        fluid.global_scope().find_var(var.name).get_tensor()
                    )
T
tianshuo78520a 已提交
1331
                    # make sure all the paramerter or optimizer var have been update
H
hong 已提交
1332 1333
                    self.assertTrue(np.sum(np.abs(t)) != 0)
                    base_map[var.name] = t
1334
            save_dir = os.path.join(temp_dir.name, "test_path")
1335
            # fluid.save(main_program, "./test_1")
1336
            paddle.distributed.io.save_persistables(
1337 1338
                exe, save_dir, main_program, filename="model_single"
            )
H
hong 已提交
1339 1340 1341 1342 1343 1344 1345

            # set var to zero
            for var in main_program.list_vars():
                if isinstance(var, framework.Parameter) or var.persistable:
                    ten = fluid.global_scope().find_var(var.name).get_tensor()
                    ten.set(np.zeros_like(np.array(ten)), place)

1346 1347 1348
                    new_t = np.array(
                        fluid.global_scope().find_var(var.name).get_tensor()
                    )
T
tianshuo78520a 已提交
1349
                    # make sure all the paramerter or optimizer var have been set to zero
H
hong 已提交
1350 1351
                    self.assertTrue(np.sum(np.abs(new_t)) == 0)

1352
            file_model_path = os.path.join(save_dir, "model_single")
1353 1354 1355 1356 1357 1358
            fluid.load(
                main_program,
                file_model_path,
                exe,
                fluid.io.get_program_persistable_vars(main_program),
            )
H
hong 已提交
1359 1360 1361

            for var in main_program.list_vars():
                if isinstance(var, framework.Parameter) or var.persistable:
1362 1363 1364
                    new_t = np.array(
                        fluid.global_scope().find_var(var.name).get_tensor()
                    )
H
hong 已提交
1365
                    base_t = base_map[var.name]
1366
                    np.testing.assert_array_equal(new_t, base_t)
H
hong 已提交
1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378

            # test exception
            # change shape
            for var in main_program.list_vars():
                if isinstance(var, framework.Parameter) or var.persistable:
                    ten = fluid.global_scope().find_var(var.name).get_tensor()
                    old_shape = np.array(ten).shape
                    new_shape = [e + 10 for e in old_shape]

                    var.desc.set_shape(new_shape)

            with self.assertRaises(RuntimeError):
1379 1380 1381 1382 1383 1384 1385 1386 1387 1388
                fluid.load(
                    main_program,
                    file_model_path,
                    exe,
                    fluid.io.get_program_persistable_vars(main_program),
                )

            fluid.io.save_params(
                exe, "test_path", main_program, filename="model_single"
            )
H
hong 已提交
1389
            with self.assertRaises(RuntimeError):
1390 1391 1392 1393 1394 1395
                fluid.load(
                    main_program,
                    file_model_path,
                    exe,
                    fluid.io.get_program_persistable_vars(main_program),
                )
H
hong 已提交
1396 1397 1398

            # check when executor is None
            with self.assertRaises(ValueError):
1399 1400 1401 1402 1403 1404
                fluid.load(
                    main_program,
                    file_model_path,
                    None,
                    fluid.io.get_program_persistable_vars(main_program),
                )
H
hong 已提交
1405 1406 1407 1408 1409 1410 1411

            # check when var list is None
            with self.assertRaises(ValueError):
                fluid.load(main_program, file_model_path, exe, None)

            # check save params, load var_list = get_program_persistable_vars
            with self.assertRaises(RuntimeError):
1412 1413 1414
                temp_var = framework.Variable(
                    main_program.global_block(), shape=[1], name="test_temp_var"
                )
H
hong 已提交
1415
                all_var_list = list(main_program.list_vars())
1416 1417 1418 1419 1420 1421
                fluid.load(
                    main_program,
                    file_model_path,
                    exe,
                    all_var_list + [temp_var],
                )
1422
        temp_dir.cleanup()
H
hong 已提交
1423 1424


H
hong 已提交
1425
class TestProgramStateOldSave(unittest.TestCase):
1426 1427
    def setUp(self):
        self.test_dygraph = True
1428 1429 1430 1431
        self.temp_dir = tempfile.TemporaryDirectory()

    def tearDown(self):
        self.temp_dir.cleanup()
1432 1433

    def set_place(self):
1434 1435 1436 1437 1438
        return (
            fluid.CPUPlace()
            if not core.is_compiled_with_cuda()
            else fluid.CUDAPlace(0)
        )
1439

H
hong 已提交
1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452
    def test_ptb_rnn_cpu_float32(self):
        seed = 90
        hidden_size = 10
        vocab_size = 1000
        num_layers = 1
        num_steps = 3
        init_scale = 0.1
        batch_size = 4
        batch_num = 200

        with new_program_scope():
            fluid.default_startup_program().random_seed = seed
            fluid.default_main_program().random_seed = seed
1453 1454 1455 1456 1457 1458 1459 1460
            ptb_model = PtbModel(
                "ptb_model",
                hidden_size=hidden_size,
                vocab_size=vocab_size,
                num_layers=num_layers,
                num_steps=num_steps,
                init_scale=init_scale,
            )
H
hong 已提交
1461

1462
            place = self.set_place()
H
hong 已提交
1463 1464
            exe = fluid.Executor(place)
            sgd = Adam(learning_rate=1e-3)
1465 1466 1467
            x = fluid.layers.data(
                name="x", shape=[-1, num_steps], dtype='int64'
            )
H
hong 已提交
1468
            y = fluid.layers.data(name="y", shape=[-1, 1], dtype='float32')
1469 1470 1471 1472 1473 1474
            init_hidden = fluid.layers.data(
                name="init_hidden", shape=[1], dtype='float32'
            )
            init_cell = fluid.layers.data(
                name="init_cell", shape=[1], dtype='float32'
            )
H
hong 已提交
1475 1476

            static_loss, static_last_hidden, static_last_cell = ptb_model(
1477 1478
                x, y, init_hidden, init_cell
            )
H
hong 已提交
1479 1480 1481

            test_program = fluid.default_main_program().clone(for_test=True)

1482 1483 1484 1485 1486 1487
            add_1 = fluid.layers.fc(
                static_last_hidden,
                size=hidden_size,
                num_flatten_dims=2,
                bias_attr=False,
            )
H
hong 已提交
1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503

            sgd.minimize(static_loss)
            static_param_updated = dict()
            static_param_init = dict()

            out = exe.run(framework.default_startup_program())

            static_loss_value = None
            static_last_cell_value = None
            static_last_hidden_value = None
            for i in range(batch_num):
                x_data = np.arange(12).reshape(4, 3).astype('int64')
                y_data = np.arange(1, 13).reshape(4, 3).astype('int64')
                x_data = x_data.reshape((-1, num_steps, 1))
                y_data = y_data.reshape((-1, 1))
                init_hidden_data = np.zeros(
1504 1505 1506 1507 1508
                    (num_layers, batch_size, hidden_size), dtype='float32'
                )
                init_cell_data = np.zeros(
                    (num_layers, batch_size, hidden_size), dtype='float32'
                )
H
hong 已提交
1509
                fetch_list = [static_loss, static_last_hidden, static_last_cell]
1510 1511 1512 1513 1514 1515 1516 1517 1518 1519
                out = exe.run(
                    fluid.default_main_program(),
                    feed={
                        "x": x_data,
                        "y": y_data,
                        "init_hidden": init_hidden_data,
                        "init_cell": init_cell_data,
                    },
                    fetch_list=fetch_list,
                )
H
hong 已提交
1520 1521 1522 1523 1524 1525 1526 1527 1528
                static_loss_value = out[0]
                static_last_hidden_value = out[1]
                static_last_cell_value = out[2]

            # get value before save
            main_program = framework.default_main_program()
            base_map = {}
            for var in main_program.list_vars():
                if isinstance(var, framework.Parameter) or var.persistable:
1529 1530 1531
                    t = np.array(
                        fluid.global_scope().find_var(var.name).get_tensor()
                    )
T
tianshuo78520a 已提交
1532
                    # make sure all the paramerter or optimizer var have been update
H
hong 已提交
1533 1534
                    self.assertTrue(np.sum(np.abs(t)) != 0)
                    base_map[var.name] = t
1535
            save_dir = os.path.join(self.temp_dir.name, "test_program_1")
1536
            paddle.distributed.io.save_persistables(exe, save_dir, main_program)
H
hong 已提交
1537 1538 1539 1540 1541 1542 1543

            # set var to zero
            for var in main_program.list_vars():
                if isinstance(var, framework.Parameter) or var.persistable:
                    ten = fluid.global_scope().find_var(var.name).get_tensor()
                    ten.set(np.zeros_like(np.array(ten)), place)

1544 1545 1546
                    new_t = np.array(
                        fluid.global_scope().find_var(var.name).get_tensor()
                    )
T
tianshuo78520a 已提交
1547
                    # make sure all the paramerter or optimizer var have been set to zero
H
hong 已提交
1548 1549
                    self.assertTrue(np.sum(np.abs(new_t)) == 0)

1550
            # case 1: load basic
1551
            program_state = fluid.load_program_state(save_dir)
H
hong 已提交
1552
            fluid.set_program_state(main_program, program_state)
1553 1554 1555
            self.check_in_static(main_program, base_map)

            # case 2: load with no need file
1556 1557
            def symlink_force(target, link_name):
                try:
1558
                    self.create_symlink(target, link_name)
1559 1560 1561
                except OSError as e:
                    if e.errno == errno.EEXIST:
                        os.remove(link_name)
1562
                        self.create_symlink(target, link_name)
1563 1564 1565
                    else:
                        raise e

1566
            program_state = fluid.load_program_state(save_dir)
1567 1568
            fluid.set_program_state(main_program, program_state)
            self.check_in_static(main_program, base_map)
H
hong 已提交
1569

1570 1571
            # case 3: load with var_list
            program_state = fluid.load_program_state(
1572 1573
                save_dir, main_program.all_parameters()
            )
1574 1575
            fluid.set_program_state(main_program, program_state)
            self.check_in_static(main_program, base_map)
H
hong 已提交
1576

1577 1578 1579
        if self.test_dygraph:
            # make sure `load_program_state` can be used in dynamic graph mode
            with fluid.dygraph.guard(place):
1580
                load_state = fluid.load_program_state(save_dir)
1581
                for k, v in load_state.items():
1582
                    np.testing.assert_array_equal(base_map[k], v)
1583

1584 1585 1586 1587 1588
    def create_symlink(self, target, link_name):
        try:
            os.symlink(target, link_name)
        except AttributeError:
            import ctypes
1589

1590 1591 1592
            kernel_dll = ctypes.windll.LoadLibrary("kernel32.dll")
            kernel_dll.CreateSymbolicLinkA(target, link_name, 0)

1593 1594 1595
    def check_in_static(self, main_program, base_map):
        for var in main_program.list_vars():
            if isinstance(var, framework.Parameter) or var.persistable:
1596 1597 1598
                new_t = np.array(
                    fluid.global_scope().find_var(var.name).get_tensor()
                )
1599
                base_t = base_map[var.name]
1600
                np.testing.assert_array_equal(new_t, base_t)
1601

H
hong 已提交
1602 1603

class TestProgramStateOldSaveSingleModel(unittest.TestCase):
1604
    def set_place(self):
1605 1606 1607 1608 1609
        return (
            fluid.CPUPlace()
            if not core.is_compiled_with_cuda()
            else fluid.CUDAPlace(0)
        )
1610

H
hong 已提交
1611 1612 1613 1614 1615 1616 1617 1618 1619
    def test_ptb_rnn_cpu_float32(self):
        seed = 90
        hidden_size = 10
        vocab_size = 1000
        num_layers = 1
        num_steps = 3
        init_scale = 0.1
        batch_size = 4
        batch_num = 200
1620
        temp_dir = tempfile.TemporaryDirectory()
H
hong 已提交
1621 1622 1623 1624

        with new_program_scope():
            fluid.default_startup_program().random_seed = seed
            fluid.default_main_program().random_seed = seed
1625 1626 1627 1628 1629 1630 1631 1632
            ptb_model = PtbModel(
                "ptb_model",
                hidden_size=hidden_size,
                vocab_size=vocab_size,
                num_layers=num_layers,
                num_steps=num_steps,
                init_scale=init_scale,
            )
H
hong 已提交
1633

1634
            place = self.set_place()
H
hong 已提交
1635 1636
            exe = fluid.Executor(place)
            sgd = Adam(learning_rate=1e-3)
1637 1638 1639
            x = fluid.layers.data(
                name="x", shape=[-1, num_steps], dtype='int64'
            )
H
hong 已提交
1640
            y = fluid.layers.data(name="y", shape=[-1, 1], dtype='float32')
1641 1642 1643 1644 1645 1646
            init_hidden = fluid.layers.data(
                name="init_hidden", shape=[1], dtype='float32'
            )
            init_cell = fluid.layers.data(
                name="init_cell", shape=[1], dtype='float32'
            )
H
hong 已提交
1647 1648

            static_loss, static_last_hidden, static_last_cell = ptb_model(
1649 1650
                x, y, init_hidden, init_cell
            )
H
hong 已提交
1651 1652 1653

            test_program = fluid.default_main_program().clone(for_test=True)

1654 1655 1656 1657 1658 1659
            add_1 = fluid.layers.fc(
                static_last_hidden,
                size=hidden_size,
                num_flatten_dims=2,
                bias_attr=False,
            )
H
hong 已提交
1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675

            sgd.minimize(static_loss)
            static_param_updated = dict()
            static_param_init = dict()

            out = exe.run(framework.default_startup_program())

            static_loss_value = None
            static_last_cell_value = None
            static_last_hidden_value = None
            for i in range(batch_num):
                x_data = np.arange(12).reshape(4, 3).astype('int64')
                y_data = np.arange(1, 13).reshape(4, 3).astype('int64')
                x_data = x_data.reshape((-1, num_steps, 1))
                y_data = y_data.reshape((-1, 1))
                init_hidden_data = np.zeros(
1676 1677 1678 1679 1680
                    (num_layers, batch_size, hidden_size), dtype='float32'
                )
                init_cell_data = np.zeros(
                    (num_layers, batch_size, hidden_size), dtype='float32'
                )
H
hong 已提交
1681
                fetch_list = [static_loss, static_last_hidden, static_last_cell]
1682 1683 1684 1685 1686 1687 1688 1689 1690 1691
                out = exe.run(
                    fluid.default_main_program(),
                    feed={
                        "x": x_data,
                        "y": y_data,
                        "init_hidden": init_hidden_data,
                        "init_cell": init_cell_data,
                    },
                    fetch_list=fetch_list,
                )
H
hong 已提交
1692 1693 1694 1695 1696 1697 1698 1699 1700
                static_loss_value = out[0]
                static_last_hidden_value = out[1]
                static_last_cell_value = out[2]

            # get value before save
            main_program = framework.default_main_program()
            base_map = {}
            for var in main_program.list_vars():
                if isinstance(var, framework.Parameter) or var.persistable:
1701 1702 1703
                    t = np.array(
                        fluid.global_scope().find_var(var.name).get_tensor()
                    )
T
tianshuo78520a 已提交
1704
                    # make sure all the paramerter or optimizer var have been update
H
hong 已提交
1705 1706 1707
                    self.assertTrue(np.sum(np.abs(t)) != 0)
                    base_map[var.name] = t

1708
            save_dir = os.path.join(temp_dir.name, "test_program_2")
1709
            paddle.distributed.io.save_persistables(
1710 1711
                exe, save_dir, main_program, filename="model_1"
            )
H
hong 已提交
1712 1713 1714 1715 1716 1717 1718

            # set var to zero
            for var in main_program.list_vars():
                if isinstance(var, framework.Parameter) or var.persistable:
                    ten = fluid.global_scope().find_var(var.name).get_tensor()
                    ten.set(np.zeros_like(np.array(ten)), place)

1719 1720 1721
                    new_t = np.array(
                        fluid.global_scope().find_var(var.name).get_tensor()
                    )
T
tianshuo78520a 已提交
1722
                    # make sure all the paramerter or optimizer var have been set to zero
H
hong 已提交
1723 1724
                    self.assertTrue(np.sum(np.abs(new_t)) == 0)

1725
            # fluid.load(test_program, "./test_1", None )
H
hong 已提交
1726
            program_state = fluid.load_program_state(
1727
                os.path.join(save_dir, "model_1"),
1728 1729
                var_list=fluid.io.get_program_persistable_vars(main_program),
            )
H
hong 已提交
1730 1731 1732 1733
            fluid.set_program_state(main_program, program_state)

            for var in main_program.list_vars():
                if isinstance(var, framework.Parameter) or var.persistable:
1734 1735 1736
                    new_t = np.array(
                        fluid.global_scope().find_var(var.name).get_tensor()
                    )
H
hong 已提交
1737
                    base_t = base_map[var.name]
1738
                    np.testing.assert_array_equal(new_t, base_t)
H
hong 已提交
1739 1740

            with self.assertRaises(ValueError):
1741
                fluid.load_program_state(os.path.join(save_dir, "model_1"))
H
hong 已提交
1742 1743

            with self.assertRaises(TypeError):
1744 1745 1746
                fluid.load_program_state(
                    os.path.join(save_dir, "model_1"), var_list=["str"]
                )
H
hong 已提交
1747 1748 1749

            with self.assertRaises(RuntimeError):
                fluid.load_program_state(
1750
                    os.path.join(save_dir, "model_1"),
H
hong 已提交
1751 1752
                    var_list=[
                        main_program.global_block().create_var(
1753 1754 1755 1756
                            name="fake_var_name", persistable=True
                        )
                    ],
                )
1757
        temp_dir.cleanup()
H
hong 已提交
1758 1759


W
WeiXin 已提交
1760 1761 1762 1763 1764 1765 1766
class TestStaticSaveLoadPickle(unittest.TestCase):
    def test_pickle_protocol(self):
        # enable static mode
        paddle.enable_static()

        with new_program_scope():
            # create network
1767 1768 1769 1770 1771
            x = paddle.static.data(
                name="static_save_load_large_x",
                shape=[None, 10],
                dtype='float32',
            )
W
WeiXin 已提交
1772 1773 1774 1775 1776 1777 1778 1779 1780
            z = paddle.static.nn.fc(x, 10, bias_attr=False)
            place = paddle.CPUPlace()
            exe = paddle.static.Executor(place)
            exe.run(paddle.static.default_startup_program())
            prog = paddle.static.default_main_program()

            base_map = {}
            for var in prog.list_vars():
                if isinstance(var, framework.Parameter) or var.persistable:
1781 1782 1783
                    t = np.array(
                        fluid.global_scope().find_var(var.name).get_tensor()
                    )
W
WeiXin 已提交
1784 1785 1786 1787
                    # make sure all the paramerter or optimizer var have been update
                    self.assertTrue(np.sum(np.abs(t)) != 0)
                    base_map[var.name] = t

1788
            temp_dir = tempfile.TemporaryDirectory()
1789 1790 1791
            path = os.path.join(
                temp_dir.name, "test_static_save_load_pickle", "pickle_protocol"
            )
W
WeiXin 已提交
1792 1793 1794 1795 1796 1797 1798 1799 1800 1801

            with self.assertRaises(ValueError):
                paddle.fluid.save(prog, path, 2.0)

            with self.assertRaises(ValueError):
                paddle.fluid.save(prog, path, 1)

            with self.assertRaises(ValueError):
                paddle.fluid.save(prog, path, 5)

1802
            protocols = [2, 3, 4]
W
WeiXin 已提交
1803 1804 1805 1806 1807
            for protocol in protocols:
                paddle.fluid.save(prog, path, protocol)
                # set var to zero
                for var in prog.list_vars():
                    if isinstance(var, framework.Parameter) or var.persistable:
1808 1809 1810
                        ten = (
                            fluid.global_scope().find_var(var.name).get_tensor()
                        )
W
WeiXin 已提交
1811 1812
                        ten.set(np.zeros_like(np.array(ten)), place)

1813 1814 1815
                        new_t = np.array(
                            fluid.global_scope().find_var(var.name).get_tensor()
                        )
W
WeiXin 已提交
1816 1817 1818 1819 1820 1821
                        self.assertTrue(np.sum(np.abs(new_t)) == 0)

                paddle.fluid.load(prog, path)

                for var in prog.list_vars():
                    if isinstance(var, framework.Parameter) or var.persistable:
1822 1823 1824
                        new_t = np.array(
                            fluid.global_scope().find_var(var.name).get_tensor()
                        )
W
WeiXin 已提交
1825
                        base_t = base_map[var.name]
1826
                        np.testing.assert_array_equal(new_t, base_t)
W
WeiXin 已提交
1827 1828


1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847
class TestSaveLoadInferenceModel(unittest.TestCase):
    def setUp(self):
        self.temp_dir = tempfile.TemporaryDirectory()
        self.model_path = os.path.join(self.temp_dir.name, 'no_params')

    def tearDown(self):
        self.temp_dir.cleanup()

    def test_no_params(self):
        main_program = framework.Program()
        with framework.program_guard(main_program):
            x = paddle.static.data(name="x", shape=[10, 10], dtype='float32')
            y = x + x

            place = paddle.CPUPlace()
            exe = paddle.static.Executor(place)

            paddle.static.save_inference_model(self.model_path, [x], [y], exe)

1848 1849 1850 1851 1852
            [
                inference_program,
                feed_target_names,
                fetch_targets,
            ] = paddle.static.load_inference_model(self.model_path, exe)
1853 1854 1855 1856 1857 1858 1859

            self.assertEqual(feed_target_names, ['x'])
            self.assertEqual(fetch_targets[0].shape, (10, 10))
            ops = [op.type for op in inference_program.block(0).ops]
            self.assertEqual(ops, ['feed', 'elementwise_add', 'scale', 'fetch'])


H
hong 已提交
1860
if __name__ == '__main__':
1861
    paddle.enable_static()
H
hong 已提交
1862
    unittest.main()