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

15 16
from __future__ import print_function

17
import os
T
bug fix  
tangwei12 已提交
18
import errno
D
dzhwinter 已提交
19
import warnings
20
import six
21
import logging
Y
Yang Zhang 已提交
22
import pickle
23
import contextlib
24
from functools import reduce
25

H
hong 已提交
26 27
import numpy as np

28 29 30
import paddle
import paddle.reader
from paddle.reader import *
31
from paddle.fluid import layers
H
hong 已提交
32
from paddle.fluid.executor import Executor, global_scope
33
from paddle.fluid.evaluator import Evaluator
T
tangwei12 已提交
34 35
from paddle.fluid.framework import Program, Parameter, default_main_program, default_startup_program, Variable, \
    program_guard
T
tangwei12 已提交
36
from paddle.fluid.compiler import CompiledProgram
37
from paddle.fluid.log_helper import get_logger
S
sneaxiy 已提交
38
from . import reader
39
from . import unique_name
S
sneaxiy 已提交
40
from .reader import *
K
fix bug  
Kexin Zhao 已提交
41
from . import core
42
from .. import compat as cpt
43

44 45
batch = paddle.batch

46
__all__ = [
47 48 49 50 51 52 53 54 55 56 57 58 59
    'save_vars',
    'save_params',
    'save_persistables',
    'load_vars',
    'load_params',
    'load_persistables',
    'save_inference_model',
    'load_inference_model',
    'batch',
    'save',
    'load',
    'load_program_state',
    'set_program_state',
H
hong 已提交
60 61
    'get_program_parameter',
    'get_program_persistable_vars',
62
] + reader.__all__ + paddle.reader.__all__
63

64 65
_logger = get_logger(
    __name__, logging.INFO, fmt='%(asctime)s-%(levelname)s: %(message)s')
66

67 68

def is_parameter(var):
F
fengjiayi 已提交
69 70
    """
    Check whether the given variable is an instance of Parameter.
71 72

    Args:
F
fengjiayi 已提交
73
        var(Variable): The variable to be checked.
74 75

    Returns:
F
fengjiayi 已提交
76 77 78 79 80 81
        bool: True if the given `var` is an instance of Parameter,
        False if not.

    Examples:
        .. code-block:: python

82
            import paddle.fluid as fluid
F
fengjiayi 已提交
83 84
            param = fluid.default_main_program().global_block().var('fc.w')
            res = fluid.io.is_parameter(param)
85
    """
86 87 88 89
    return isinstance(var, Parameter)


def is_persistable(var):
F
fengjiayi 已提交
90 91 92 93 94 95 96 97 98 99 100 101 102
    """
    Check whether the given variable is persistable.

    Args:
        var(Variable): The variable to be checked.

    Returns:
        bool: True if the given `var` is persistable
        False if not.

    Examples:
        .. code-block:: python

103
            import paddle.fluid as fluid
104
            param = fluid.default_main_program().global_block().var('fc.b')
F
fengjiayi 已提交
105 106
            res = fluid.io.is_persistable(param)
    """
107
    if var.desc.type() == core.VarDesc.VarType.FEED_MINIBATCH or \
Y
yuyang18 已提交
108 109
            var.desc.type() == core.VarDesc.VarType.FETCH_LIST or \
            var.desc.type() == core.VarDesc.VarType.READER:
110
        return False
111 112 113
    return var.persistable


H
hong 已提交
114
def is_belong_to_optimizer(var):
115
    if not (isinstance(var, Parameter) or var.desc.need_check_feed()):
116 117 118
        return is_persistable(var)

    return False
H
hong 已提交
119 120


H
hong 已提交
121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164
def get_program_parameter(program):
    """
    Get all the parameters from Program.

    Args:
        var(Program): The Program to get parameters

    Returns:
        list: The list contains all parameters in the program

    Examples:
        .. code-block:: python

            import paddle.fluid as fluid
            data = fluid.data(name="img", shape=[64, 784])
            w = fluid.layers.create_parameter(shape=[784, 200], dtype='float32', name='fc_w')
            b = fluid.layers.create_parameter(shape=[200], dtype='float32', name='fc_b')
            list_para  = fluid.io.get_program_parameter(  fluid.default_main_program() )
    """
    return list(filter(is_parameter, program.list_vars()))


def get_program_persistable_vars(program):
    """
    Get all the persistable vars from Program.

    Args:
        var(Program): The Program to get persistable vars

    Returns:
        list: The list contains all persistable vars in the program

    Examples:
        .. code-block:: python

            import paddle.fluid as fluid
            data = fluid.data(name="img", shape=[64, 784])
            w = fluid.layers.create_parameter(shape=[784, 200], dtype='float32', name='fc_w')
            b = fluid.layers.create_parameter(shape=[200], dtype='float32', name='fc_b')
            list_para  = fluid.io.get_program_persistable_vars(  fluid.default_main_program() )
    """
    return list(filter(is_persistable, program.list_vars()))


165 166
def _clone_var_in_block_(block, var):
    assert isinstance(var, Variable)
167 168 169 170 171 172 173 174 175 176 177 178 179 180 181
    if var.desc.type() == core.VarDesc.VarType.LOD_TENSOR:
        return block.create_var(
            name=var.name,
            shape=var.shape,
            dtype=var.dtype,
            type=var.type,
            lod_level=var.lod_level,
            persistable=True)
    else:
        return block.create_var(
            name=var.name,
            shape=var.shape,
            dtype=var.dtype,
            type=var.type,
            persistable=True)
182 183


184 185 186 187 188 189 190 191 192 193 194
@contextlib.contextmanager
def _load_program_scope(main=None, startup=None, scope=None):
    prog = main if main else paddle.fluid.Program()
    startup_prog = startup if startup else paddle.fluid.Program()
    scope = scope if scope else paddle.fluid.core.Scope()
    with paddle.fluid.scope_guard(scope):
        with paddle.fluid.program_guard(prog, startup_prog):
            with paddle.fluid.unique_name.guard():
                yield


C
chengduo 已提交
195 196 197 198 199 200 201 202 203 204 205 206 207 208
def _get_valid_program(main_program):
    if main_program is None:
        main_program = default_main_program()
    elif isinstance(main_program, CompiledProgram):
        main_program = main_program._program
        if main_program is None:
            raise TypeError("program should be as Program type or None")
        warnings.warn(
            "The input is a CompiledProgram, this is not recommended.")
    if not isinstance(main_program, Program):
        raise TypeError("program should be as Program type or None")
    return main_program


209 210 211 212 213
def save_vars(executor,
              dirname,
              main_program=None,
              vars=None,
              predicate=None,
214
              filename=None):
215
    """
216
    This API saves specific variables in the `Program` to files.
F
fengjiayi 已提交
217

218 219 220
    There are two ways to specify the variables to be saved: set variables in 
    a list and assign it to the `vars`, or use the `predicate` function to select
    variables that make `predicate(variable) == True`. The first way has a higher priority.
221

222 223 224
    The `dirname` is used to specify the folder where to save variables.
    If you prefer to save variables in separate files in the `dirname` floder,
    do not set `filename`. If you prefer to save all variables in a single file,
F
fengjiayi 已提交
225
    use `filename` to specify it.
226

F
fengjiayi 已提交
227 228
    Args:
        executor(Executor): The executor to run for saving variables.
229 230
        dirname(str, optional): The folder where to save variables.
                            When you need to save the parameter to the memory, set it to None.
231
        main_program(Program, optional): The program whose variables will be saved.
232
                                    If it is None, the default main program will
F
fengjiayi 已提交
233 234
                                    be used automatically.
                                    Default: None
235 236 237 238 239 240 241 242
        vars(list[Variable], optional): The list contains all variables to be saved.
                                        Default: None
        predicate(function, optional): The function selects the variables that make
                                       `predicate(variable) == True`. 
                                       Default: None
        filename(str, optional): If you prefer to save all variables in a single file,
                                 use `filename` to specify it. Otherwise, let `filename` be None. 
                                 Default: None
F
fengjiayi 已提交
243 244

    Returns:
245 246
        str: When saving parameters to a file, returns None.
             When saving parameters to memory, returns a binary string containing parameters.
F
fengjiayi 已提交
247 248 249 250 251 252 253

    Raises:
        TypeError: If `main_program` is not an instance of Program nor None.

    Examples:
        .. code-block:: python

254
            import paddle.fluid as fluid
255

256 257 258 259 260 261 262 263 264 265 266
            main_prog = fluid.Program()
            startup_prog = fluid.Program()
            with fluid.program_guard(main_prog, startup_prog):
                data = fluid.layers.data(name="img", shape=[64, 784], append_batch_size=False)
                w = fluid.layers.create_parameter(shape=[784, 200], dtype='float32', name='fc_w')
                b = fluid.layers.create_parameter(shape=[200], dtype='float32', name='fc_b')
                hidden_w = fluid.layers.matmul(x=data, y=w)
                hidden_b = fluid.layers.elementwise_add(hidden_w, b)
            place = fluid.CPUPlace()
            exe = fluid.Executor(place)
            exe.run(startup_prog)
F
fengjiayi 已提交
267

268
            # The first usage: use `vars` to set the saved variables.
269 270
            var_list = [w, b]
            path = "./my_paddle_vars"
271
            fluid.io.save_vars(executor=exe, dirname=path, vars=var_list,
272 273 274 275 276 277 278 279 280 281
                            filename="vars_file")
            # w and b will be save in a file named "var_file".

            # The second usage: use `predicate` to select the saved variable.
            def name_has_fc(var):
                res = "fc" in var.name
                return res
            param_path = "./my_paddle_model"
            fluid.io.save_vars(executor=exe, dirname=param_path, main_program=main_prog, vars=None, predicate = name_has_fc)
            # all variables whose names contain "fc " are saved.
282
    """
283 284 285 286
    save_to_memory = False
    if dirname is None and filename is None:
        save_to_memory = True

C
chengduo 已提交
287
    main_program = _get_valid_program(main_program)
T
tangwei12 已提交
288

289
    if vars is None:
290
        return save_vars(
291
            executor,
292
            main_program=main_program,
293
            dirname=dirname,
294
            vars=list(filter(predicate, main_program.list_vars())),
295
            filename=filename)
296
    else:
297
        params_var_name = unique_name.generate("saved_params")
298 299 300 301 302 303 304
        # give warning when there is no var in model
        if len(list(vars)) == 0:
            warnings.warn(
                "no variable in your model, please ensure there are any variables in your model to save"
            )
            return None

305 306
        save_program = Program()
        save_block = save_program.global_block()
307 308

        save_var_map = {}
309
        for each_var in vars:
310 311 312
            # NOTE: don't save the variable which type is RAW
            if each_var.type == core.VarDesc.VarType.RAW:
                continue
313
            new_var = _clone_var_in_block_(save_block, each_var)
314 315 316
            if filename is None and save_to_memory is False:
                save_file_path = os.path.join(
                    os.path.normpath(dirname), new_var.name)
317 318 319 320
                save_block.append_op(
                    type='save',
                    inputs={'X': [new_var]},
                    outputs={},
321
                    attrs={'file_path': os.path.normpath(save_file_path)})
322 323 324
            else:
                save_var_map[new_var.name] = new_var

325
        if filename is not None or save_to_memory:
326 327 328 329
            save_var_list = []
            for name in sorted(save_var_map.keys()):
                save_var_list.append(save_var_map[name])

330 331 332 333 334 335 336
            save_path = str()
            if save_to_memory is False:
                save_path = os.path.join(os.path.normpath(dirname), filename)

            saved_params = save_block.create_var(
                type=core.VarDesc.VarType.RAW, name=params_var_name)
            saved_params.desc.set_persistable(True)
337
            save_block.append_op(
338 339
                type='save_combine',
                inputs={'X': save_var_list},
340 341 342 343 344
                outputs={'Y': saved_params},
                attrs={
                    'file_path': save_path,
                    'save_to_memory': save_to_memory
                })
345

346 347 348 349
        #NOTE(zhiqiu): save op will add variable kLookupTablePath in save_program.desc,
        # which leads to diff on save_program and its desc. Call _sync_with_cpp
        # to keep consistency.
        save_program._sync_with_cpp()
350
        executor.run(save_program)
351 352
        if save_to_memory:
            return global_scope().find_var(params_var_name).get_bytes()
353 354


355
def save_params(executor, dirname, main_program=None, filename=None):
356
    """
G
guofei 已提交
357 358 359
    This operator saves all parameters from the :code:`main_program` to
    the folder :code:`dirname` or file :code:`filename`. You can refer to 
    :ref:`api_guide_model_save_reader_en` for more details.
F
fengjiayi 已提交
360

G
guofei 已提交
361 362 363
    Use the :code:`dirname` to specify the saving folder. If you would like to
    save parameters in separate files, set :code:`filename` None; if you would
    like to save all parameters in a single file, use :code:`filename` to specify
F
fengjiayi 已提交
364 365
    the file name.

G
guofei 已提交
366 367 368 369 370 371 372 373 374 375
    Note: 
        Some variables are not Parameter while they are necessary for
        training, such as learning rate, global step, etc. So you can NOT save 
        and continue your training just by :ref:`api_fluid_io_save_params`
        and :ref:`api_fluid_io_load_params`. Please use :ref:`api_fluid_io_save_persistables`
        and :ref:`api_fluid_io_load_persistables` instead. 
        
        If you want to save your model for the inference, please use the 
        :ref:`api_fluid_io_save_inference_model`. You can refer to
        :ref:`api_guide_model_save_reader_en` for more details.
F
fengjiayi 已提交
376 377

    Args:
G
guofei 已提交
378 379
        executor(Executor): The executor to run for saving parameters, You can 
                            refer to :ref:`api_guide_executor_en`.
380 381
        dirname(str, optional): The saving directory path.
                            When you need to save the parameter to the memory, set it to None.
G
guofei 已提交
382 383 384 385 386 387 388 389 390 391
        main_program(Program, optional): The program whose parameters will be
                                         saved. You can refer to 
                                         :ref:`api_guide_Program_en` for more 
                                         details. If it is None, the default main
                                         program will be used.
                                         Default: None
        filename(str, optional): The file to save all parameters. If you prefer
                                 to save parameters in different files, set it
                                 to None.
                                 Default: None
F
fengjiayi 已提交
392 393

    Returns:
394 395
        str: When saving parameters to a file, returns None.
             When saving parameters to memory, returns a binary string containing parameters.
F
fengjiayi 已提交
396 397 398 399

    Examples:
        .. code-block:: python

H
Huihuang Zheng 已提交
400
            import paddle.fluid as fluid
G
guofei 已提交
401 402 403 404 405 406 407 408 409 410
           
            params_path = "./my_paddle_model"
            image = fluid.data(name='img', shape=[None, 28, 28], dtype='float32')
            label = fluid.data(name='label', shape=[None, 1], dtype='int64')
            feeder = fluid.DataFeeder(feed_list=[image, label], place=fluid.CPUPlace())
            predict = fluid.layers.fc(input=image, size=10, act='softmax')
    
            loss = fluid.layers.cross_entropy(input=predict, label=label)
            avg_loss = fluid.layers.mean(loss)
            
F
fengjiayi 已提交
411
            exe = fluid.Executor(fluid.CPUPlace())
G
guofei 已提交
412 413 414 415
            exe.run(fluid.default_startup_program())
            fluid.io.save_params(executor=exe, dirname=params_path)
            # The parameters weights and bias of the fc layer in the network are going to 
            # be saved in different files in the path "./my_paddle_model" 
416
    """
417
    return save_vars(
418 419
        executor,
        dirname=dirname,
420
        main_program=main_program,
421
        vars=None,
422
        predicate=is_parameter,
423
        filename=filename)
424 425


426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447
def _save_distributed_persistables(executor, dirname, main_program):
    """
    save_persistables for distributed training.
    the method will do things listed below:
    1.save part of persistable variables on trainer.
    2.receive "remote prefetch variables" from parameter servers and merge them.
    3.save "distributed lookup table" on parameter servers.
    4.receive "optimizer variables" from parameter servers and merge them.

    Args:
        executor(Executor): The executor to run for saving parameters.
        dirname(str): The saving directory path.
        main_program(Program): The program whose parameters will be
                            saved. the main_program must be the trainer_program
                            get after transpiler.

    Returns:
        None

    Examples:
        .. code-block:: python

448
            import paddle.fluid as fluid
449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469
            exe = fluid.Executor(fluid.CPUPlace())
            param_path = "./my_paddle_model"
            t = distribute_transpiler.DistributeTranspiler()
            t.transpile(...)
            train_program = t.get_trainer_program()
            _save_distributed_persistables(executor=exe, dirname=param_path, main_program=train_program)
    """

    def __save_remote_params(executor, dirname, remote_params_map):
        """
        recive params on pserver through rpc.
        if the params are be sliced, will concat them to one, then save it.
        """
        if not remote_params_map:
            return

        prog = Program()
        block = prog.global_block()

        # recv optimize vars from pserver
        for name, remote_params in remote_params_map.items():
T
tangwei12 已提交
470 471 472 473 474 475 476
            origin = remote_params[0].origin
            is_slice = remote_params[0].is_slice

            slices = [None] * len(remote_params)
            slice_varnames = [None] * len(remote_params)
            remote_varnames = [None] * len(remote_params)
            endpoints = [None] * len(remote_params)
477 478 479

            for idx, optimizer in enumerate(remote_params):
                block_id = optimizer.block_id
T
tangwei12 已提交
480
                slice = optimizer.slice
481 482 483
                endpoint = optimizer.endpoint

                index = block_id if is_slice else idx
T
tangwei12 已提交
484 485 486
                slices[index] = slice
                slice_varnames[index] = "{}.slice.{}".format(slice.name, idx)
                remote_varnames[index] = slice.name
487 488
                endpoints[index] = endpoint

T
tangwei12 已提交
489 490 491 492 493
            slice_shapes = []
            for slice in slices:
                tmp = [str(dim) for dim in slice.shape]
                slice_shapes.append(",".join(tmp))

494
            block.append_op(
T
tangwei12 已提交
495 496 497 498 499 500 501 502 503 504 505
                type='recv_save',
                attrs={
                    "trainer_id": 0,
                    "shape": origin.shape,
                    "slice_shapes": slice_shapes,
                    "slice_varnames": slice_varnames,
                    "remote_varnames": remote_varnames,
                    "endpoints": endpoints,
                    "file_path": os.path.join(dirname, origin.name)
                })

506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534
        executor.run(prog)

    def __save_distributed_lookup_tables(executor, dirname,
                                         distributed_lookup_table, endpoints):
        """
        because the distributed lookup table may too huge to merge and save at one place,
        it will be saved at parameter server independent respectively.

        the save directory is dirname/"__lookup_table__".

        """
        prog = Program()
        block = prog.global_block()

        # if there is lookup table, the trainer 0 will notify all pserver to save.
        lookup_table_filename = os.path.join(dirname, "__lookup_table__")
        attrs = {}
        attrs['epmap'] = endpoints
        attrs['dir'] = lookup_table_filename
        attrs['lookup_table'] = distributed_lookup_table
        block.append_op(
            type='checkpoint_notify', inputs={}, outputs={}, attrs=attrs)
        executor.run(prog)

    def __exclude_vars(exclude_var_names=[]):
        def is_valid(var):
            if var.name in exclude_var_names:
                return False
            if var.desc.type() == core.VarDesc.VarType.FEED_MINIBATCH or \
T
tangwei12 已提交
535 536
                    var.desc.type() == core.VarDesc.VarType.FETCH_LIST or \
                    var.desc.type() == core.VarDesc.VarType.READER:
537 538 539 540 541 542
                return False
            return var.persistable

        return is_valid

    if not isinstance(main_program, Program):
T
tangwei12 已提交
543
        raise TypeError("'main_program' should be an instance of Program.")
544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576

    if not main_program._is_distributed:
        raise ValueError(
            "'_save_distributed_persistables' just be designed for distributed training."
        )

    remote_params_map = main_program._parameters_on_pservers.get_distributed_vars_by_vtypes(
        ["Optimizer", "RemotePrefetch"], groupby=True)

    exclude_var_names = []
    if remote_params_map:
        exclude_var_names.extend(remote_params_map.keys())

    if main_program._distributed_lookup_table:
        if isinstance(main_program._distributed_lookup_table, list):
            exclude_var_names.extend(main_program._distributed_lookup_table)
        else:
            exclude_var_names.append(main_program._distributed_lookup_table)

    local_vars = list(
        filter(__exclude_vars(exclude_var_names), main_program.list_vars()))
    save_vars(
        executor, main_program=main_program, dirname=dirname, vars=local_vars)

    if main_program._is_chief:
        if remote_params_map:
            __save_remote_params(executor, dirname, remote_params_map)
        if main_program._distributed_lookup_table:
            __save_distributed_lookup_tables(
                executor, dirname, main_program._distributed_lookup_table,
                main_program._endpoints)


577
def save_persistables(executor, dirname, main_program=None, filename=None):
578
    """
G
guofei 已提交
579 580 581 582 583
    This operator saves all persistable variables from :code:`main_program` to 
    the folder :code:`dirname` or file :code:`filename`. You can refer to 
    :ref:`api_guide_model_save_reader_en` for more details. And then
    saves these persistables variables to the folder :code:`dirname` or file 
    :code:`filename`. 
F
fengjiayi 已提交
584

G
guofei 已提交
585
    The :code:`dirname` is used to specify the folder where persistable variables
586
    are going to be saved. If you would like to save variables in separate
G
guofei 已提交
587 588
    files, set :code:`filename` None; if you would like to save all variables in a
    single file, use :code:`filename` to specify the file name.
F
fengjiayi 已提交
589 590 591

    Args:
        executor(Executor): The executor to run for saving persistable variables.
G
guofei 已提交
592 593
                            You can refer to :ref:`api_guide_executor_en` for 
                            more details.
594 595
        dirname(str, optional): The saving directory path.
                            When you need to save the parameter to the memory, set it to None.
G
guofei 已提交
596 597 598 599 600 601 602 603 604
        main_program(Program, optional): The program whose persistbale variables will
                                         be saved. You can refer to 
                                         :ref:`api_guide_Program_en` for more details.
                                         If it is None, the default main program will 
                                         be used.
                                         Default: None.
        filename(str, optional): The file to save all variables. If you prefer to
                                 save variables in different files, set it to None.
                                 Default: None.
F
fengjiayi 已提交
605 606

    Returns:
607 608
        str: When saving parameters to a file, returns None.
             When saving parameters to memory, returns a binary string containing parameters.
F
fengjiayi 已提交
609 610 611 612

    Examples:
        .. code-block:: python

H
Huihuang Zheng 已提交
613
            import paddle.fluid as fluid
G
guofei 已提交
614 615 616 617 618 619 620 621 622 623
        
            dir_path = "./my_paddle_model"
            file_name = "persistables"
            image = fluid.data(name='img', shape=[None, 28, 28], dtype='float32')
            label = fluid.data(name='label', shape=[None, 1], dtype='int64')
            feeder = fluid.DataFeeder(feed_list=[image, label], place=fluid.CPUPlace())
           
            predict = fluid.layers.fc(input=image, size=10, act='softmax')
            loss = fluid.layers.cross_entropy(input=predict, label=label)
            avg_loss = fluid.layers.mean(loss)
F
fengjiayi 已提交
624
            exe = fluid.Executor(fluid.CPUPlace())
G
guofei 已提交
625 626 627 628 629
            exe.run(fluid.default_startup_program())
            fluid.io.save_persistables(executor=exe, dirname=dir_path, filename=file_name)
            # The persistables variables weights and bias in the fc layer of the network 
            # are going to be saved in the same file named "persistables" in the path
            # "./my_paddle_model"
630
    """
631
    if main_program and main_program._is_distributed:
632
        return _save_distributed_persistables(
633 634
            executor, dirname=dirname, main_program=main_program)
    else:
635
        return save_vars(
636 637 638 639 640 641
            executor,
            dirname=dirname,
            main_program=main_program,
            vars=None,
            predicate=is_persistable,
            filename=filename)
642 643


644 645 646 647 648
def load_vars(executor,
              dirname,
              main_program=None,
              vars=None,
              predicate=None,
649
              filename=None):
650
    """
651
    This API loads variables from files by executor.
F
fengjiayi 已提交
652

653 654 655 656
    There are two ways to specify the variables to be loaded: the first way, set
    variables in a list and assign it to the `vars`; the second way, use the 
    `predicate` function to select variables that make `predicate(variable) == True`. 
    The first way has a higher priority.
F
fengjiayi 已提交
657

658
    The `dirname` is used to specify the folder where to load variables.
659
    If variables were saved in separate files in the folder `dirname`,
660
    set `filename` None. If all variables were saved in a single file,
F
fengjiayi 已提交
661
    use `filename` to specify it.
662

F
fengjiayi 已提交
663 664
    Args:
        executor(Executor): The executor to run for loading variables.
665 666
        dirname(str): The folder where to load the variables.
        main_program(Program, optional): The program whose variables will be loaded.
667
                                    If it is None, the default main program will
F
fengjiayi 已提交
668 669
                                    be used automatically.
                                    Default: None
670
        vars(list[Variable], optional): The list that contains all variables to be loaded.
F
fengjiayi 已提交
671
                                   Default: None
672 673 674 675 676 677
        predicate(function, optional): The function selects variables that make 
                                        `predicate(variable) == True`.
                                        Default: None
        filename(str, optional): The file which saved all required variables. If variables
                                were saved in separate files, set it to be None.
                                Default: None
F
fengjiayi 已提交
678 679 680 681 682 683 684 685 686 687

    Returns:
        None

    Raises:
        TypeError: If `main_program` is not an instance of Program nor None.

    Examples:
        .. code-block:: python

688
            import paddle.fluid as fluid
689

690 691 692 693 694 695 696 697 698 699 700
            main_prog = fluid.Program()
            startup_prog = fluid.Program()
            with fluid.program_guard(main_prog, startup_prog):
                data = fluid.layers.data(name="img", shape=[64, 784], append_batch_size=False)
                w = fluid.layers.create_parameter(shape=[784, 200], dtype='float32', name='fc_w')
                b = fluid.layers.create_parameter(shape=[200], dtype='float32', name='fc_b')
                hidden_w = fluid.layers.matmul(x=data, y=w)
                hidden_b = fluid.layers.elementwise_add(hidden_w, b)
            place = fluid.CPUPlace()
            exe = fluid.Executor(place)
            exe.run(startup_prog)
F
fengjiayi 已提交
701

702 703 704 705 706 707 708 709 710 711 712
            # The first usage: using `vars` to specify the variables.
            path = "./my_paddle_vars"
            var_list = [w, b]
            fluid.io.save_vars(executor=exe, dirname=path, vars=var_list,
                               filename="vars_file")
            fluid.io.load_vars(executor=exe, dirname=path, vars=var_list,
                               filename="vars_file")
            # w and b will be loaded, and they are supposed to
            # be saved in the same file named 'var_file' in the path "./my_paddle_vars".

            # The second usage: using the `predicate` function to select variables
713
            param_path = "./my_paddle_model"
F
fengjiayi 已提交
714 715 716
            def name_has_fc(var):
                res = "fc" in var.name
                return res
717 718 719
            fluid.io.save_vars(executor=exe, dirname=param_path, main_program=main_prog,
                              vars=None, predicate=name_has_fc)
            fluid.io.load_vars(executor=exe, dirname=param_path, main_program=main_prog,
C
chengduo 已提交
720
                               vars=None, predicate=name_has_fc)
721 722
            # Load All variables in the `main_program` whose name includes "fc".
            # And all the variables are supposed to be saved in separate files.
F
fengjiayi 已提交
723

724
    """
725 726 727 728 729
    vars_from_memory = False
    if dirname is not None:
        dirname = os.path.normpath(dirname)
    else:
        vars_from_memory = True
T
tangwei12 已提交
730

731
    if vars is None:
732
        if main_program is None:
Y
Yu Yang 已提交
733
            main_program = default_main_program()
734
        if not isinstance(main_program, Program):
735 736 737 738
            raise TypeError("program's type should be Program")

        load_vars(
            executor,
739
            dirname=dirname,
T
tangwei12 已提交
740
            main_program=main_program,
741
            vars=list(filter(predicate, main_program.list_vars())),
742
            filename=filename)
743 744 745
    else:
        load_prog = Program()
        load_block = load_prog.global_block()
746

747 748
        if main_program is None:
            main_program = default_main_program()
T
tangwei12 已提交
749

750 751 752
        if not isinstance(main_program, Program):
            raise TypeError("program should be as Program type or None")

T
tangwei12 已提交
753
        # save origin param shape
H
hong 已提交
754
        orig_para_shape = {}
755
        load_var_map = {}
756 757
        for each_var in vars:
            assert isinstance(each_var, Variable)
T
tangwei12 已提交
758 759
            if each_var.type == core.VarDesc.VarType.RAW:
                continue
H
hong 已提交
760 761

            if isinstance(each_var, Parameter):
762 763
                orig_para_shape[each_var.name] = tuple(each_var.desc.get_shape(
                ))
764
            new_var = _clone_var_in_block_(load_block, each_var)
765
            if filename is None:
766 767 768 769
                if dirname is None:
                    raise ValueError(
                        "The directory path and params cannot be None at the same time."
                    )
770 771 772 773
                load_block.append_op(
                    type='load',
                    inputs={},
                    outputs={'Out': [new_var]},
774
                    attrs={'file_path': os.path.join(dirname, new_var.name)})
775 776 777
            else:
                load_var_map[new_var.name] = new_var

778
        if filename is not None:
779 780 781 782
            load_var_list = []
            for name in sorted(load_var_map.keys()):
                load_var_list.append(load_var_map[name])

783 784 785
            if vars_from_memory is False:
                filename = os.path.join(dirname, filename)

786
            load_block.append_op(
787
                type='load_combine',
788
                inputs={},
789
                outputs={"Out": load_var_list},
790 791 792 793
                attrs={
                    'file_path': filename,
                    'model_from_memory': vars_from_memory
                })
794 795
        executor.run(load_prog)

T
tangwei12 已提交
796
        # check var shape
H
hong 已提交
797 798 799 800 801 802
        for each_var in vars:
            if not isinstance(each_var, Parameter):
                continue
            var_temp = paddle.fluid.global_scope().find_var(each_var.name)
            assert var_temp != None, "can't not find var: " + each_var.name
            new_shape = (np.array(var_temp.get_tensor())).shape
803
            assert each_var.name in orig_para_shape, each_var.name + "MUST in var list"
H
hong 已提交
804 805 806 807 808 809 810
            orig_shape = orig_para_shape.get(each_var.name)
            if new_shape != orig_shape:
                raise RuntimeError(
                    "Shape not matching: the Program requires a parameter with a shape of ({}), "
                    "while the loaded parameter (namely [ {} ]) has a shape of  ({}).".
                    format(orig_shape, each_var.name, new_shape))

811

812
def load_params(executor, dirname, main_program=None, filename=None):
813
    """
814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832
    This API filters out all parameters from the give ``main_program``
    and then tries to load these parameters from the directory ``dirname`` or
    the file ``filename``.

    Use the ``dirname`` to specify the directory where parameters were saved. If
    parameters were saved in separate files under the directory `dirname`, set
    ``filename`` as None; if all parameters were saved in a single file, use
    ``filename`` to specify the file name.

    **Note**:
        Some variables are not Parameter while they are necessary for
        training, such as learning rate, global step, etc. So you cannot save and
        continue your training just by using :ref:`api_fluid_io_save_params` and
        :ref:`api_fluid_io_load_params`. Please use :ref:`api_fluid_io_save_persistables`
        and :ref:`api_fluid_io_load_persistables` instead.

        If you want to load the pre-trained model structure and parameters
        for the inference, please use the :ref:`api_fluid_io_load_inference_model` API. You can
        refer to :ref:`api_guide_model_save_reader_en` for more details.
F
fengjiayi 已提交
833 834

    Args:
835 836
        executor(Executor): The executor used for loading parameters.
                            See :ref:`api_guide_executor_en` for more details about it.
F
fengjiayi 已提交
837
        dirname(str): The directory path.
838 839 840 841 842 843 844 845
        main_program(Program, optional): The program whose parameters will be
                                    loaded. If it is None, the ``default_main_program``
                                    will be used automatically. See :ref:`api_guide_Program_en`
                                    for more about ``Program``.
                                    Default: None.
        filename(str, optional): The file which saved all parameters. If parameters
                            were saved in separated files, set it to None.
                            Default: None.
F
fengjiayi 已提交
846 847 848 849 850 851 852

    Returns:
        None

    Examples:
        .. code-block:: python

853
            import paddle.fluid as fluid
854

F
fengjiayi 已提交
855 856 857
            exe = fluid.Executor(fluid.CPUPlace())
            param_path = "./my_paddle_model"
            prog = fluid.default_main_program()
858
            fluid.io.load_params(executor=exe, dirname=param_path,
F
fengjiayi 已提交
859
                                main_program=None)
860 861
    """
    load_vars(
862 863 864
        executor,
        dirname=dirname,
        main_program=main_program,
865
        predicate=is_parameter,
866
        filename=filename)
867 868


869
def load_persistables(executor, dirname, main_program=None, filename=None):
870
    """
871 872 873
    This API filters out all variables with ``persistable==True`` from the
    given ``main_program`` and then tries to load these variables from the
    directory ``dirnameme`` or the file ``filename``.
F
fengjiayi 已提交
874

875 876 877 878
    Use the ``dirname`` to specify the directory where persistable variables
    (refer to :ref:`api_guide_model_save_reader_en`) were saved. If variables
    were saved in separate files, set ``filename`` as None; if all variables
    were saved in a single file, use ``filename`` to specify the file name.
F
fengjiayi 已提交
879 880

    Args:
881 882
        executor(Executor): The executor used for loading persistable variables.
                            See :ref:`api_guide_executor_en` for more details about it.
F
fengjiayi 已提交
883
        dirname(str): The directory path.
884 885 886 887 888 889 890 891
        main_program(Program, optional): The program whose persistbale variables will
                                    be loaded. If it is None, the ``default_main_program``
                                    will be used automatically. See :ref:`api_guide_Program_en`
                                    for more about ``Program``.
                                    Default: None.
        filename(str, optional): The file which saved all persistable variables. If variables
                                 were saved in separated files, set it to None.
                                 Default: None.
F
fengjiayi 已提交
892 893 894 895 896 897 898

    Returns:
        None

    Examples:
        .. code-block:: python

899
            import paddle.fluid as fluid
900

F
fengjiayi 已提交
901 902 903
            exe = fluid.Executor(fluid.CPUPlace())
            param_path = "./my_paddle_model"
            prog = fluid.default_main_program()
904
            fluid.io.load_persistables(executor=exe, dirname=param_path,
F
fengjiayi 已提交
905
                                       main_program=None)
906
    """
907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937

    if main_program and main_program._is_distributed:
        _load_distributed_persistables(
            executor, dirname=dirname, main_program=main_program)
    else:
        load_vars(
            executor,
            dirname=dirname,
            main_program=main_program,
            predicate=is_persistable,
            filename=filename)


def _load_distributed_persistables(executor, dirname, main_program=None):
    """
    customized load_persistables for distributed training.
    it should be used on parameter server,

    Args:
        executor(Executor): The executor to run for saving parameters.
        dirname(str): The load directory path.
        main_program(Program): The program whose parameters will be
                            loaded. the main_program must be the pserver_program
                            get after transpiler.

    Returns:
        None

    Examples:
        .. code-block:: python

938
            import paddle.fluid as fluid
939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971
            exe = fluid.Executor(fluid.CPUPlace())
            param_path = "./my_paddle_model"
            t = distribute_transpiler.DistributeTranspiler()
            t.transpile(...)
            pserver_prog = t.get_pserver_program(...)
            _load_distributed_persistables(executor=exe, dirname=param_path, main_program=pserver_prog)
    """

    def __is_distributed_part_var(varname):
        trainer_idx = varname.find(".trainer_")
        block_idx = varname.find(".block")
        return trainer_idx or block_idx

    def __load_persistable_vars(executor, dirname, need_load_vars):
        load_prog = Program()
        load_block = load_prog.global_block()
        need_delete_vars = []

        for param in need_load_vars:
            origin_var = param.origin
            slice_var = param.slice
            is_slice = param.is_slice
            offset = param.offset

            if is_slice:
                slice = load_block.create_var(
                    name=slice_var.name,
                    type=slice_var.type,
                    shape=slice_var.shape,
                    dtype=slice_var.dtype,
                    persistable=True)

                load_block.append_op(
T
tangwei12 已提交
972 973 974 975 976 977 978 979
                    type='load',
                    inputs={},
                    outputs={'Out': [slice]},
                    attrs={
                        'file_path': os.path.join(dirname, origin_var.name),
                        'seek': offset,
                        'shape': slice.shape
                    })
980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001
            else:
                origin = load_block.create_var(
                    name="{}".format(origin_var.name),
                    type=origin_var.type,
                    shape=origin_var.shape,
                    dtype=origin_var.dtype,
                    persistable=True)
                load_block.append_op(
                    type='load',
                    inputs={},
                    outputs={'Out': [origin]},
                    attrs={
                        'file_path': os.path.join(dirname, origin_var.name)
                    })

        load_block.append_op(
            type='delete_var',
            inputs={'X': need_delete_vars}, )

        executor.run(load_prog)

    if not isinstance(main_program, Program):
T
tangwei12 已提交
1002
        raise TypeError("'main_program' should be an instance of Program.")
1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016

    if not main_program._is_distributed:
        raise ValueError(
            "'_load_distributed_persistables' just be designed for distributed training."
        )

    if not main_program._ps_endpoint:
        raise ValueError(
            "'_load_distributed_persistables' need current_endpoint set in DistributeTranspiler.transpile"
        )

    need_load_vars = main_program._parameters_on_pservers.get_distributed_vars_by_ep(
        main_program._ps_endpoint)
    __load_persistable_vars(executor, dirname, need_load_vars)
1017 1018


1019 1020 1021
def prepend_feed_ops(inference_program,
                     feed_target_names,
                     feed_holder_name='feed'):
Q
Qiao Longfei 已提交
1022 1023 1024
    if len(feed_target_names) == 0:
        return

K
Kexin Zhao 已提交
1025 1026
    global_block = inference_program.global_block()
    feed_var = global_block.create_var(
1027 1028 1029
        name=feed_holder_name,
        type=core.VarDesc.VarType.FEED_MINIBATCH,
        persistable=True)
K
Kexin Zhao 已提交
1030

1031
    for i, name in enumerate(feed_target_names):
K
fix bug  
Kexin Zhao 已提交
1032
        out = global_block.var(name)
W
Wu Yi 已提交
1033
        global_block._prepend_op(
K
Kexin Zhao 已提交
1034 1035
            type='feed',
            inputs={'X': [feed_var]},
K
fix bug  
Kexin Zhao 已提交
1036
            outputs={'Out': [out]},
K
Kexin Zhao 已提交
1037 1038 1039
            attrs={'col': i})


1040 1041 1042
def append_fetch_ops(inference_program,
                     fetch_target_names,
                     fetch_holder_name='fetch'):
K
Kexin Zhao 已提交
1043 1044
    global_block = inference_program.global_block()
    fetch_var = global_block.create_var(
1045 1046 1047
        name=fetch_holder_name,
        type=core.VarDesc.VarType.FETCH_LIST,
        persistable=True)
K
Kexin Zhao 已提交
1048

1049
    for i, name in enumerate(fetch_target_names):
K
Kexin Zhao 已提交
1050 1051 1052 1053 1054 1055 1056
        global_block.append_op(
            type='fetch',
            inputs={'X': [name]},
            outputs={'Out': [fetch_var]},
            attrs={'col': i})


1057 1058 1059 1060
def save_inference_model(dirname,
                         feeded_var_names,
                         target_vars,
                         executor,
1061
                         main_program=None,
1062
                         model_filename=None,
1063
                         params_filename=None,
T
tangwei12 已提交
1064 1065
                         export_for_deployment=True,
                         program_only=False):
1066
    """
F
fengjiayi 已提交
1067
    Prune the given `main_program` to build a new program especially for inference,
G
guofei 已提交
1068
    and then save it and all related parameters to given `dirname` .
1069
    If you just want to save parameters of your trained model, please use the
G
guofei 已提交
1070 1071
    :ref:`api_fluid_io_save_params` . You can refer to :ref:`api_guide_model_save_reader_en`
    for more details.
1072

G
guofei 已提交
1073 1074 1075 1076 1077
    Note:
        The :code:`dirname` is used to specify the folder where inference model 
        structure and parameters are going to be saved. If you would like to save params of
        Program in separate files, set `params_filename` None; if you would like to save all 
        params of Program in a single file, use `params_filename` to specify the file name.
F
fengjiayi 已提交
1078 1079 1080

    Args:
        dirname(str): The directory path to save the inference model.
G
guofei 已提交
1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096
        feeded_var_names(list[str]): list of string. Names of variables that need to be feeded
                                     data during inference.
        target_vars(list[Variable]): list of Variable. Variables from which we can get 
                                     inference results.
        executor(Executor): The executor that saves the inference model. You can refer 
                            to :ref:`api_guide_executor_en` for more details.
        main_program(Program, optional): The original program, which will be pruned to
                                         build the inference model. If is setted None,
                                         the global default :code:`_main_program_` will be used.
                                         Default: None.
        model_filename(str, optional): The name of file to save the inference program
                                       itself. If is setted None, a default filename
                                       :code:`__model__` will be used.
        params_filename(str, optional): The name of file to save all related parameters.
                                        If it is setted None, parameters will be saved
                                        in separate files .
X
Xin Pan 已提交
1097 1098 1099 1100 1101
        export_for_deployment(bool): If True, programs are modified to only support
                                     direct inference deployment. Otherwise,
                                     more information will be stored for flexible
                                     optimization and re-training. Currently, only
                                     True is supported.
G
guofei 已提交
1102 1103 1104 1105
                                     Default: True.
        program_only(bool, optional): If True, It will save inference program only, and do not 
                                      save params of Program.
                                      Default: False.
1106

F
fengjiayi 已提交
1107
    Returns:
G
guofei 已提交
1108 1109 1110 1111
        The fetch variables' name list

     Return Type:
        list
F
fengjiayi 已提交
1112 1113

    Raises:
G
guofei 已提交
1114 1115
        ValueError: If `feed_var_names` is not a list of basestring, an exception is thrown.
        ValueError: If `target_vars` is not a list of Variable, an exception is thrown.
F
fengjiayi 已提交
1116 1117 1118

    Examples:
        .. code-block:: python
F
fengjiayi 已提交
1119

1120 1121
            import paddle.fluid as fluid

F
fengjiayi 已提交
1122 1123
            path = "./infer_model"

1124
            # User defined network, here a softmax regresssion example
G
guofei 已提交
1125 1126
            image = fluid.data(name='img', shape=[None, 28, 28], dtype='float32')
            label = fluid.data(name='label', shape=[None, 1], dtype='int64')
1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143
            feeder = fluid.DataFeeder(feed_list=[image, label], place=fluid.CPUPlace())
            predict = fluid.layers.fc(input=image, size=10, act='softmax')

            loss = fluid.layers.cross_entropy(input=predict, label=label)
            avg_loss = fluid.layers.mean(loss)

            exe = fluid.Executor(fluid.CPUPlace())
            exe.run(fluid.default_startup_program())

            # Feed data and train process

            # Save inference model. Note we don't save label and loss in this example
            fluid.io.save_inference_model(dirname=path,
                                          feeded_var_names=['img'],
                                          target_vars=[predict],
                                          executor=exe)

G
guofei 已提交
1144 1145 1146
            # In this example, the save_inference_mode inference will prune the default
            # main program according to the network's input node (img) and output node(predict). 
            # The pruned inference program is going to be saved in the "./infer_model/__model__"
F
fengjiayi 已提交
1147
            # and parameters are going to be saved in separate files under folder
1148
            # "./infer_model".
1149 1150

    """
M
minqiyang 已提交
1151
    if isinstance(feeded_var_names, six.string_types):
F
fengjiayi 已提交
1152
        feeded_var_names = [feeded_var_names]
X
Xin Pan 已提交
1153
    elif export_for_deployment:
Q
Qiao Longfei 已提交
1154
        if len(feeded_var_names) > 0:
1155
            # TODO(paddle-dev): polish these code blocks
Q
Qiao Longfei 已提交
1156
            if not (bool(feeded_var_names) and all(
M
minqiyang 已提交
1157
                    isinstance(name, six.string_types)
1158
                    for name in feeded_var_names)):
M
minqiyang 已提交
1159
                raise ValueError("'feed_var_names' should be a list of str.")
F
fengjiayi 已提交
1160 1161

    if isinstance(target_vars, Variable):
F
fengjiayi 已提交
1162
        target_vars = [target_vars]
X
Xin Pan 已提交
1163
    elif export_for_deployment:
1164 1165
        if not (bool(target_vars) and
                all(isinstance(var, Variable) for var in target_vars)):
F
fengjiayi 已提交
1166 1167
            raise ValueError("'target_vars' should be a list of Variable.")

C
chengduo 已提交
1168
    main_program = _get_valid_program(main_program)
T
tangwei12 已提交
1169

1170 1171 1172 1173 1174 1175 1176 1177 1178
    # remind user to set auc_states to zeros if the program contains auc op 
    all_ops = main_program.global_block().ops
    for op in all_ops:
        if op.type == 'auc':
            warnings.warn(
                "please ensure that you have set the auc states to zeros before saving inference model"
            )
            break

F
flame 已提交
1179
    target_var_name_list = [var.name for var in target_vars]
1180

1181
    # when a pserver and a trainer running on the same machine, mkdir may conflict
L
lujun 已提交
1182
    save_dirname = dirname
1183
    try:
L
lujun 已提交
1184 1185
        save_dirname = os.path.normpath(dirname)
        os.makedirs(save_dirname)
1186 1187 1188 1189
    except OSError as e:
        if e.errno != errno.EEXIST:
            raise

X
Xin Pan 已提交
1190 1191 1192 1193
    if model_filename is not None:
        model_basename = os.path.basename(model_filename)
    else:
        model_basename = "__model__"
L
lujun 已提交
1194
    model_basename = os.path.join(save_dirname, model_basename)
1195

X
Xin Pan 已提交
1196 1197 1198 1199
    # When export_for_deployment is true, we modify the program online so that
    # it can only be loaded for inference directly. If it's false, the whole
    # original program and related meta are saved so that future usage can be
    # more flexible.
1200 1201 1202

    origin_program = main_program.clone()

X
Xin Pan 已提交
1203
    if export_for_deployment:
X
Xin Pan 已提交
1204 1205
        main_program = main_program.clone()
        global_block = main_program.global_block()
1206
        need_to_remove_op_index = []
X
Xin Pan 已提交
1207 1208 1209
        for i, op in enumerate(global_block.ops):
            op.desc.set_is_target(False)
            if op.type == "feed" or op.type == "fetch":
1210 1211 1212 1213 1214
                need_to_remove_op_index.append(i)

        for index in need_to_remove_op_index[::-1]:
            global_block._remove_op(index)

X
Xin Pan 已提交
1215
        main_program.desc.flush()
X
Xin Pan 已提交
1216

1217 1218
        main_program = main_program._prune_with_input(
            feeded_var_names=feeded_var_names, targets=target_vars)
X
Xin Pan 已提交
1219
        main_program = main_program._inference_optimize(prune_read_op=True)
X
Xin Pan 已提交
1220 1221
        fetch_var_names = [v.name for v in target_vars]

X
Xin Pan 已提交
1222 1223 1224
        prepend_feed_ops(main_program, feeded_var_names)
        append_fetch_ops(main_program, fetch_var_names)

1225 1226
        main_program.desc._set_version()
        paddle.fluid.core.save_op_compatible_info(main_program.desc)
X
Xin Pan 已提交
1227 1228
        with open(model_basename, "wb") as f:
            f.write(main_program.desc.serialize_to_string())
X
Xin Pan 已提交
1229 1230 1231
    else:
        # TODO(panyx0718): Save more information so that it can also be used
        # for training and more flexible post-processing.
X
Xin Pan 已提交
1232 1233
        with open(model_basename + ".main_program", "wb") as f:
            f.write(main_program.desc.serialize_to_string())
T
tangwei12 已提交
1234

T
tangwei12 已提交
1235 1236 1237 1238 1239 1240
    if program_only:
        warnings.warn(
            "save_inference_model specified the param `program_only` to True, It will not save params of Program."
        )
        return target_var_name_list

1241 1242
    main_program._copy_dist_param_info_from(origin_program)

X
fix  
Xin Pan 已提交
1243 1244
    if params_filename is not None:
        params_filename = os.path.basename(params_filename)
1245

L
lujun 已提交
1246
    save_persistables(executor, save_dirname, main_program, params_filename)
F
flame 已提交
1247
    return target_var_name_list
X
fix  
Xin Pan 已提交
1248

1249

1250 1251 1252
def load_inference_model(dirname,
                         executor,
                         model_filename=None,
T
tangwei12 已提交
1253 1254
                         params_filename=None,
                         pserver_endpoints=None):
1255
    """
1256 1257 1258
    Load the inference model from a given directory. By this API, you can get the model
    structure(Inference Program) and model parameters. If you just want to load
    parameters of the pre-trained model, please use the :ref:`api_fluid_io_load_params` API.
1259
    You can refer to :ref:`api_guide_model_save_reader_en` for more details.
1260

F
fengjiayi 已提交
1261
    Args:
1262 1263 1264
        dirname(str): One of the following:
          - The given directory path.
          - Set to None when reading the model from memory.
F
fengjiayi 已提交
1265
        executor(Executor): The executor to run for loading inference model.
1266
                            See :ref:`api_guide_executor_en` for more details about it.
1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277
        model_filename(str, optional): One of the following:
          - The name of file to load the inference program.
          - If it is None, the default filename ``__model__`` will be used.
          - When ``dirname`` is ``None``, it must be set to a string containing model.
          Default: ``None``.
        params_filename(str, optional): It is only used for the case that all
            parameters were saved in a single binary file. One of the following:
          - The name of file to load all parameters.  
          - When ``dirname`` is ``None``, it must be set to a string containing all the parameters.
          - If parameters were saved in separate files, set it as ``None``.
            Default: ``None``.
1278 1279 1280 1281

        pserver_endpoints(list, optional): It is only needed by the distributed inference.
                                    If using a distributed look up table during the training,
                                    this table is also needed by the inference process. Its value is
1282
                                    a list of pserver endpoints.
F
fengjiayi 已提交
1283 1284

    Returns:
1285
        list: The return of this API is a list with three elements:
1286
        (program, feed_target_names, fetch_targets). The `program` is a
1287 1288 1289 1290 1291
        ``Program`` (refer to :ref:`api_guide_Program_en`), which is used for inference.
        The `feed_target_names` is a list of ``str``, which contains names of variables
        that need to feed data in the inference program. The `fetch_targets` is a list of
        ``Variable`` (refer to :ref:`api_guide_Program_en`). It contains variables from which
        we can get inference results.
F
fengjiayi 已提交
1292 1293 1294 1295 1296 1297 1298

    Raises:
        ValueError: If `dirname` is not a existing directory.

    Examples:
        .. code-block:: python

1299 1300
            import paddle.fluid as fluid
            import numpy as np
1301 1302

            # Build the model
1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313
            main_prog = fluid.Program()
            startup_prog = fluid.Program()
            with fluid.program_guard(main_prog, startup_prog):
                data = fluid.layers.data(name="img", shape=[64, 784], append_batch_size=False)
                w = fluid.layers.create_parameter(shape=[784, 200], dtype='float32')
                b = fluid.layers.create_parameter(shape=[200], dtype='float32')
                hidden_w = fluid.layers.matmul(x=data, y=w)
                hidden_b = fluid.layers.elementwise_add(hidden_w, b)
            place = fluid.CPUPlace()
            exe = fluid.Executor(place)
            exe.run(startup_prog)
1314 1315

            # Save the inference model
F
fengjiayi 已提交
1316
            path = "./infer_model"
1317 1318
            fluid.io.save_inference_model(dirname=path, feeded_var_names=['img'],
                         target_vars=[hidden_b], executor=exe, main_program=main_prog)
1319 1320 1321

            # Demo one. Not need to set the distributed look up table, because the
            # training doesn't use a distributed look up table.
1322 1323
            [inference_program, feed_target_names, fetch_targets] = (
                fluid.io.load_inference_model(dirname=path, executor=exe))
1324
            tensor_img = np.array(np.random.random((1, 64, 784)), dtype=np.float32)
F
fengjiayi 已提交
1325 1326 1327 1328
            results = exe.run(inference_program,
                          feed={feed_target_names[0]: tensor_img},
                          fetch_list=fetch_targets)

1329 1330 1331
            # Demo two. If the training uses a distributed look up table, the pserver
            # endpoints list should be supported when loading the inference model.
            # The below is just an example.
1332
            endpoints = ["127.0.0.1:2023","127.0.0.1:2024"]
1333
            [dist_inference_program, dist_feed_target_names, dist_fetch_targets] = (
1334 1335
                fluid.io.load_inference_model(dirname=path,
                                              executor=exe,
1336
                                              pserver_endpoints=endpoints))
1337

1338
            # In this example, the inference program was saved in the file
1339
            # "./infer_model/__model__" and parameters were saved in
1340 1341 1342 1343
            # separate files under the directory "./infer_model".
            # By the inference program, feed_target_names and
            # fetch_targets, we can use an executor to run the inference
            # program for getting the inference result.
1344
    """
1345 1346 1347 1348 1349
    load_from_memory = False
    if dirname is not None:
        load_dirname = os.path.normpath(dirname)
        if not os.path.isdir(load_dirname):
            raise ValueError("There is no directory named '%s'", dirname)
1350

1351 1352
        if model_filename is None:
            model_filename = '__model__'
1353

1354 1355
        model_filename = os.path.join(load_dirname,
                                      os.path.basename(model_filename))
1356

1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370
        if params_filename is not None:
            params_filename = os.path.basename(params_filename)

        with open(model_filename, "rb") as f:
            program_desc_str = f.read()
    else:
        load_from_memory = True
        if params_filename is None:
            raise ValueError(
                "The path of params cannot be None when the directory path is None."
            )
        load_dirname = dirname
        program_desc_str = model_filename
        params_filename = params_filename
1371

1372
    program = Program.parse_from_string(program_desc_str)
X
Xin Pan 已提交
1373
    if not core._is_program_version_supported(program._version()):
X
version  
Xin Pan 已提交
1374 1375 1376
        raise ValueError("Unsupported program version: %d\n" %
                         program._version())
    # Binary data also need versioning.
L
lujun 已提交
1377
    load_persistables(executor, load_dirname, program, params_filename)
1378

T
tangwei12 已提交
1379
    if pserver_endpoints:
T
tangwei12 已提交
1380
        program = _endpoints_replacement(program, pserver_endpoints)
T
tangwei12 已提交
1381

1382 1383
    feed_target_names = program.desc.get_feed_target_names()
    fetch_target_names = program.desc.get_fetch_target_names()
1384 1385 1386 1387 1388
    fetch_targets = [
        program.global_block().var(name) for name in fetch_target_names
    ]

    return [program, feed_target_names, fetch_targets]
X
xuwei06 已提交
1389 1390


T
tangwei12 已提交
1391 1392 1393
def _endpoints_replacement(program, endpoints):
    ENDPOINT_MAP = "epmap"
    for op in program.global_block().ops:
T
tangwei12 已提交
1394 1395
        if op.has_attr(ENDPOINT_MAP):
            op.set_attr(ENDPOINT_MAP, endpoints)
T
fix  
tangwei12 已提交
1396
    program._sync_with_cpp()
T
tangwei12 已提交
1397
    return program
T
tangwei12 已提交
1398 1399


X
xuwei06 已提交
1400 1401
def get_parameter_value(para, executor):
    """
F
fengjiayi 已提交
1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412
    Get the LoDTensor value of the given parameter.

    Args:
        para(Parameter): The parameter to get value from.
        executor(Executor): The executor to run for retrieving the value.

    Returns:
        numpy.array: The given parameter's values.

    Raises:
        AssertionError: If the `para` is not an instance of Parameter.
X
xuwei06 已提交
1413

F
fengjiayi 已提交
1414 1415
    Examples:
        .. code-block:: python
X
xuwei06 已提交
1416

1417
            import paddle.fluid as fluid
F
fengjiayi 已提交
1418 1419 1420
            exe = fluid.Executor(fluid.CPUPlace())
            param = fluid.default_main_program().global_block().var('fc.w')
            p = fluid.io.get_parameter_value(param, exe)
1421

X
xuwei06 已提交
1422
    """
X
xuwei06 已提交
1423 1424
    assert is_parameter(para)

X
xuwei06 已提交
1425 1426 1427 1428 1429 1430 1431 1432
    get_program = Program()
    block = get_program.global_block()
    new_var = _clone_var_in_block_(block, para)
    return executor.run(get_program, feed={}, fetch_list=[new_var])[0]


def get_parameter_value_by_name(name, executor, program=None):
    """
F
fengjiayi 已提交
1433
    Get the LoDTensor value of a certain parameter by its name.
X
xuwei06 已提交
1434

F
fengjiayi 已提交
1435 1436 1437 1438 1439 1440 1441
    Args:
        name(str): The parameter's name.
        executor(Executor): The executor to run for retrieving the value.
        program(Program | None): The program where to find the parameter.
                               If it's set to be None, the function will
                               try to find the parameter in the default
                               main program.
X
xuwei06 已提交
1442

F
fengjiayi 已提交
1443 1444
    Returns:
        numpy.array: The parameter's values.
1445

F
fengjiayi 已提交
1446 1447 1448 1449 1450
    Raises:
        TypeError: If given `name` is not an instance of basestring.
        TypeError: If the parameter with the given name doesn't exist.
        AssertionError: If there is a varibale named `name` in the
                        given program but it is not a Parameter.
1451

F
fengjiayi 已提交
1452 1453 1454
    Examples:
        .. code-block:: python

1455
            import paddle.fluid as fluid
F
fengjiayi 已提交
1456 1457
            exe = fluid.Executor(fluid.CPUPlace())
            p = fluid.io.get_parameter_value('fc.w', exe)
X
xuwei06 已提交
1458 1459
    """
    if program is None:
Y
Yu Yang 已提交
1460
        program = default_main_program()
X
xuwei06 已提交
1461 1462
    var = program.global_block().var(name)
    return get_parameter_value(var, executor)
1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539


def _save_persistable_nodes(executor, dirname, graph):
    """
    Save persistable nodes to the given directory by the executor.

    Args:
        executor(Executor): The executor to run for saving node values.
        dirname(str): The directory path.
        graph(IrGraph): All the required persistable nodes in the graph will be saved.
    """
    persistable_node_names = set()
    persistable_nodes = []
    all_persistable_nodes = graph.all_persistable_nodes()
    for node in all_persistable_nodes:
        name = cpt.to_text(node.name())
        if name not in persistable_node_names:
            persistable_node_names.add(name)
            persistable_nodes.append(node)
    program = Program()
    var_list = []
    for node in persistable_nodes:
        var_desc = node.var()
        if var_desc.type() == core.VarDesc.VarType.RAW or \
                var_desc.type() == core.VarDesc.VarType.READER:
            continue
        var = program.global_block().create_var(
            name=var_desc.name(),
            shape=var_desc.shape(),
            dtype=var_desc.dtype(),
            type=var_desc.type(),
            lod_level=var_desc.lod_level(),
            persistable=var_desc.persistable())
        var_list.append(var)
    save_vars(executor=executor, dirname=dirname, vars=var_list)


def _load_persistable_nodes(executor, dirname, graph):
    """
    Load persistable node values from the given directory by the executor.

    Args:
        executor(Executor): The executor to run for loading node values.
        dirname(str): The directory path.
        graph(IrGraph): All the required persistable nodes in the graph will be loaded.
    """
    persistable_node_names = set()
    persistable_nodes = []
    all_persistable_nodes = graph.all_persistable_nodes()
    for node in all_persistable_nodes:
        name = cpt.to_text(node.name())
        if name not in persistable_node_names:
            persistable_node_names.add(name)
            persistable_nodes.append(node)
    program = Program()
    var_list = []

    def _exist(var):
        return os.path.exists(os.path.join(dirname, var.name))

    for node in persistable_nodes:
        var_desc = node.var()
        if var_desc.type() == core.VarDesc.VarType.RAW or \
                var_desc.type() == core.VarDesc.VarType.READER:
            continue
        var = program.global_block().create_var(
            name=var_desc.name(),
            shape=var_desc.shape(),
            dtype=var_desc.dtype(),
            type=var_desc.type(),
            lod_level=var_desc.lod_level(),
            persistable=var_desc.persistable())
        if _exist(var):
            var_list.append(var)
        else:
            _logger.warn("Cannot find the var %s!!!" % (node.name()))
    load_vars(executor=executor, dirname=dirname, vars=var_list)
H
hong 已提交
1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568


def save(program, model_path):
    """
    This function save parameters, optimizer information and network description to  model_path.

    The parameters contains all the trainable Variable, will save to a file with suffix ".pdparams".
    The optimizer information contains all the variable used by optimizer. For Adam optimizer, contains beta1, beta2, momentum etc. All the information will save to a file with suffix ".pdopt". (If the optimizer have no variable need to save (like SGD), the fill will not generated).
    The network description is the description of the program. It's only used for deployment. The description  will save to a file with a suffix ".pdmodel".
    
    Args:
        program(Program) : The program to saved.
        model_path(str): the file prefix to save the program. The format is "dirname/file_prefix". If file_prefix is empty str. A exception will be raised

    Returns:
        None

    Examples:
        .. code-block:: python

            import paddle.fluid as fluid

            prog = fluid.default_main_program()
            fluid.save( prog, "./temp")

    """

    base_name = os.path.basename(model_path)
    assert base_name != "", \
T
tangwei12 已提交
1569
        "model_path MUST be format of dirname/filename [dirname\\filename in Window], Now filename is empty str"
H
hong 已提交
1570

1571 1572 1573 1574
    dir_name = os.path.dirname(model_path)
    if dir_name and not os.path.exists(dir_name):
        os.makedirs(dir_name)

Y
Yang Zhang 已提交
1575 1576 1577 1578
    def get_tensor(var):
        t = global_scope().find_var(var.name).get_tensor()
        return np.array(t)

H
hong 已提交
1579
    parameter_list = list(filter(is_parameter, program.list_vars()))
Y
Yang Zhang 已提交
1580 1581
    param_dict = {p.name: get_tensor(p) for p in parameter_list}
    with open(model_path + ".pdparams", 'wb') as f:
1582
        pickle.dump(param_dict, f, protocol=2)
H
hong 已提交
1583 1584 1585 1586

    optimizer_var_list = list(
        filter(is_belong_to_optimizer, program.list_vars()))

Y
Yang Zhang 已提交
1587 1588
    opt_dict = {p.name: get_tensor(p) for p in optimizer_var_list}
    with open(model_path + ".pdopt", 'wb') as f:
1589
        pickle.dump(opt_dict, f, protocol=2)
H
hong 已提交
1590 1591 1592 1593 1594 1595 1596 1597 1598 1599

    main_program = program.clone()
    program.desc.flush()
    main_program.desc._set_version()
    paddle.fluid.core.save_op_compatible_info(program.desc)

    with open(model_path + ".pdmodel", "wb") as f:
        f.write(program.desc.serialize_to_string())


H
hong 已提交
1600
def load(program, model_path, executor=None, var_list=None):
H
hong 已提交
1601
    """
H
hong 已提交
1602
    This function get parameters and optimizer information from program, and then get corresponding value from file.
1603
    An exception will throw if shape or dtype of the parameters is not match.
H
hong 已提交
1604

H
hong 已提交
1605 1606 1607 1608
    This function can also load model file saved with [ save_params, save_persistables, save_vars ]. 
    var_list can not be None  when load single model file 
    ( filename is not None When save_params, save_persistables or save_vars is called ).

H
hong 已提交
1609
    Args: 
1610 1611 1612 1613
        program(Program): The program will be loaded
        model_path(str): The file prefix store the program
        executor(Executor, optional): The executor used for initialize the parameter 
                                      When startup program is not run.
H
hong 已提交
1614 1615 1616
        var_list(list, optional): The variable list to load single model file saved with 
                                  [ save_params, save_persistables, save_vars ]. 
                                  Default: None
H
hong 已提交
1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632

    Returns:
        None
        
     Examples:
        .. code-block:: python

            import paddle.fluid as fluid

            prog = fluid.default_main_program()
            fluid.save( prog, "./temp")

            fluid.load( prog, "./temp")

    """

1633 1634
    assert executor is None or isinstance(executor, Executor)

H
hong 已提交
1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713
    model_prefix = model_path
    if model_prefix.endswith(".pdparams"):
        model_prefix = model_prefix[:-9]
    elif model_prefix.endswith(".pdopt"):
        model_prefix = model_prefix[:-6]
    elif model_prefix.endswith(".pdmodel"):
        model_prefix = model_prefix[:-8]

    parameter_file_name = model_prefix + ".pdparams"

    if not os.path.exists(parameter_file_name):
        # model file save by fluid.save not found, try to load model file saved with
        # [save_vars, save_params, save_persistables]
        _logger.warning(
            "{} not found, try to load model file saved with [ save_params, save_persistables, save_vars ]".
            format(parameter_file_name))
        if executor is None:
            raise ValueError(
                "executor is required when loading model file saved with [ save_params, save_persistables, save_vars ]"
            )
        if os.path.isdir(model_path):
            binary_file_set = set()
            for root, dirs, files in os.walk(model_path, topdown=False):
                for f in files:
                    binary_file_set.add(
                        os.path.join(root, f).replace("\\", "/"))
            program_var_list = list(program.list_vars())
            loaded_var_list = []
            for var in program_var_list:
                var_path = os.path.join(model_path, var.name).replace("\\", "/")
                if var_path in binary_file_set:
                    loaded_var_list.append(var)
                    binary_file_set.remove(var_path)
            if len(binary_file_set) > 0:
                unused_var_list = " ".join(list(binary_file_set))
                _logger.warning("variable file [ %s ] not used" %
                                (" ".join(list(binary_file_set))))
            try:
                load_vars(
                    executor=executor, dirname=model_path, vars=loaded_var_list)
            except RuntimeError as e:
                _logger.error(e)
                raise e
            except:
                raise RuntimeError(
                    "Failed to load model file , please make sure model file is saved with the "
                    "following APIs: save_params, save_persistables, save_vars")

            return
        elif os.path.isfile(model_path):
            if var_list == None:
                raise ValueError(
                    "var_list is required when loading model file saved with [ save_params, save_persistables, save_vars ]"
                )
            program_var_list = program.list_vars()
            program_var_name_set = set([var.name for var in program_var_list])

            # check all the variable inlcuded in program
            for var in var_list:
                if var.name not in program_var_name_set:
                    raise LookupError(
                        "loaded var [{}] not included in program variable list")

            dir_name, file_name = os.path.split(model_path)
            try:
                load_vars(
                    executor=executor,
                    dirname=dir_name,
                    vars=var_list,
                    filename=file_name)
            except RuntimeError as e:
                _logger.error(e)
                raise e
            except:
                raise RuntimeError( "Failed to load model file , please make sure model file is saved with the " \
                                    "the following APIs: [ save_params, save_persistables, save_vars ]. " \
                                    "When these API called, filename CANNOT be None")

            return
Y
Yang Zhang 已提交
1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727

    def set_var(var, ndarray):
        t = global_scope().find_var(var.name).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)
H
hong 已提交
1728 1729

    parameter_list = list(filter(is_parameter, program.list_vars()))
1730 1731 1732 1733 1734

    if executor:
        paddle.fluid.core._create_loaded_parameter(parameter_list,
                                                   global_scope(),
                                                   executor._default_executor)
Y
Yang Zhang 已提交
1735
    with open(parameter_file_name, 'rb') as f:
1736 1737
        load_dict = pickle.load(f) if six.PY2 else pickle.load(
            f, encoding='latin1')
Y
Yang Zhang 已提交
1738 1739 1740 1741 1742
    for v in parameter_list:
        assert v.name in load_dict, \
            "Can not find [{}] in model file [{}]".format(
                v.name, parameter_file_name)
        set_var(v, load_dict[v.name])
H
hong 已提交
1743 1744 1745 1746 1747

    optimizer_var_list = list(
        filter(is_belong_to_optimizer, program.list_vars()))

    if len(optimizer_var_list) > 0:
H
hong 已提交
1748
        opt_file_name = model_prefix + ".pdopt"
H
hong 已提交
1749
        assert os.path.exists(opt_file_name), \
T
tangwei12 已提交
1750
            "Optimizer file [{}] not exits".format(opt_file_name)
1751 1752 1753 1754

        if executor:
            paddle.fluid.core._create_loaded_parameter(
                optimizer_var_list, global_scope(), executor._default_executor)
Y
Yang Zhang 已提交
1755 1756

        with open(opt_file_name, 'rb') as f:
1757 1758
            load_dict = pickle.load(f) if six.PY2 else pickle.load(
                f, encoding='latin1')
Y
Yang Zhang 已提交
1759 1760 1761 1762 1763
        for v in optimizer_var_list:
            assert v.name in load_dict, \
                "Can not find [{}] in model file [{}]".format(
                    v.name, opt_file_name)
            set_var(v, load_dict[v.name])
1764 1765


1766
def load_program_state(model_path, var_list=None):
1767 1768 1769 1770 1771
    """
    Load program state from local file
    
    Args:
        model_path(str): The file prefix store the program
1772 1773 1774 1775 1776
        var_list(list, optional): The variable list to load saved with 
                                  [ save_params, save_persistables, save_vars ]. 
                                  Default: None.
                                  The var_list is only used to get name, 
                                  will not be modified.
1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796
    Returns:
        state_dict(dict): the dict store Parameter and optimizer information

    Examples:
        .. code-block:: python

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

            place = fluid.CPUPlace()
            exe = fluid.Executor(place)
            exe.run( fluid.default_startup_program() )
            prog = fluid.default_main_program()

            fluid.save( prog, "./temp")
            program_state = fluid.load_program_state( "./temp")
            
    """
1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877
    model_prefix = model_path
    if model_prefix.endswith(".pdparams"):
        model_prefix = model_prefix[:-9]
    elif model_prefix.endswith(".pdopt"):
        model_prefix = model_prefix[:-6]
    elif model_prefix.endswith(".pdmodel"):
        model_prefix = model_prefix[:-8]

    parameter_file_name = model_prefix + ".pdparams"
    if not os.path.exists(parameter_file_name):
        # model file saved with fluid.save is not found, try to load model file saved with
        # [save_vars, save_params, save_persistables]
        _logger.warning(
            "{} not found, try to load model file saved with [ save_params, save_persistables, save_vars ]".
            format(parameter_file_name))

        var_name_list = []
        if var_list is None and os.path.isfile(model_path):
            raise ValueError(
                "var_list can not be None when model_path is a file type")

        for root, dirs, files in os.walk(model_path, topdown=False):
            for f in files:
                file_path = os.path.join(root, f)
                var_temp_name = os.path.relpath(file_path, model_path)
                var_temp_name = var_temp_name.replace("\\", "/")
                var_name_list.append(var_temp_name)

        with _load_program_scope():
            load_prog = Program()
            load_block = load_prog.global_block()

            def clone_var_to_block(block, var):
                if not isinstance(var, Variable):
                    raise TypeError("value in var_list must be variable")
                return block.create_var(
                    name=var.name,
                    shape=var.shape,
                    dtype=var.dtype,
                    type=var.type,
                    lod_level=var.lod_level
                    if var.desc.type() == core.VarDesc.VarType.LOD_TENSOR else
                    None,
                    persistable=True)

            loaded_var_list = []

            if var_list is not None:
                for var in var_list:
                    loaded_var_list.append(clone_var_to_block(load_block, var))
            else:
                for var_name in var_name_list:
                    loaded_var_list.append(
                        load_block.create_var(
                            name=var_name, persistable=True))

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

            try:
                if os.path.isfile(model_path):
                    dir_name, file_name = os.path.split(model_path)
                else:
                    dir_name = model_path
                    file_name = None
                load_vars(
                    executor=exe,
                    dirname=dir_name,
                    vars=loaded_var_list,
                    filename=file_name)
            except:
                raise RuntimeError(
                    "Failed to load model file , please make sure model file is saved with the "
                    "following APIs: save_params, save_persistables, save_vars")
            res_dict = {}
            for var in loaded_var_list:
                res_dict[var.name] = np.asarray(paddle.fluid.global_scope(
                ).find_var(var.name).get_tensor())

            return res_dict

1878
    assert os.path.exists(parameter_file_name), \
T
tangwei12 已提交
1879
        "Parameter file [{}] not exits".format(parameter_file_name)
1880 1881

    with open(parameter_file_name, 'rb') as f:
1882 1883
        para_dict = pickle.load(f) if six.PY2 else pickle.load(
            f, encoding='latin1')
1884

1885
    opt_file_name = model_prefix + ".pdopt"
1886 1887
    if os.path.exists(opt_file_name):
        with open(opt_file_name, 'rb') as f:
1888 1889
            opti_dict = pickle.load(f) if six.PY2 else pickle.load(
                f, encoding='latin1')
1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925

        para_dict.update(opti_dict)

    return para_dict


def set_program_state(program, state_dict):
    """
    Set program parameter from state_dict

    An exception will throw if shape or dtype of the parameters is not match. 

    NOTICE: This function MUST called after run start_up_program

    Args:
        program(Program): The program to be set
        state_dict(dict): the dict store Parameter and optimizer information
    Returns: 
        None
    
    Examples:
        .. code-block:: python
            
            import paddle.fluid as fluid
            x = fluid.data( name="x", shape=[10, 10], dtype='float32')
            y = fluid.layers.fc( x, 10)
            z = fluid.layers.fc( y, 10)

            place = fluid.CPUPlace()
            exe = fluid.Executor(place)
            exe.run( fluid.default_startup_program() )
            prog = fluid.default_main_program()

            fluid.save( prog, "./temp")
            program_state = fluid.load_program_state( "./temp")

H
hong 已提交
1926 1927
            fluid.set_program_state( prog, program_state)

1928 1929 1930 1931 1932 1933 1934
    """
    parameter_list = list(filter(is_persistable, program.list_vars()))

    used_para_list = {}
    for para in parameter_list:
        var_temp = paddle.fluid.global_scope().find_var(para.name)
        assert var_temp != None, \
T
tangwei12 已提交
1935
            "Variable [ {} ] Not found, Please make sure run startup program".format(para.name)
1936 1937 1938 1939
        if para.name in state_dict:
            # set value from state dict
            orig_para_np = np.array(var_temp.get_tensor())
            new_para_np = state_dict[para.name]
T
tangwei12 已提交
1940 1941 1942
            assert orig_para_np.shape == new_para_np.shape, \
                "Shape not matching: the Program requires a parameter with a shape of ({}), " \
                "while the loaded parameter (namely [ {} ]) has a shape of  ({})." \
1943
                    .format(orig_para_np.shape, para.name, new_para_np.shape)
T
tangwei12 已提交
1944 1945 1946
            assert orig_para_np.dtype == new_para_np.dtype, \
                "Dtype not matching: the Program requires a parameter with a dtype of ({}), " \
                "while the loaded parameter (namely [ {} ]) has a dtype of  ({})." \
1947 1948 1949 1950 1951 1952
                    .format(orig_para_np.dtype, para.name, new_para_np.dtype)

            ten = var_temp.get_tensor()
            ten_place = ten._place()

            assert ten_place.is_gpu_place() or ten_place.is_cpu_place(), \
T
tangwei12 已提交
1953
                "Place not support, only support CPUPlace and GPUPlace, now is {}".format(str(ten_place))
1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973
            py_place = paddle.fluid.CPUPlace()
            if ten_place.is_cuda_pinned_place():
                place = paddle.fluid.CUDAPinnedPlace()
            elif ten_place.is_gpu_place():
                p = paddle.fluid.core.Place()
                p.set_place(ten_place)
                py_place = paddle.fluid.CUDAPlace(p.gpu_device_id())

            ten.set(new_para_np, py_place)

            used_para_list[para.name] = 1

    unused_para_list = []
    for k, v in state_dict.items():
        if k not in used_para_list:
            unused_para_list.append(k)
    if len(unused_para_list) > 0:
        warnings.warn(
            "This list is not set, Because of Paramerter not found in program. There are: {}".
            format(" ".join(unused_para_list)))