io.py 44.1 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
T
tangwei12 已提交
20 21
import time
import shutil
22
import six
23
from functools import reduce
24

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
K
fix bug  
Kexin Zhao 已提交
28
from . import core
29 30

__all__ = [
T
tangwei12 已提交
31
    'save_vars', 'save_params', 'save_persistables', 'load_vars', 'load_params',
32
    'load_persistables', 'save_inference_model', 'load_inference_model'
33 34 35 36
]


def is_parameter(var):
F
fengjiayi 已提交
37 38
    """
    Check whether the given variable is an instance of Parameter.
39 40

    Args:
F
fengjiayi 已提交
41
        var(Variable): The variable to be checked.
42 43

    Returns:
F
fengjiayi 已提交
44 45 46 47 48 49 50 51
        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)
52
    """
53 54 55 56
    return isinstance(var, Parameter)


def is_persistable(var):
F
fengjiayi 已提交
57 58 59 60 61 62 63 64 65 66 67 68 69
    """
    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

70
            param = fluid.default_main_program().global_block().var('fc.b')
F
fengjiayi 已提交
71 72
            res = fluid.io.is_persistable(param)
    """
73
    if var.desc.type() == core.VarDesc.VarType.FEED_MINIBATCH or \
Y
yuyang18 已提交
74 75
            var.desc.type() == core.VarDesc.VarType.FETCH_LIST or \
            var.desc.type() == core.VarDesc.VarType.READER:
76
        return False
77 78 79 80 81 82 83 84
    return var.persistable


def _clone_var_in_block_(block, var):
    assert isinstance(var, Variable)
    return block.create_var(
        name=var.name,
        shape=var.shape,
F
fengjiayi 已提交
85
        dtype=var.dtype,
86 87 88 89 90
        type=var.type,
        lod_level=var.lod_level,
        persistable=True)


91 92 93 94 95
def save_vars(executor,
              dirname,
              main_program=None,
              vars=None,
              predicate=None,
96
              filename=None):
97
    """
F
fengjiayi 已提交
98 99
    Save variables to the given directory by executor.

100 101 102 103
    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 已提交
104
    are assigned, the `main_program` and the `predicate` will be ignored.
105

106 107 108
    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 已提交
109
    use `filename` to specify it.
110

F
fengjiayi 已提交
111 112 113
    Args:
        executor(Executor): The executor to run for saving variables.
        dirname(str): The directory path.
114 115
        main_program(Program|None): The program whose variables will be saved.
                                    If it is None, the default main program will
F
fengjiayi 已提交
116 117
                                    be used automatically.
                                    Default: None
118
        vars(list[Variable]|None): The list that contains all variables to save.
F
fengjiayi 已提交
119 120
                                   It has a higher priority than the `main_program`.
                                   Default: None
121 122 123 124
        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 已提交
125 126
                                  `vars` is None).
                                  Default: None
127
        filename(str|None): The file which to save all variables. If you prefer to save
F
fengjiayi 已提交
128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149
                            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

            exe = fluid.Executor(fluid.CPUPlace())
            param_path = "./my_paddle_model"

            # The first usage: using `main_program` to specify variables
            def name_has_fc(var):
                res = "fc" in var.name
                return res

            prog = fluid.default_main_program()
            fluid.io.save_vars(executor=exe, dirname=path, main_program=prog,
C
chengduo 已提交
150
                               vars=None, predicate = name_has_fc)
F
fengjiayi 已提交
151 152 153 154 155 156
            # 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
            var_list = [var_a, var_b, var_c]
157
            fluid.io.save_vars(executor=exe, dirname=path, vars=var_list,
F
fengjiayi 已提交
158 159 160
                               filename="vars_file")
            # var_a, var_b and var_c will be saved. And they are going to be
            # saved in the same file named 'var_file' in the path "./my_paddle_model".
161 162
    """
    if vars is None:
163
        if main_program is None:
Y
Yu Yang 已提交
164
            main_program = default_main_program()
165
        if not isinstance(main_program, Program):
166 167 168 169
            raise TypeError("program should be as Program type or None")

        save_vars(
            executor,
170
            main_program=main_program,
171
            dirname=dirname,
172
            vars=list(filter(predicate, main_program.list_vars())),
173
            filename=filename)
174 175 176
    else:
        save_program = Program()
        save_block = save_program.global_block()
177

178 179 180 181 182
        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")

183
        save_var_map = {}
184
        for each_var in vars:
185 186 187
            # NOTE: don't save the variable which type is RAW
            if each_var.type == core.VarDesc.VarType.RAW:
                continue
188
            new_var = _clone_var_in_block_(save_block, each_var)
189
            if filename is None:
190 191 192 193 194 195 196 197
                save_block.append_op(
                    type='save',
                    inputs={'X': [new_var]},
                    outputs={},
                    attrs={'file_path': os.path.join(dirname, new_var.name)})
            else:
                save_var_map[new_var.name] = new_var

198
        if filename is not None:
199 200 201 202
            save_var_list = []
            for name in sorted(save_var_map.keys()):
                save_var_list.append(save_var_map[name])

203
            save_block.append_op(
204 205
                type='save_combine',
                inputs={'X': save_var_list},
206
                outputs={},
207
                attrs={'file_path': os.path.join(dirname, filename)})
208

209 210 211
        executor.run(save_program)


212
def save_params(executor, dirname, main_program=None, filename=None):
213
    """
F
fengjiayi 已提交
214 215 216
    This function filters out all parameters from the give `main_program`
    and then save them to the folder `dirname` or the file `filename`.

217 218 219
    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 已提交
220 221
    the file name.

222 223 224
    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()`
F
fengjiayi 已提交
225 226 227 228 229 230 231 232 233
    and `load_persistables()` instead.

    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
234 235
        filename(str|None): The file to save all parameters. If you prefer
                            to save parameters in differnet files, set it
F
fengjiayi 已提交
236 237 238 239 240 241 242 243 244 245 246 247
                            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()
248
            fluid.io.save_params(executor=exe, dirname=param_path,
F
fengjiayi 已提交
249
                                 main_program=None)
250 251 252 253
    """
    save_vars(
        executor,
        dirname=dirname,
254
        main_program=main_program,
255
        vars=None,
256
        predicate=is_parameter,
257
        filename=filename)
258 259


260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 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
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)


440
def save_persistables(executor, dirname, main_program=None, filename=None):
441
    """
442 443
    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 已提交
444 445
    or file `filename`.

446 447 448
    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 已提交
449 450 451 452 453
    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.
454 455
        main_program(Program|None): The program whose persistbale variables will
                                    be saved. If it is None, the default main
F
fengjiayi 已提交
456 457
                                    program will be used automatically.
                                    Default: None
458
        filename(str|None): The file to saved all variables. If you prefer to
F
fengjiayi 已提交
459 460 461 462 463 464 465 466 467 468 469 470
                            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"
            prog = fluid.default_main_program()
471
            fluid.io.save_persistables(executor=exe, dirname=param_path,
F
fengjiayi 已提交
472
                                       main_program=None)
473
    """
474 475 476 477 478 479 480 481 482 483 484 485 486

    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)
487 488


489 490 491 492 493
def load_vars(executor,
              dirname,
              main_program=None,
              vars=None,
              predicate=None,
494
              filename=None):
495
    """
F
fengjiayi 已提交
496 497
    Load variables from the given directory by executor.

498 499 500 501
    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 已提交
502 503
    are assigned, the `main_program` and the `predicate` will be ignored.

504 505 506
    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 已提交
507
    use `filename` to specify it.
508

F
fengjiayi 已提交
509 510 511
    Args:
        executor(Executor): The executor to run for loading variables.
        dirname(str): The directory path.
512 513
        main_program(Program|None): The program whose variables will be loaded.
                                    If it is None, the default main program will
F
fengjiayi 已提交
514 515
                                    be used automatically.
                                    Default: None
516
        vars(list[Variable]|None): The list that contains all variables to load.
F
fengjiayi 已提交
517 518
                                   It has a higher priority than the `main_program`.
                                   Default: None
519 520 521 522
        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 已提交
523 524
                                  `vars` is None).
                                  Default: None
525
        filename(str|None): The file which saved all required variables. If variables
F
fengjiayi 已提交
526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544
                            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

            exe = fluid.Executor(fluid.CPUPlace())
            param_path = "./my_paddle_model"

            # The first usage: using `main_program` to specify variables
            def name_has_fc(var):
                res = "fc" in var.name
                return res
545

F
fengjiayi 已提交
546 547
            prog = fluid.default_main_program()
            fluid.io.load_vars(executor=exe, dirname=path, main_program=prog,
C
chengduo 已提交
548
                               vars=None, predicate=name_has_fc)
F
fengjiayi 已提交
549 550 551 552 553 554
            # 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
            var_list = [var_a, var_b, var_c]
555
            fluid.io.load_vars(executor=exe, dirname=path, vars=var_list,
F
fengjiayi 已提交
556
                               filename="vars_file")
557
            # var_a, var_b and var_c will be loaded. And they are supposed to haven
F
fengjiayi 已提交
558
            # been saved in the same file named 'var_file' in the path "./my_paddle_model".
559 560
    """
    if vars is None:
561
        if main_program is None:
Y
Yu Yang 已提交
562
            main_program = default_main_program()
563
        if not isinstance(main_program, Program):
564 565 566 567 568
            raise TypeError("program's type should be Program")

        load_vars(
            executor,
            dirname=dirname,
T
tangwei12 已提交
569
            main_program=main_program,
570
            vars=list(filter(predicate, main_program.list_vars())),
571
            filename=filename)
572 573 574
    else:
        load_prog = Program()
        load_block = load_prog.global_block()
575

576 577 578 579 580
        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")

581
        load_var_map = {}
582 583
        for each_var in vars:
            assert isinstance(each_var, Variable)
T
tangwei12 已提交
584 585
            if each_var.type == core.VarDesc.VarType.RAW:
                continue
586
            new_var = _clone_var_in_block_(load_block, each_var)
587
            if filename is None:
588 589 590 591 592 593 594 595
                load_block.append_op(
                    type='load',
                    inputs={},
                    outputs={'Out': [new_var]},
                    attrs={'file_path': os.path.join(dirname, new_var.name)})
            else:
                load_var_map[new_var.name] = new_var

596
        if filename is not None:
597 598 599 600
            load_var_list = []
            for name in sorted(load_var_map.keys()):
                load_var_list.append(load_var_map[name])

601
            load_block.append_op(
602
                type='load_combine',
603
                inputs={},
604
                outputs={"Out": load_var_list},
605
                attrs={'file_path': os.path.join(dirname, filename)})
606 607 608
        executor.run(load_prog)


609
def load_params(executor, dirname, main_program=None, filename=None):
610
    """
F
fengjiayi 已提交
611
    This function filters out all parameters from the give `main_program`
F
fengjiayi 已提交
612
    and then trys to load these parameters from the folder `dirname` or
F
fengjiayi 已提交
613 614
    the file `filename`.

615 616 617
    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 已提交
618 619
    `filename` to specify the file name.

620 621 622 623
    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.
F
fengjiayi 已提交
624 625 626 627 628 629 630 631

    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
632
        filename(str|None): The file which saved all parameters. If parameters
F
fengjiayi 已提交
633 634 635 636 637 638 639 640 641 642 643 644
                            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()
645
            fluid.io.load_params(executor=exe, dirname=param_path,
F
fengjiayi 已提交
646
                                main_program=None)
647 648
    """
    load_vars(
649 650 651
        executor,
        dirname=dirname,
        main_program=main_program,
652
        predicate=is_parameter,
653
        filename=filename)
654 655


656
def load_persistables(executor, dirname, main_program=None, filename=None):
657
    """
658 659
    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 已提交
660 661
    `dirname` or the file `filename`.

662 663 664
    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 已提交
665 666 667 668 669
    the file name.

    Args:
        executor(Executor): The executor to run for loading persistable variables.
        dirname(str): The directory path.
670 671
        main_program(Program|None): The program whose persistbale variables will
                                    be loaded. If it is None, the default main
F
fengjiayi 已提交
672 673
                                    program will be used automatically.
                                    Default: None
674
        filename(str|None): The file which saved all variables. If variables were
F
fengjiayi 已提交
675 676 677 678 679 680 681 682 683 684 685 686
                            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_persistables(executor=exe, dirname=param_path,
F
fengjiayi 已提交
688
                                       main_program=None)
689
    """
690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 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 810 811 812 813 814 815 816 817

    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)

                dim1_flatten = reduce(lambda x, y: x * y, slice.shape[1:])
                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)
818 819


820 821 822
def prepend_feed_ops(inference_program,
                     feed_target_names,
                     feed_holder_name='feed'):
Q
Qiao Longfei 已提交
823 824 825
    if len(feed_target_names) == 0:
        return

K
Kexin Zhao 已提交
826 827
    global_block = inference_program.global_block()
    feed_var = global_block.create_var(
828 829 830
        name=feed_holder_name,
        type=core.VarDesc.VarType.FEED_MINIBATCH,
        persistable=True)
K
Kexin Zhao 已提交
831

832
    for i, name in enumerate(feed_target_names):
K
fix bug  
Kexin Zhao 已提交
833
        out = global_block.var(name)
W
Wu Yi 已提交
834
        global_block._prepend_op(
K
Kexin Zhao 已提交
835 836
            type='feed',
            inputs={'X': [feed_var]},
K
fix bug  
Kexin Zhao 已提交
837
            outputs={'Out': [out]},
K
Kexin Zhao 已提交
838 839 840
            attrs={'col': i})


841 842 843
def append_fetch_ops(inference_program,
                     fetch_target_names,
                     fetch_holder_name='fetch'):
K
Kexin Zhao 已提交
844 845
    global_block = inference_program.global_block()
    fetch_var = global_block.create_var(
846 847 848
        name=fetch_holder_name,
        type=core.VarDesc.VarType.FETCH_LIST,
        persistable=True)
K
Kexin Zhao 已提交
849

850
    for i, name in enumerate(fetch_target_names):
K
Kexin Zhao 已提交
851 852 853 854 855 856 857
        global_block.append_op(
            type='fetch',
            inputs={'X': [name]},
            outputs={'Out': [fetch_var]},
            attrs={'col': i})


858 859 860 861
def save_inference_model(dirname,
                         feeded_var_names,
                         target_vars,
                         executor,
862
                         main_program=None,
863
                         model_filename=None,
864 865
                         params_filename=None,
                         export_for_deployment=True):
866
    """
F
fengjiayi 已提交
867 868 869 870 871
    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`.

    Args:
        dirname(str): The directory path to save the inference model.
872
        feeded_var_names(list[str]): Names of variables that need to be feeded data
F
fengjiayi 已提交
873
                                     during inference.
874
        target_vars(list[Variable]): Variables from which we can get inference
F
fengjiayi 已提交
875 876
                                     results.
        executor(Executor): The executor that saves the inference model.
877 878
        main_program(Program|None): The original program, which will be pruned to
                                    build the inference model. If is setted None,
F
fengjiayi 已提交
879 880
                                    the default main program will be used.
                                    Default: None.
881 882
        model_filename(str|None): The name of file to save the inference program
                                  itself. If is setted None, a default filename
F
fengjiayi 已提交
883
                                  `__model__` will be used.
884 885
        params_filename(str|None): The name of file to save all related parameters.
                                   If it is setted None, parameters will be saved
F
fengjiayi 已提交
886
                                   in separate files .
X
Xin Pan 已提交
887 888 889 890 891
        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.
892

F
fengjiayi 已提交
893 894 895 896 897 898 899 900 901
    Returns:
        None

    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 已提交
902

F
fengjiayi 已提交
903 904 905 906 907
            exe = fluid.Executor(fluid.CPUPlace())
            path = "./infer_model"
            fluid.io.save_inference_model(dirname=path, feeded_var_names=['img'],
                         target_vars=[predict_var], executor=exe)

908 909 910
            # In this exsample, the function will prune the default main program
            # to make it suitable for infering the `predict_var`. The pruned
            # inference program is going to be saved in the "./infer_model/__model__"
F
fengjiayi 已提交
911
            # and parameters are going to be saved in separate files under folder
912
            # "./infer_model".
913 914

    """
M
minqiyang 已提交
915
    if isinstance(feeded_var_names, six.string_types):
F
fengjiayi 已提交
916
        feeded_var_names = [feeded_var_names]
X
Xin Pan 已提交
917
    elif export_for_deployment:
Q
Qiao Longfei 已提交
918
        if len(feeded_var_names) > 0:
919
            # TODO(paddle-dev): polish these code blocks
Q
Qiao Longfei 已提交
920
            if not (bool(feeded_var_names) and all(
M
minqiyang 已提交
921
                    isinstance(name, six.string_types)
922
                    for name in feeded_var_names)):
M
minqiyang 已提交
923
                raise ValueError("'feed_var_names' should be a list of str.")
F
fengjiayi 已提交
924 925

    if isinstance(target_vars, Variable):
F
fengjiayi 已提交
926
        target_vars = [target_vars]
X
Xin Pan 已提交
927
    elif export_for_deployment:
928 929
        if not (bool(target_vars) and
                all(isinstance(var, Variable) for var in target_vars)):
F
fengjiayi 已提交
930 931
            raise ValueError("'target_vars' should be a list of Variable.")

932
    if main_program is None:
Y
Yu Yang 已提交
933
        main_program = default_main_program()
D
dzhwinter 已提交
934
        if main_program._is_optimized:
D
dzhwinter 已提交
935 936 937 938 939 940
            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 已提交
941

942 943
    # when a pserver and a trainer running on the same machine, mkdir may conflict
    try:
944
        os.makedirs(dirname)
945 946 947 948
    except OSError as e:
        if e.errno != errno.EEXIST:
            raise

X
Xin Pan 已提交
949 950 951 952 953
    if model_filename is not None:
        model_basename = os.path.basename(model_filename)
    else:
        model_basename = "__model__"
    model_basename = os.path.join(dirname, model_basename)
954

X
Xin Pan 已提交
955 956 957 958
    # 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.
959 960 961

    origin_program = main_program.clone()

X
Xin Pan 已提交
962
    if export_for_deployment:
X
Xin Pan 已提交
963 964
        main_program = main_program.clone()
        global_block = main_program.global_block()
965
        need_to_remove_op_index = []
X
Xin Pan 已提交
966 967 968
        for i, op in enumerate(global_block.ops):
            op.desc.set_is_target(False)
            if op.type == "feed" or op.type == "fetch":
969 970 971 972 973
                need_to_remove_op_index.append(i)

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

X
Xin Pan 已提交
974
        main_program.desc.flush()
X
Xin Pan 已提交
975

X
Xin Pan 已提交
976 977
        main_program = main_program._prune(targets=target_vars)
        main_program = main_program._inference_optimize(prune_read_op=True)
X
Xin Pan 已提交
978 979
        fetch_var_names = [v.name for v in target_vars]

X
Xin Pan 已提交
980 981 982 983 984
        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 已提交
985 986 987
    else:
        # TODO(panyx0718): Save more information so that it can also be used
        # for training and more flexible post-processing.
X
Xin Pan 已提交
988 989
        with open(model_basename + ".main_program", "wb") as f:
            f.write(main_program.desc.serialize_to_string())
T
tangwei12 已提交
990

991 992
    main_program._copy_dist_param_info_from(origin_program)

X
fix  
Xin Pan 已提交
993 994
    if params_filename is not None:
        params_filename = os.path.basename(params_filename)
995

X
fix  
Xin Pan 已提交
996 997
    save_persistables(executor, dirname, main_program, params_filename)

998

999 1000 1001
def load_inference_model(dirname,
                         executor,
                         model_filename=None,
T
tangwei12 已提交
1002 1003
                         params_filename=None,
                         pserver_endpoints=None):
1004 1005 1006
    """
    Load inference model from a directory

F
fengjiayi 已提交
1007 1008 1009 1010
    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.
1011
                                  If it is None, the default filename
F
fengjiayi 已提交
1012 1013 1014
                                  '__model__' will be used.
                                  Default: None
        params_filename(str|None): The name of file to load all parameters.
1015 1016 1017
                                   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 已提交
1018
                                   files, set it as 'None'.
1019 1020 1021 1022
        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 已提交
1023 1024 1025

    Returns:
        tuple: The return of this function is a tuple with three elements:
1026 1027 1028 1029 1030
        (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 已提交
1031 1032 1033 1034 1035 1036 1037 1038 1039 1040
        results.

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

    Examples:
        .. code-block:: python

            exe = fluid.Executor(fluid.CPUPlace())
            path = "./infer_model"
1041
            endpoints = ["127.0.0.1:2023","127.0.0.1:2024"]
1042
            [inference_program, feed_target_names, fetch_targets] =
F
fengjiayi 已提交
1043 1044 1045 1046 1047
                fluid.io.load_inference_model(dirname=path, executor=exe)
            results = exe.run(inference_program,
                          feed={feed_target_names[0]: tensor_img},
                          fetch_list=fetch_targets)

1048 1049 1050
            # if we need lookup table, we will use:
            fluid.io.load_inference_model(dirname=path, executor=exe, pserver_endpoints=endpoints)

1051 1052 1053 1054 1055
            # In this exsample, the inference program was saved in the
            # "./infer_model/__model__" and parameters were saved in
            # separate files in ""./infer_model".
            # After getting inference program, feed target names and
            # fetch targets, we can use an Executor to run the inference
F
fengjiayi 已提交
1056
            # program to get the inference result.
1057

1058 1059 1060 1061
    """
    if not os.path.isdir(dirname):
        raise ValueError("There is no directory named '%s'", dirname)

1062 1063
    if model_filename is not None:
        model_filename = os.path.basename(model_filename)
1064
    else:
1065 1066 1067 1068 1069
        model_filename = "__model__"
    model_filename = os.path.join(dirname, model_filename)

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

1071
    with open(model_filename, "rb") as f:
1072 1073
        program_desc_str = f.read()

1074
    program = Program.parse_from_string(program_desc_str)
X
Xin Pan 已提交
1075
    if not core._is_program_version_supported(program._version()):
X
version  
Xin Pan 已提交
1076 1077 1078
        raise ValueError("Unsupported program version: %d\n" %
                         program._version())
    # Binary data also need versioning.
1079
    load_persistables(executor, dirname, program, params_filename)
1080

T
tangwei12 已提交
1081
    if pserver_endpoints:
T
tangwei12 已提交
1082
        program = _endpoints_replacement(program, pserver_endpoints)
T
tangwei12 已提交
1083

1084 1085
    feed_target_names = program.desc.get_feed_target_names()
    fetch_target_names = program.desc.get_fetch_target_names()
1086 1087 1088 1089 1090
    fetch_targets = [
        program.global_block().var(name) for name in fetch_target_names
    ]

    return [program, feed_target_names, fetch_targets]
X
xuwei06 已提交
1091 1092


T
tangwei12 已提交
1093 1094 1095
def _endpoints_replacement(program, endpoints):
    ENDPOINT_MAP = "epmap"
    for op in program.global_block().ops:
T
tangwei12 已提交
1096 1097
        if op.has_attr(ENDPOINT_MAP):
            op.set_attr(ENDPOINT_MAP, endpoints)
T
fix  
tangwei12 已提交
1098
    program._sync_with_cpp()
T
tangwei12 已提交
1099
    return program
T
tangwei12 已提交
1100 1101


X
xuwei06 已提交
1102 1103
def get_parameter_value(para, executor):
    """
F
fengjiayi 已提交
1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114
    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 已提交
1115

F
fengjiayi 已提交
1116 1117
    Examples:
        .. code-block:: python
X
xuwei06 已提交
1118

F
fengjiayi 已提交
1119 1120 1121
            exe = fluid.Executor(fluid.CPUPlace())
            param = fluid.default_main_program().global_block().var('fc.w')
            p = fluid.io.get_parameter_value(param, exe)
1122

X
xuwei06 已提交
1123
    """
X
xuwei06 已提交
1124 1125
    assert is_parameter(para)

X
xuwei06 已提交
1126 1127 1128 1129 1130 1131 1132 1133
    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 已提交
1134
    Get the LoDTensor value of a certain parameter by its name.
X
xuwei06 已提交
1135

F
fengjiayi 已提交
1136 1137 1138 1139 1140 1141 1142
    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 已提交
1143

F
fengjiayi 已提交
1144 1145
    Returns:
        numpy.array: The parameter's values.
1146

F
fengjiayi 已提交
1147 1148 1149 1150 1151
    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.
1152

F
fengjiayi 已提交
1153 1154 1155 1156 1157
    Examples:
        .. code-block:: python

            exe = fluid.Executor(fluid.CPUPlace())
            p = fluid.io.get_parameter_value('fc.w', exe)
X
xuwei06 已提交
1158 1159
    """
    if program is None:
Y
Yu Yang 已提交
1160
        program = default_main_program()
X
xuwei06 已提交
1161 1162
    var = program.global_block().var(name)
    return get_parameter_value(var, executor)