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

15 16
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
22
from functools import reduce
23

24
from paddle.fluid import layers
X
Xin Pan 已提交
25
from paddle.fluid.executor import Executor
26
from paddle.fluid.evaluator import Evaluator
27
from paddle.fluid.framework import Program, Parameter, default_main_program, default_startup_program, Variable, program_guard
28
from paddle.fluid.log_helper import get_logger
S
sneaxiy 已提交
29 30
from . import reader
from .reader import *
K
fix bug  
Kexin Zhao 已提交
31
from . import core
32
from .. import compat as cpt
33 34

__all__ = [
T
tangwei12 已提交
35
    'save_vars', 'save_params', 'save_persistables', 'load_vars', 'load_params',
36
    'load_persistables', 'save_inference_model', 'load_inference_model'
S
sneaxiy 已提交
37
] + reader.__all__
38

39 40
_logger = get_logger(
    __name__, logging.INFO, fmt='%(asctime)s-%(levelname)s: %(message)s')
41

42 43

def is_parameter(var):
F
fengjiayi 已提交
44 45
    """
    Check whether the given variable is an instance of Parameter.
46 47

    Args:
F
fengjiayi 已提交
48
        var(Variable): The variable to be checked.
49 50

    Returns:
F
fengjiayi 已提交
51 52 53 54 55 56 57 58
        bool: True if the given `var` is an instance of Parameter,
        False if not.

    Examples:
        .. code-block:: python

            param = fluid.default_main_program().global_block().var('fc.w')
            res = fluid.io.is_parameter(param)
59
    """
60 61 62 63
    return isinstance(var, Parameter)


def is_persistable(var):
F
fengjiayi 已提交
64 65 66 67 68 69 70 71 72 73 74 75 76
    """
    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

77
            param = fluid.default_main_program().global_block().var('fc.b')
F
fengjiayi 已提交
78 79
            res = fluid.io.is_persistable(param)
    """
80
    if var.desc.type() == core.VarDesc.VarType.FEED_MINIBATCH or \
Y
yuyang18 已提交
81 82
            var.desc.type() == core.VarDesc.VarType.FETCH_LIST or \
            var.desc.type() == core.VarDesc.VarType.READER:
83
        return False
84 85 86 87 88 89 90 91
    return var.persistable


def _clone_var_in_block_(block, var):
    assert isinstance(var, Variable)
    return block.create_var(
        name=var.name,
        shape=var.shape,
92
        dtype=var.dtype,
93 94 95 96 97
        type=var.type,
        lod_level=var.lod_level,
        persistable=True)


98 99 100 101 102
def save_vars(executor,
              dirname,
              main_program=None,
              vars=None,
              predicate=None,
103
              filename=None):
104
    """
F
fengjiayi 已提交
105 106
    Save variables to the given directory by executor.

107 108 109 110
    There are two ways to specify variables to be saved: The first way, list
    variables in a list and assign it to the `vars`. The second way, assign the
    `main_program` with an existing program, then all variables in the program
    will be saved. The first way has a higher priority. In other words, if `vars`
F
fengjiayi 已提交
111
    are assigned, the `main_program` and the `predicate` will be ignored.
112

113 114 115
    The `dirname` are used to specify the folder where to save variables.
    If you prefer to save variables in separate files in the folder `dirname`,
    set `filename` None; if you prefer to save all variables in a single file,
F
fengjiayi 已提交
116
    use `filename` to specify it.
117

F
fengjiayi 已提交
118 119 120
    Args:
        executor(Executor): The executor to run for saving variables.
        dirname(str): The directory path.
121 122
        main_program(Program|None): The program whose variables will be saved.
                                    If it is None, the default main program will
F
fengjiayi 已提交
123 124
                                    be used automatically.
                                    Default: None
125
        vars(list[Variable]|None): The list that contains all variables to save.
F
fengjiayi 已提交
126 127
                                   It has a higher priority than the `main_program`.
                                   Default: None
128 129 130 131
        predicate(function|None): If it is not None, only variables in the
                                  `main_program` that makes predicate(variable)==True
                                  will be saved. It only works when we are using the
                                  `main_program` to specify variables (In other words
F
fengjiayi 已提交
132 133
                                  `vars` is None).
                                  Default: None
134
        filename(str|None): The file which to save all variables. If you prefer to save
F
fengjiayi 已提交
135 136 137 138 139 140 141 142 143 144 145 146
                            variables separately, set it to None.
                            Default: None

    Returns:
        None

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

    Examples:
        .. code-block:: python

147 148 149 150 151 152 153 154 155 156 157 158
            import paddle.fluid as fluid
            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 已提交
159

160
            param_path = "./my_paddle_model"
F
fengjiayi 已提交
161 162 163 164
            # The first usage: using `main_program` to specify variables
            def name_has_fc(var):
                res = "fc" in var.name
                return res
165
            fluid.io.save_vars(executor=exe, dirname=param_path, main_program=main_prog,
C
chengduo 已提交
166
                               vars=None, predicate = name_has_fc)
F
fengjiayi 已提交
167 168 169 170 171
            # All variables in `main_program` whose name includes "fc" will be saved.
            # And variables are going to be saved separately.


            # The second usage: using `vars` to specify variables
172 173
            var_list = [w, b]
            path = "./my_paddle_vars"
174
            fluid.io.save_vars(executor=exe, dirname=path, vars=var_list,
F
fengjiayi 已提交
175 176
                               filename="vars_file")
            # var_a, var_b and var_c will be saved. And they are going to be
177
            # saved in the same file named 'var_file' in the path "./my_paddle_vars".
178
    """
L
lujun 已提交
179
    save_dirname = os.path.normpath(dirname)
180
    if vars is None:
181
        if main_program is None:
182
            main_program = default_main_program()
183
        if not isinstance(main_program, Program):
184 185 186 187
            raise TypeError("program should be as Program type or None")

        save_vars(
            executor,
188
            main_program=main_program,
L
lujun 已提交
189
            dirname=save_dirname,
190
            vars=list(filter(predicate, main_program.list_vars())),
191
            filename=filename)
192 193 194
    else:
        save_program = Program()
        save_block = save_program.global_block()
195

196 197 198 199 200
        if main_program is None:
            main_program = default_main_program()
        if not isinstance(main_program, Program):
            raise TypeError("program should be as Program type or None")

201
        save_var_map = {}
202
        for each_var in vars:
203 204 205
            # NOTE: don't save the variable which type is RAW
            if each_var.type == core.VarDesc.VarType.RAW:
                continue
206
            new_var = _clone_var_in_block_(save_block, each_var)
207
            if filename is None:
208 209 210 211
                save_block.append_op(
                    type='save',
                    inputs={'X': [new_var]},
                    outputs={},
L
lujun 已提交
212 213 214
                    attrs={
                        'file_path': os.path.join(save_dirname, new_var.name)
                    })
215 216 217
            else:
                save_var_map[new_var.name] = new_var

218
        if filename is not None:
219 220 221 222
            save_var_list = []
            for name in sorted(save_var_map.keys()):
                save_var_list.append(save_var_map[name])

223
            save_block.append_op(
224 225
                type='save_combine',
                inputs={'X': save_var_list},
226
                outputs={},
L
lujun 已提交
227
                attrs={'file_path': os.path.join(save_dirname, filename)})
228

229 230 231
        executor.run(save_program)


232
def save_params(executor, dirname, main_program=None, filename=None):
233
    """
F
fengjiayi 已提交
234 235 236
    This function filters out all parameters from the give `main_program`
    and then save them to the folder `dirname` or the file `filename`.

237 238 239
    Use the `dirname` to specify the saving folder. If you would like to
    save parameters in separate files, set `filename` None; if you would
    like to save all parameters in a single file, use `filename` to specify
F
fengjiayi 已提交
240 241
    the file name.

242 243 244
    NOTICE: Some variables are not Parameter while they are necessary for
    training. So you can NOT save and continue your training just by
    `save_params()` and `load_params()`. Please use `save_persistables()`
245 246 247
    and `load_persistables()` instead. If you want to save your model for
    the inference, please use the `save_inference_model` API. You can refer
    to :ref:`api_guide_model_save_reader_en` for more details.
F
fengjiayi 已提交
248 249 250 251 252 253 254 255

    Args:
        executor(Executor): The executor to run for saving parameters.
        dirname(str): The saving directory path.
        main_program(Program|None): The program whose parameters will be
                                    saved. If it is None, the default
                                    main program will be used automatically.
                                    Default: None
256 257
        filename(str|None): The file to save all parameters. If you prefer
                            to save parameters in differnet files, set it
F
fengjiayi 已提交
258 259 260 261 262 263 264 265 266 267 268 269
                            to None.
                            Default: None

    Returns:
        None

    Examples:
        .. code-block:: python

            exe = fluid.Executor(fluid.CPUPlace())
            param_path = "./my_paddle_model"
            prog = fluid.default_main_program()
270
            fluid.io.save_params(executor=exe, dirname=param_path,
F
fengjiayi 已提交
271
                                 main_program=None)
272 273 274 275
    """
    save_vars(
        executor,
        dirname=dirname,
276
        main_program=main_program,
277
        vars=None,
278
        predicate=is_parameter,
279
        filename=filename)
280 281


282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461
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

            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():
            origin_var = None
            is_slice = False
            slice_vars = [0] * len(remote_params)
            slice_var_names = [""] * len(remote_params)
            endpoints = [""] * len(remote_params)

            for idx, optimizer in enumerate(remote_params):
                origin = optimizer.origin
                slice = optimizer.slice
                is_slice = optimizer.is_slice
                block_id = optimizer.block_id
                endpoint = optimizer.endpoint

                if idx == 0:
                    origin_var = block.create_var(
                        name=origin.name,
                        type=origin.type,
                        shape=origin.shape,
                        dtype=origin.dtype,
                        persistable=True)

                slice_var = block.create_var(
                    name="{}.slice.{}".format(slice.name, idx),
                    type=slice.type,
                    shape=slice.shape,
                    dtype=slice.dtype,
                    persistable=True)

                index = block_id if is_slice else idx
                slice_vars[index] = slice_var
                slice_var_names[index] = slice.name
                endpoints[index] = endpoint

            if is_slice:
                block.append_op(
                    type='recv',
                    inputs={"X": []},
                    outputs={"Out": slice_vars},
                    attrs={
                        "epmap": endpoints,
                        "with_barrier": False,
                        "varnames": slice_var_names,
                        "sync_mode": True
                    })
                block.append_op(
                    type='concat',
                    inputs={'X': slice_vars},
                    outputs={'Out': origin_var},
                    attrs={})
            else:
                block.append_op(
                    type='recv',
                    inputs={"X": []},
                    outputs={"Out": [origin_var]},
                    attrs={
                        "epmap": endpoints[:1],
                        "with_barrier": False,
                        "varnames": slice_var_names,
                        "sync_mode": True
                    })
            block.append_op(
                type='save',
                inputs={'X': [origin_var]},
                outputs={},
                attrs={'file_path': os.path.join(dirname, origin_var.name)})
            block.append_op(type='delete_var', inputs={'X': slice_vars})
        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 \
                        var.desc.type() == core.VarDesc.VarType.FETCH_LIST or \
                        var.desc.type() == core.VarDesc.VarType.READER:
                return False
            return var.persistable

        return is_valid

    if not isinstance(main_program, Program):
        raise ValueError("'main_program' should be an instance of Program.")

    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)


462
def save_persistables(executor, dirname, main_program=None, filename=None):
463
    """
464 465
    This function filters out all variables with `persistable==True` from the
    give `main_program` and then saves these variables to the folder `dirname`
F
fengjiayi 已提交
466 467
    or file `filename`.

468 469 470
    The `dirname` is used to specify the folder where persistable variables
    are going to be saved. If you would like to save variables in separate
    files, set `filename` None; if you would like to save all variables in a
F
fengjiayi 已提交
471 472 473 474 475
    single file, use `filename` to specify the file name.

    Args:
        executor(Executor): The executor to run for saving persistable variables.
        dirname(str): The directory path.
476 477
        main_program(Program|None): The program whose persistbale variables will
                                    be saved. If it is None, the default main
F
fengjiayi 已提交
478 479
                                    program will be used automatically.
                                    Default: None
480
        filename(str|None): The file to saved all variables. If you prefer to
F
fengjiayi 已提交
481 482 483 484 485 486 487 488 489 490 491
                            save variables in differnet files, set it to None.
                            Default: None

    Returns:
        None

    Examples:
        .. code-block:: python

            exe = fluid.Executor(fluid.CPUPlace())
            param_path = "./my_paddle_model"
492
            # `prog` can be a program defined by the user
F
fengjiayi 已提交
493
            prog = fluid.default_main_program()
494
            fluid.io.save_persistables(executor=exe, dirname=param_path,
495
                                       main_program=prog)
496
    """
497 498 499 500 501 502 503 504 505 506 507 508 509

    if main_program and main_program._is_distributed:
        _save_distributed_persistables(
            executor, dirname=dirname, main_program=main_program)

    else:
        save_vars(
            executor,
            dirname=dirname,
            main_program=main_program,
            vars=None,
            predicate=is_persistable,
            filename=filename)
510 511


512 513 514 515 516
def load_vars(executor,
              dirname,
              main_program=None,
              vars=None,
              predicate=None,
517
              filename=None):
518
    """
F
fengjiayi 已提交
519 520
    Load variables from the given directory by executor.

521 522 523 524
    There are two ways to specify variables to be loaded: The first way, list
    variables in a list and assign it to the `vars`. The second way, assign the
    `main_program` with an existing program, then all variables in the program
    will be loaded. The first way has a higher priority. In other words if `vars`
F
fengjiayi 已提交
525 526
    are assigned, the `main_program` and the `predicate` will be ignored.

527 528 529
    The `dirname` are used to specify the folder where to load variables.
    If variables were saved in separate files in the folder `dirname`,
    set `filename` None; if all variables were saved in a single file,
F
fengjiayi 已提交
530
    use `filename` to specify it.
531

F
fengjiayi 已提交
532 533 534
    Args:
        executor(Executor): The executor to run for loading variables.
        dirname(str): The directory path.
535 536
        main_program(Program|None): The program whose variables will be loaded.
                                    If it is None, the default main program will
F
fengjiayi 已提交
537 538
                                    be used automatically.
                                    Default: None
539
        vars(list[Variable]|None): The list that contains all variables to load.
F
fengjiayi 已提交
540 541
                                   It has a higher priority than the `main_program`.
                                   Default: None
542 543 544 545
        predicate(function|None): If it is not None, only variables in the
                                  `main_program` that makes predicate(variable)==True
                                  will be loaded. It only works when we are using the
                                  `main_program` to specify variables (In other words
F
fengjiayi 已提交
546 547
                                  `vars` is None).
                                  Default: None
548
        filename(str|None): The file which saved all required variables. If variables
F
fengjiayi 已提交
549 550 551 552 553 554 555 556 557 558 559 560
                            were saved in differnet files, set it to None.
                            Default: None

    Returns:
        None

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

    Examples:
        .. code-block:: python

561 562 563 564 565 566 567 568 569 570 571 572
            import paddle.fluid as fluid
            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 已提交
573

574
            param_path = "./my_paddle_model"
F
fengjiayi 已提交
575 576 577 578
            # The first usage: using `main_program` to specify variables
            def name_has_fc(var):
                res = "fc" in var.name
                return res
579 580 581
            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 已提交
582
                               vars=None, predicate=name_has_fc)
F
fengjiayi 已提交
583 584 585 586
            # All variables in `main_program` whose name includes "fc" will be loaded.
            # And all the variables are supposed to have been saved in differnet files.

            # The second usage: using `vars` to specify variables
587 588 589 590
            path = "./my_paddle_vars"
            var_list = [w, b]
            fluid.io.save_vars(executor=exe, dirname=path, vars=var_list,
                               filename="vars_file")
591
            fluid.io.load_vars(executor=exe, dirname=path, vars=var_list,
F
fengjiayi 已提交
592
                               filename="vars_file")
593 594
            # w and b will be loaded. And they are supposed to haven
            # been saved in the same file named 'var_file' in the path "./my_paddle_vars".
595
    """
L
lujun 已提交
596
    load_dirname = os.path.normpath(dirname)
597
    if vars is None:
598
        if main_program is None:
599
            main_program = default_main_program()
600
        if not isinstance(main_program, Program):
601 602 603 604
            raise TypeError("program's type should be Program")

        load_vars(
            executor,
L
lujun 已提交
605
            dirname=load_dirname,
606
            main_program=main_program,
607
            vars=list(filter(predicate, main_program.list_vars())),
608
            filename=filename)
609 610 611
    else:
        load_prog = Program()
        load_block = load_prog.global_block()
612

613 614 615 616 617
        if main_program is None:
            main_program = default_main_program()
        if not isinstance(main_program, Program):
            raise TypeError("program should be as Program type or None")

618
        load_var_map = {}
619 620
        for each_var in vars:
            assert isinstance(each_var, Variable)
T
tangwei12 已提交
621 622
            if each_var.type == core.VarDesc.VarType.RAW:
                continue
623
            new_var = _clone_var_in_block_(load_block, each_var)
624
            if filename is None:
625 626 627 628
                load_block.append_op(
                    type='load',
                    inputs={},
                    outputs={'Out': [new_var]},
L
lujun 已提交
629 630 631
                    attrs={
                        'file_path': os.path.join(load_dirname, new_var.name)
                    })
632 633 634
            else:
                load_var_map[new_var.name] = new_var

635
        if filename is not None:
636 637 638 639
            load_var_list = []
            for name in sorted(load_var_map.keys()):
                load_var_list.append(load_var_map[name])

640
            load_block.append_op(
641
                type='load_combine',
642
                inputs={},
643
                outputs={"Out": load_var_list},
L
lujun 已提交
644
                attrs={'file_path': os.path.join(load_dirname, filename)})
645 646 647
        executor.run(load_prog)


648
def load_params(executor, dirname, main_program=None, filename=None):
649
    """
F
fengjiayi 已提交
650
    This function filters out all parameters from the give `main_program`
F
fengjiayi 已提交
651
    and then trys to load these parameters from the folder `dirname` or
F
fengjiayi 已提交
652 653
    the file `filename`.

654 655 656
    Use the `dirname` to specify the folder where parameters were saved. If
    parameters were saved in separate files in the folder `dirname`, set
    `filename` None; if all parameters were saved in a single file, use
F
fengjiayi 已提交
657 658
    `filename` to specify the file name.

659 660 661 662
    NOTICE: Some variables are not Parameter while they are necessary for
    training. So you can NOT save and continue your training just by
    `save_params()` and `load_params()`. Please use `save_persistables()`
    and `load_persistables()` instead.
663 664 665
    If you want to load the pre-trained model structure and parameters
    for the inference, please use the `load_inference_model` API. You can
    refer to :ref:`api_guide_model_save_reader_en` for more details.
F
fengjiayi 已提交
666 667 668 669 670 671 672 673

    Args:
        executor(Executor): The executor to run for loading parameters.
        dirname(str): The directory path.
        main_program(Program|None): The program whose parameters will be
                                    loaded. If it is None, the default
                                    main program will be used automatically.
                                    Default: None
674
        filename(str|None): The file which saved all parameters. If parameters
F
fengjiayi 已提交
675 676 677 678 679 680 681 682 683 684 685 686
                            were saved in differnet files, set it to None.
                            Default: None

    Returns:
        None

    Examples:
        .. code-block:: python

            exe = fluid.Executor(fluid.CPUPlace())
            param_path = "./my_paddle_model"
            prog = fluid.default_main_program()
687
            fluid.io.load_params(executor=exe, dirname=param_path,
F
fengjiayi 已提交
688
                                main_program=None)
689 690
    """
    load_vars(
691 692 693
        executor,
        dirname=dirname,
        main_program=main_program,
694
        predicate=is_parameter,
695
        filename=filename)
696 697


698
def load_persistables(executor, dirname, main_program=None, filename=None):
699
    """
700 701
    This function filters out all variables with `persistable==True` from the
    give `main_program` and then trys to load these variables from the folder
F
fengjiayi 已提交
702 703
    `dirname` or the file `filename`.

704 705 706
    Use the `dirname` to specify the folder where persistable variables were
    saved. If variables were saved in separate files, set `filename` None;
    if all variables were saved in a single file, use `filename` to specify
F
fengjiayi 已提交
707 708 709 710 711
    the file name.

    Args:
        executor(Executor): The executor to run for loading persistable variables.
        dirname(str): The directory path.
712 713
        main_program(Program|None): The program whose persistbale variables will
                                    be loaded. If it is None, the default main
F
fengjiayi 已提交
714 715
                                    program will be used automatically.
                                    Default: None
716
        filename(str|None): The file which saved all variables. If variables were
F
fengjiayi 已提交
717 718 719 720 721 722 723 724 725 726 727 728
                            saved in differnet files, set it to None.
                            Default: None

    Returns:
        None

    Examples:
        .. code-block:: python

            exe = fluid.Executor(fluid.CPUPlace())
            param_path = "./my_paddle_model"
            prog = fluid.default_main_program()
729
            fluid.io.load_persistables(executor=exe, dirname=param_path,
F
fengjiayi 已提交
730
                                       main_program=None)
731
    """
732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809

    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

            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:
                origin = load_block.create_var(
                    name="{}.load".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)
                    })

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

810 811 812 813
                dim1_flatten = 1
                if len(slice.shape) >= 2:
                    dim1_flatten = reduce(lambda x, y: x * y, slice.shape[1:])

814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862
                start = int(offset / dim1_flatten)
                end = int(offset / dim1_flatten + slice.shape[0])

                load_block.append_op(
                    type="slice",
                    inputs={'Input': origin},
                    outputs={'Out': slice},
                    attrs={'axes': [0],
                           'starts': [start],
                           'ends': [end]})

                need_delete_vars.append(origin)
            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):
        raise ValueError("'main_program' should be an instance of Program.")

    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)
863 864


865 866 867
def prepend_feed_ops(inference_program,
                     feed_target_names,
                     feed_holder_name='feed'):
868 869 870
    if len(feed_target_names) == 0:
        return

K
Kexin Zhao 已提交
871 872
    global_block = inference_program.global_block()
    feed_var = global_block.create_var(
873 874 875
        name=feed_holder_name,
        type=core.VarDesc.VarType.FEED_MINIBATCH,
        persistable=True)
K
Kexin Zhao 已提交
876

877
    for i, name in enumerate(feed_target_names):
K
fix bug  
Kexin Zhao 已提交
878
        out = global_block.var(name)
W
Wu Yi 已提交
879
        global_block._prepend_op(
K
Kexin Zhao 已提交
880 881
            type='feed',
            inputs={'X': [feed_var]},
K
fix bug  
Kexin Zhao 已提交
882
            outputs={'Out': [out]},
K
Kexin Zhao 已提交
883 884 885
            attrs={'col': i})


886 887 888
def append_fetch_ops(inference_program,
                     fetch_target_names,
                     fetch_holder_name='fetch'):
K
Kexin Zhao 已提交
889 890
    global_block = inference_program.global_block()
    fetch_var = global_block.create_var(
891 892 893
        name=fetch_holder_name,
        type=core.VarDesc.VarType.FETCH_LIST,
        persistable=True)
K
Kexin Zhao 已提交
894

895
    for i, name in enumerate(fetch_target_names):
K
Kexin Zhao 已提交
896 897 898 899 900 901 902
        global_block.append_op(
            type='fetch',
            inputs={'X': [name]},
            outputs={'Out': [fetch_var]},
            attrs={'col': i})


903 904 905 906
def save_inference_model(dirname,
                         feeded_var_names,
                         target_vars,
                         executor,
907
                         main_program=None,
908
                         model_filename=None,
909 910
                         params_filename=None,
                         export_for_deployment=True):
911
    """
F
fengjiayi 已提交
912 913
    Prune the given `main_program` to build a new program especially for inference,
    and then save it and all related parameters to given `dirname` by the `executor`.
914 915 916 917
    If you just want to save parameters of your trained model, please use the
    `save_params` API. You can refer to :ref:`api_guide_model_save_reader_en` for
    more details.

F
fengjiayi 已提交
918 919 920

    Args:
        dirname(str): The directory path to save the inference model.
921
        feeded_var_names(list[str]): Names of variables that need to be feeded data
F
fengjiayi 已提交
922
                                     during inference.
923
        target_vars(list[Variable]): Variables from which we can get inference
F
fengjiayi 已提交
924 925
                                     results.
        executor(Executor): The executor that saves the inference model.
926 927
        main_program(Program|None): The original program, which will be pruned to
                                    build the inference model. If is setted None,
F
fengjiayi 已提交
928 929
                                    the default main program will be used.
                                    Default: None.
930 931
        model_filename(str|None): The name of file to save the inference program
                                  itself. If is setted None, a default filename
F
fengjiayi 已提交
932
                                  `__model__` will be used.
933 934
        params_filename(str|None): The name of file to save all related parameters.
                                   If it is setted None, parameters will be saved
F
fengjiayi 已提交
935
                                   in separate files .
X
Xin Pan 已提交
936 937 938 939 940
        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.
941

F
fengjiayi 已提交
942
    Returns:
943
        target_var_name_list(list): The fetch variables' name list
F
fengjiayi 已提交
944 945 946 947 948 949 950

    Raises:
        ValueError: If `feed_var_names` is not a list of basestring.
        ValueError: If `target_vars` is not a list of Variable.

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

952 953
            import paddle.fluid as fluid

F
fengjiayi 已提交
954 955
            path = "./infer_model"

956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977
            # User defined network, here a softmax regresssion example
            image = fluid.layers.data(name='img', shape=[1, 28, 28], dtype='float32')
            label = fluid.layers.data(name='label', shape=[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)

            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)

            # In this example, the function will prune the default main program
            # to make it suitable for infering the `predict` var. The pruned
978
            # inference program is going to be saved in the "./infer_model/__model__"
F
fengjiayi 已提交
979
            # and parameters are going to be saved in separate files under folder
980
            # "./infer_model".
981 982

    """
M
minqiyang 已提交
983
    if isinstance(feeded_var_names, six.string_types):
F
fengjiayi 已提交
984
        feeded_var_names = [feeded_var_names]
X
Xin Pan 已提交
985
    elif export_for_deployment:
986
        if len(feeded_var_names) > 0:
987
            # TODO(paddle-dev): polish these code blocks
988
            if not (bool(feeded_var_names) and all(
M
minqiyang 已提交
989
                    isinstance(name, six.string_types)
990
                    for name in feeded_var_names)):
M
minqiyang 已提交
991
                raise ValueError("'feed_var_names' should be a list of str.")
F
fengjiayi 已提交
992 993

    if isinstance(target_vars, Variable):
F
fengjiayi 已提交
994
        target_vars = [target_vars]
X
Xin Pan 已提交
995
    elif export_for_deployment:
996 997
        if not (bool(target_vars) and
                all(isinstance(var, Variable) for var in target_vars)):
F
fengjiayi 已提交
998 999
            raise ValueError("'target_vars' should be a list of Variable.")

1000
    if main_program is None:
1001
        main_program = default_main_program()
1002
        if main_program._is_mem_optimized:
D
dzhwinter 已提交
1003 1004 1005 1006 1007 1008
            warnings.warn(
                "save_inference_model must put before you call memory_optimize. \
                                            the memory_optimize will modify the original program, \
                                            is not suitable for saving inference model \
                                            we save the original program as inference model.",
                RuntimeWarning)
X
Xin Pan 已提交
1009

1010 1011 1012 1013 1014
    # fix the bug that the activation op's output as target will be pruned.
    # will affect the inference performance.
    # TODO(Superjomn) add an IR pass to remove 1-scale op.
    with program_guard(main_program):
        uniq_target_vars = []
1015
        for i, var in enumerate(target_vars):
1016
            if isinstance(var, Variable):
1017 1018 1019
                var = layers.scale(
                    var, 1., name="save_infer_model/scale_{}".format(i))
            uniq_target_vars.append(var)
1020
        target_vars = uniq_target_vars
1021
    target_var_name_list = [var.name for var in target_vars]
1022

1023
    # when a pserver and a trainer running on the same machine, mkdir may conflict
L
lujun 已提交
1024
    save_dirname = dirname
1025
    try:
L
lujun 已提交
1026 1027
        save_dirname = os.path.normpath(dirname)
        os.makedirs(save_dirname)
1028 1029 1030 1031
    except OSError as e:
        if e.errno != errno.EEXIST:
            raise

X
Xin Pan 已提交
1032 1033 1034 1035
    if model_filename is not None:
        model_basename = os.path.basename(model_filename)
    else:
        model_basename = "__model__"
L
lujun 已提交
1036
    model_basename = os.path.join(save_dirname, model_basename)
1037

X
Xin Pan 已提交
1038 1039 1040 1041
    # 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.
1042 1043 1044

    origin_program = main_program.clone()

X
Xin Pan 已提交
1045
    if export_for_deployment:
X
Xin Pan 已提交
1046 1047
        main_program = main_program.clone()
        global_block = main_program.global_block()
1048
        need_to_remove_op_index = []
X
Xin Pan 已提交
1049 1050 1051
        for i, op in enumerate(global_block.ops):
            op.desc.set_is_target(False)
            if op.type == "feed" or op.type == "fetch":
1052 1053 1054 1055 1056
                need_to_remove_op_index.append(i)

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

X
Xin Pan 已提交
1057
        main_program.desc.flush()
X
Xin Pan 已提交
1058

X
Xin Pan 已提交
1059 1060
        main_program = main_program._prune(targets=target_vars)
        main_program = main_program._inference_optimize(prune_read_op=True)
X
Xin Pan 已提交
1061 1062
        fetch_var_names = [v.name for v in target_vars]

X
Xin Pan 已提交
1063 1064 1065 1066 1067
        prepend_feed_ops(main_program, feeded_var_names)
        append_fetch_ops(main_program, fetch_var_names)

        with open(model_basename, "wb") as f:
            f.write(main_program.desc.serialize_to_string())
X
Xin Pan 已提交
1068 1069 1070
    else:
        # TODO(panyx0718): Save more information so that it can also be used
        # for training and more flexible post-processing.
X
Xin Pan 已提交
1071 1072
        with open(model_basename + ".main_program", "wb") as f:
            f.write(main_program.desc.serialize_to_string())
1073

1074 1075
    main_program._copy_dist_param_info_from(origin_program)

X
fix  
Xin Pan 已提交
1076 1077
    if params_filename is not None:
        params_filename = os.path.basename(params_filename)
1078

L
lujun 已提交
1079
    save_persistables(executor, save_dirname, main_program, params_filename)
1080
    return target_var_name_list
X
fix  
Xin Pan 已提交
1081

1082

1083 1084 1085
def load_inference_model(dirname,
                         executor,
                         model_filename=None,
1086 1087
                         params_filename=None,
                         pserver_endpoints=None):
1088
    """
1089 1090 1091 1092
    Load inference model from a 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 `load_params` API.
    You can refer to :ref:`api_guide_model_save_reader_en` for more details.
1093

F
fengjiayi 已提交
1094 1095 1096 1097
    Args:
        dirname(str): The directory path
        executor(Executor): The executor to run for loading inference model.
        model_filename(str|None): The name of file to load inference program.
1098
                                  If it is None, the default filename
F
fengjiayi 已提交
1099 1100 1101
                                  '__model__' will be used.
                                  Default: None
        params_filename(str|None): The name of file to load all parameters.
1102 1103 1104
                                   It is only used for the case that all
                                   parameters were saved in a single binary
                                   file. If parameters were saved in separate
F
fengjiayi 已提交
1105
                                   files, set it as 'None'.
1106 1107 1108 1109
        pserver_endpoints(list|None): This only need by distributed inference.
                                    When use distributed look up table in training,
                                    We also need it in inference.The parameter is
                                    a list of pserver endpoints.
F
fengjiayi 已提交
1110 1111 1112

    Returns:
        tuple: The return of this function is a tuple with three elements:
1113 1114 1115 1116 1117
        (program, feed_target_names, fetch_targets). The `program` is a
        Program, it's the program for inference. The `feed_target_names` is
        a list of str, it contains Names of variables that need to feed
        data in the inference program. The `fetch_targets` is a list of
        Variable. It contains variables from which we can get inference
F
fengjiayi 已提交
1118 1119 1120 1121 1122 1123 1124 1125
        results.

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

    Examples:
        .. code-block:: python

1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138
            import paddle.fluid as fluid
            import numpy as np
            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)
F
fengjiayi 已提交
1139
            path = "./infer_model"
1140 1141 1142
            fluid.io.save_inference_model(dirname=path, feeded_var_names=['img'],
                         target_vars=[hidden_b], executor=exe, main_program=main_prog)
            tensor_img = np.array(np.random.random((1, 64, 784)), dtype=np.float32)
1143 1144
            [inference_program, feed_target_names, fetch_targets] = (
                fluid.io.load_inference_model(dirname=path, executor=exe))
F
fengjiayi 已提交
1145 1146 1147 1148
            results = exe.run(inference_program,
                          feed={feed_target_names[0]: tensor_img},
                          fetch_list=fetch_targets)

1149 1150
            # endpoints is your pserver endpoints list, the above is just an example
            endpoints = ["127.0.0.1:2023","127.0.0.1:2024"]
1151
            # if we need lookup table, we will use:
1152
            [dist_inference_program, dist_feed_target_names, dist_fetch_targets] = (
1153 1154
                fluid.io.load_inference_model(dirname=path,
                                              executor=exe,
1155
                                              pserver_endpoints=endpoints))
1156

1157
            # In this example, the inference program was saved in the
1158
            # "./infer_model/__model__" and parameters were saved in
1159
            # separate files in "./infer_model".
1160 1161
            # After getting inference program, feed target names and
            # fetch targets, we can use an Executor to run the inference
F
fengjiayi 已提交
1162
            # program to get the inference result.
1163
    """
L
lujun 已提交
1164 1165
    load_dirname = os.path.normpath(dirname)
    if not os.path.isdir(load_dirname):
1166 1167
        raise ValueError("There is no directory named '%s'", dirname)

1168 1169
    if model_filename is not None:
        model_filename = os.path.basename(model_filename)
1170
    else:
1171
        model_filename = "__model__"
L
lujun 已提交
1172
    model_filename = os.path.join(load_dirname, model_filename)
1173 1174 1175

    if params_filename is not None:
        params_filename = os.path.basename(params_filename)
1176

1177
    with open(model_filename, "rb") as f:
1178 1179
        program_desc_str = f.read()

1180
    program = Program.parse_from_string(program_desc_str)
X
Xin Pan 已提交
1181
    if not core._is_program_version_supported(program._version()):
X
version  
Xin Pan 已提交
1182 1183 1184
        raise ValueError("Unsupported program version: %d\n" %
                         program._version())
    # Binary data also need versioning.
L
lujun 已提交
1185
    load_persistables(executor, load_dirname, program, params_filename)
1186

1187
    if pserver_endpoints:
T
tangwei12 已提交
1188
        program = _endpoints_replacement(program, pserver_endpoints)
1189

1190 1191
    feed_target_names = program.desc.get_feed_target_names()
    fetch_target_names = program.desc.get_fetch_target_names()
1192 1193 1194 1195 1196
    fetch_targets = [
        program.global_block().var(name) for name in fetch_target_names
    ]

    return [program, feed_target_names, fetch_targets]
X
xuwei06 已提交
1197 1198


1199 1200 1201
def _endpoints_replacement(program, endpoints):
    ENDPOINT_MAP = "epmap"
    for op in program.global_block().ops:
T
tangwei12 已提交
1202 1203
        if op.has_attr(ENDPOINT_MAP):
            op.set_attr(ENDPOINT_MAP, endpoints)
T
fix  
tangwei12 已提交
1204
    program._sync_with_cpp()
T
tangwei12 已提交
1205
    return program
1206 1207


X
xuwei06 已提交
1208 1209
def get_parameter_value(para, executor):
    """
F
fengjiayi 已提交
1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220
    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 已提交
1221

F
fengjiayi 已提交
1222 1223
    Examples:
        .. code-block:: python
X
xuwei06 已提交
1224

F
fengjiayi 已提交
1225 1226 1227
            exe = fluid.Executor(fluid.CPUPlace())
            param = fluid.default_main_program().global_block().var('fc.w')
            p = fluid.io.get_parameter_value(param, exe)
1228

X
xuwei06 已提交
1229
    """
1230 1231
    assert is_parameter(para)

X
xuwei06 已提交
1232 1233 1234 1235 1236 1237 1238 1239
    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 已提交
1240
    Get the LoDTensor value of a certain parameter by its name.
X
xuwei06 已提交
1241

F
fengjiayi 已提交
1242 1243 1244 1245 1246 1247 1248
    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 已提交
1249

F
fengjiayi 已提交
1250 1251
    Returns:
        numpy.array: The parameter's values.
1252

F
fengjiayi 已提交
1253 1254 1255 1256 1257
    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.
1258

F
fengjiayi 已提交
1259 1260 1261 1262 1263
    Examples:
        .. code-block:: python

            exe = fluid.Executor(fluid.CPUPlace())
            p = fluid.io.get_parameter_value('fc.w', exe)
X
xuwei06 已提交
1264 1265
    """
    if program is None:
1266
        program = default_main_program()
X
xuwei06 已提交
1267 1268
    var = program.global_block().var(name)
    return get_parameter_value(var, executor)
1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345


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)
反馈
建议
客服 返回
顶部