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

15 16
from __future__ import print_function

17
import os
T
bug fix  
tangwei12 已提交
18
import errno
T
tangwei12 已提交
19 20
import time
import shutil
21
import six
22

23
from paddle.fluid.evaluator import Evaluator
24
from paddle.fluid.framework import Program, Parameter, default_main_program, default_startup_program, Variable
K
fix bug  
Kexin Zhao 已提交
25
from . import core
26 27

__all__ = [
T
tangwei12 已提交
28 29
    'save_vars', 'save_params', 'save_persistables', 'load_vars', 'load_params',
    'load_persistables', 'save_inference_model', 'load_inference_model',
T
tangwei12 已提交
30
    'get_inference_program'
31 32 33 34
]


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

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

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


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

            param = fluid.default_main_program().global_block().var('fc.w')
            res = fluid.io.is_persistable(param)
    """
71
    if var.desc.type() == core.VarDesc.VarType.FEED_MINIBATCH or \
Y
yuyang18 已提交
72 73
            var.desc.type() == core.VarDesc.VarType.FETCH_LIST or \
            var.desc.type() == core.VarDesc.VarType.READER:
74
        return False
75 76 77 78 79 80 81 82
    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 已提交
83
        dtype=var.dtype,
84 85 86 87 88
        type=var.type,
        lod_level=var.lod_level,
        persistable=True)


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

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

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

F
fengjiayi 已提交
109 110 111
    Args:
        executor(Executor): The executor to run for saving variables.
        dirname(str): The directory path.
112 113
        main_program(Program|None): The program whose variables will be saved.
                                    If it is None, the default main program will
F
fengjiayi 已提交
114 115
                                    be used automatically.
                                    Default: None
116
        vars(list[Variable]|None): The list that contains all variables to save.
F
fengjiayi 已提交
117 118
                                   It has a higher priority than the `main_program`.
                                   Default: None
119 120 121 122
        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 已提交
123 124
                                  `vars` is None).
                                  Default: None
125
        filename(str|None): The file which to save all variables. If you prefer to save
F
fengjiayi 已提交
126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154
                            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,
                               vars=None)
            # 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]
155
            fluid.io.save_vars(executor=exe, dirname=path, vars=var_list,
F
fengjiayi 已提交
156 157 158
                               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".
159 160
    """
    if vars is None:
161
        if main_program is None:
Y
Yu Yang 已提交
162
            main_program = default_main_program()
163
        if not isinstance(main_program, Program):
164 165 166 167 168
            raise TypeError("program should be as Program type or None")

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

        save_var_map = {}
176
        for each_var in vars:
177 178 179
            # NOTE: don't save the variable which type is RAW
            if each_var.type == core.VarDesc.VarType.RAW:
                continue
180
            new_var = _clone_var_in_block_(save_block, each_var)
181
            if filename is None:
182 183 184 185 186 187 188 189
                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

190
        if filename is not None:
191 192 193 194
            save_var_list = []
            for name in sorted(save_var_map.keys()):
                save_var_list.append(save_var_map[name])

195
            save_block.append_op(
196 197
                type='save_combine',
                inputs={'X': save_var_list},
198
                outputs={},
199
                attrs={'file_path': os.path.join(dirname, filename)})
200

201 202 203
        executor.run(save_program)


204
def save_params(executor, dirname, main_program=None, filename=None):
205
    """
F
fengjiayi 已提交
206 207 208
    This function filters out all parameters from the give `main_program`
    and then save them to the folder `dirname` or the file `filename`.

209 210 211
    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 已提交
212 213
    the file name.

214 215 216
    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 已提交
217 218 219 220 221 222 223 224 225
    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
226 227
        filename(str|None): The file to save all parameters. If you prefer
                            to save parameters in differnet files, set it
F
fengjiayi 已提交
228 229 230 231 232 233 234 235 236 237 238 239
                            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()
240
            fluid.io.save_params(executor=exe, dirname=param_path,
F
fengjiayi 已提交
241
                                 main_program=None)
242 243 244 245
    """
    save_vars(
        executor,
        dirname=dirname,
246
        main_program=main_program,
247
        vars=None,
248
        predicate=is_parameter,
249
        filename=filename)
250 251


252
def save_persistables(executor, dirname, main_program=None, filename=None):
253
    """
254 255
    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 已提交
256 257
    or file `filename`.

258 259 260
    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 已提交
261 262 263 264 265
    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.
266 267
        main_program(Program|None): The program whose persistbale variables will
                                    be saved. If it is None, the default main
F
fengjiayi 已提交
268 269
                                    program will be used automatically.
                                    Default: None
270
        filename(str|None): The file to saved all variables. If you prefer to
F
fengjiayi 已提交
271 272 273 274 275 276 277 278 279 280 281 282
                            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()
283
            fluid.io.save_persistables(executor=exe, dirname=param_path,
F
fengjiayi 已提交
284
                                       main_program=None)
285 286 287 288
    """
    save_vars(
        executor,
        dirname=dirname,
289
        main_program=main_program,
290
        vars=None,
291
        predicate=is_persistable,
292
        filename=filename)
293 294


295 296 297 298 299
def load_vars(executor,
              dirname,
              main_program=None,
              vars=None,
              predicate=None,
300
              filename=None):
301
    """
F
fengjiayi 已提交
302 303
    Load variables from the given directory by executor.

304 305 306 307
    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 已提交
308 309
    are assigned, the `main_program` and the `predicate` will be ignored.

310 311 312
    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 已提交
313
    use `filename` to specify it.
314

F
fengjiayi 已提交
315 316 317
    Args:
        executor(Executor): The executor to run for loading variables.
        dirname(str): The directory path.
318 319
        main_program(Program|None): The program whose variables will be loaded.
                                    If it is None, the default main program will
F
fengjiayi 已提交
320 321
                                    be used automatically.
                                    Default: None
322
        vars(list[Variable]|None): The list that contains all variables to load.
F
fengjiayi 已提交
323 324
                                   It has a higher priority than the `main_program`.
                                   Default: None
325 326 327 328
        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 已提交
329 330
                                  `vars` is None).
                                  Default: None
331
        filename(str|None): The file which saved all required variables. If variables
F
fengjiayi 已提交
332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350
                            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
351

F
fengjiayi 已提交
352 353 354 355 356 357 358 359 360
            prog = fluid.default_main_program()
            fluid.io.load_vars(executor=exe, dirname=path, main_program=prog,
                               vars=None)
            # 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]
361
            fluid.io.load_vars(executor=exe, dirname=path, vars=var_list,
F
fengjiayi 已提交
362
                               filename="vars_file")
363
            # var_a, var_b and var_c will be loaded. And they are supposed to haven
F
fengjiayi 已提交
364
            # been saved in the same file named 'var_file' in the path "./my_paddle_model".
365 366
    """
    if vars is None:
367
        if main_program is None:
Y
Yu Yang 已提交
368
            main_program = default_main_program()
369
        if not isinstance(main_program, Program):
370 371 372 373 374
            raise TypeError("program's type should be Program")

        load_vars(
            executor,
            dirname=dirname,
T
tangwei12 已提交
375
            main_program=main_program,
376
            vars=list(filter(predicate, main_program.list_vars())),
377
            filename=filename)
378 379 380
    else:
        load_prog = Program()
        load_block = load_prog.global_block()
381 382

        load_var_map = {}
383 384
        for each_var in vars:
            assert isinstance(each_var, Variable)
T
tangwei12 已提交
385 386
            if each_var.type == core.VarDesc.VarType.RAW:
                continue
387
            new_var = _clone_var_in_block_(load_block, each_var)
388
            if filename is None:
389 390 391 392 393 394 395 396
                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

397
        if filename is not None:
398 399 400 401
            load_var_list = []
            for name in sorted(load_var_map.keys()):
                load_var_list.append(load_var_map[name])

402
            load_block.append_op(
403
                type='load_combine',
404
                inputs={},
405
                outputs={"Out": load_var_list},
406
                attrs={'file_path': os.path.join(dirname, filename)})
407 408
        executor.run(load_prog)

C
chengduo 已提交
409 410 411
        if main_program is None:
            main_program = default_main_program()

412 413
        # load slice vars on pserver, if have it.
        _load_slice_up_vars(executor, dirname,
T
tangwei12 已提交
414
                            main_program._slice_vars_and_attrs)
415

416

417
def load_params(executor, dirname, main_program=None, filename=None):
418
    """
F
fengjiayi 已提交
419
    This function filters out all parameters from the give `main_program`
F
fengjiayi 已提交
420
    and then trys to load these parameters from the folder `dirname` or
F
fengjiayi 已提交
421 422
    the file `filename`.

423 424 425
    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 已提交
426 427
    `filename` to specify the file name.

428 429 430 431
    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 已提交
432 433 434 435 436 437 438 439

    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
440
        filename(str|None): The file which saved all parameters. If parameters
F
fengjiayi 已提交
441 442 443 444 445 446 447 448 449 450 451 452
                            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()
453
            fluid.io.load_params(executor=exe, dirname=param_path,
F
fengjiayi 已提交
454
                                main_program=None)
455 456
    """
    load_vars(
457 458 459
        executor,
        dirname=dirname,
        main_program=main_program,
460
        predicate=is_parameter,
461
        filename=filename)
462 463


464
def load_persistables(executor, dirname, main_program=None, filename=None):
465
    """
466 467
    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 已提交
468 469
    `dirname` or the file `filename`.

470 471 472
    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 已提交
473 474 475 476 477
    the file name.

    Args:
        executor(Executor): The executor to run for loading persistable variables.
        dirname(str): The directory path.
478 479
        main_program(Program|None): The program whose persistbale variables will
                                    be loaded. If it is None, the default main
F
fengjiayi 已提交
480 481
                                    program will be used automatically.
                                    Default: None
482
        filename(str|None): The file which saved all variables. If variables were
F
fengjiayi 已提交
483 484 485 486 487 488 489 490 491 492 493 494
                            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()
495
            fluid.io.load_persistables(executor=exe, dirname=param_path,
F
fengjiayi 已提交
496
                                       main_program=None)
497 498
    """
    load_vars(
499 500 501
        executor,
        dirname=dirname,
        main_program=main_program,
502
        predicate=is_persistable,
503
        filename=filename)
504 505


506 507
def get_inference_program(target_vars, main_program=None):
    if main_program is None:
Y
Yu Yang 已提交
508
        main_program = default_main_program()
509 510
    if not isinstance(target_vars, list):
        target_vars = [target_vars]
W
wanghaoshuang 已提交
511 512 513
    vars = []
    for var in target_vars:
        if isinstance(var, Evaluator):
W
wanghaoshuang 已提交
514 515
            vars.extend(var.states)
            vars.extend(var.metrics)
W
wanghaoshuang 已提交
516 517 518
        else:
            vars.append(var)
    pruned_program = main_program.prune(targets=vars)
519 520 521 522
    inference_program = pruned_program.inference_optimize()
    return inference_program


523 524 525
def prepend_feed_ops(inference_program,
                     feed_target_names,
                     feed_holder_name='feed'):
Q
Qiao Longfei 已提交
526 527 528
    if len(feed_target_names) == 0:
        return

K
Kexin Zhao 已提交
529 530
    global_block = inference_program.global_block()
    feed_var = global_block.create_var(
531 532 533
        name=feed_holder_name,
        type=core.VarDesc.VarType.FEED_MINIBATCH,
        persistable=True)
K
Kexin Zhao 已提交
534

535
    for i, name in enumerate(feed_target_names):
K
fix bug  
Kexin Zhao 已提交
536
        out = global_block.var(name)
W
Wu Yi 已提交
537
        global_block._prepend_op(
K
Kexin Zhao 已提交
538 539
            type='feed',
            inputs={'X': [feed_var]},
K
fix bug  
Kexin Zhao 已提交
540
            outputs={'Out': [out]},
K
Kexin Zhao 已提交
541 542 543
            attrs={'col': i})


544 545 546
def append_fetch_ops(inference_program,
                     fetch_target_names,
                     fetch_holder_name='fetch'):
K
Kexin Zhao 已提交
547 548
    global_block = inference_program.global_block()
    fetch_var = global_block.create_var(
549 550 551
        name=fetch_holder_name,
        type=core.VarDesc.VarType.FETCH_LIST,
        persistable=True)
K
Kexin Zhao 已提交
552

553
    for i, name in enumerate(fetch_target_names):
K
Kexin Zhao 已提交
554 555 556 557 558 559 560
        global_block.append_op(
            type='fetch',
            inputs={'X': [name]},
            outputs={'Out': [fetch_var]},
            attrs={'col': i})


561 562 563 564
def save_inference_model(dirname,
                         feeded_var_names,
                         target_vars,
                         executor,
565
                         main_program=None,
566
                         model_filename=None,
567 568
                         params_filename=None,
                         export_for_deployment=True):
569
    """
F
fengjiayi 已提交
570 571 572 573 574
    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.
575
        feeded_var_names(list[str]): Names of variables that need to be feeded data
F
fengjiayi 已提交
576
                                     during inference.
577
        target_vars(list[Variable]): Variables from which we can get inference
F
fengjiayi 已提交
578 579
                                     results.
        executor(Executor): The executor that saves the inference model.
580 581
        main_program(Program|None): The original program, which will be pruned to
                                    build the inference model. If is setted None,
F
fengjiayi 已提交
582 583
                                    the default main program will be used.
                                    Default: None.
584 585
        model_filename(str|None): The name of file to save the inference program
                                  itself. If is setted None, a default filename
F
fengjiayi 已提交
586
                                  `__model__` will be used.
587 588
        params_filename(str|None): The name of file to save all related parameters.
                                   If it is setted None, parameters will be saved
F
fengjiayi 已提交
589
                                   in separate files .
590 591
        export_for_deployment(bool): remove the read ops that are added by py_reader
                                    for cpp inference lib. Default True
592

F
fengjiayi 已提交
593 594 595 596 597 598 599 600 601
    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 已提交
602

F
fengjiayi 已提交
603 604 605 606 607
            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)

608 609 610
            # 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 已提交
611
            # and parameters are going to be saved in separate files under folder
612
            # "./infer_model".
613 614

    """
M
minqiyang 已提交
615
    if isinstance(feeded_var_names, six.string_types):
F
fengjiayi 已提交
616 617
        feeded_var_names = [feeded_var_names]
    else:
Q
Qiao Longfei 已提交
618
        if len(feeded_var_names) > 0:
619
            # TODO(paddle-dev): polish these code blocks
Q
Qiao Longfei 已提交
620
            if not (bool(feeded_var_names) and all(
M
minqiyang 已提交
621
                    isinstance(name, six.string_types)
622
                    for name in feeded_var_names)):
M
minqiyang 已提交
623
                raise ValueError("'feed_var_names' should be a list of str.")
F
fengjiayi 已提交
624 625

    if isinstance(target_vars, Variable):
F
fengjiayi 已提交
626
        target_vars = [target_vars]
F
fengjiayi 已提交
627 628 629 630 631
    else:
        if not (bool(target_vars) and all(
                isinstance(var, Variable) for var in target_vars)):
            raise ValueError("'target_vars' should be a list of Variable.")

632
    if main_program is None:
Y
Yu Yang 已提交
633
        main_program = default_main_program()
634
    copy_program = main_program.clone()
635 636 637 638

    if not os.path.isdir(dirname):
        os.makedirs(dirname)

639
    # Clear the is_target information and remove the existed feed and fetch op
640
    global_block = copy_program.global_block()
641 642 643
    for i, op in enumerate(global_block.ops):
        op.desc.set_is_target(False)
        if op.type == "feed" or op.type == "fetch":
W
Wu Yi 已提交
644
            global_block._remove_op(i)
645
    copy_program.desc.flush()
646

647
    pruned_program = copy_program.prune(targets=target_vars)
648 649
    inference_program = pruned_program.inference_optimize(
        export_for_deployment=export_for_deployment)
650 651
    fetch_var_names = [v.name for v in target_vars]

K
Kexin Zhao 已提交
652 653
    prepend_feed_ops(inference_program, feeded_var_names)
    append_fetch_ops(inference_program, fetch_var_names)
654

655 656
    if model_filename is not None:
        model_filename = os.path.basename(model_filename)
657
    else:
658 659
        model_filename = "__model__"
    model_filename = os.path.join(dirname, model_filename)
660

661 662 663 664
    if params_filename is not None:
        params_filename = os.path.basename(params_filename)

    with open(model_filename, "wb") as f:
665
        f.write(inference_program.desc.serialize_to_string())
666

667
    save_persistables(executor, dirname, inference_program, params_filename)
668

T
tangwei12 已提交
669
    # if there is lookup table, the trainer 0 will notify all pserver to save.
T
tangwei12 已提交
670 671 672 673 674
    if main_program._is_distributed and main_program._is_chief and main_program._distributed_lookup_table:
        lookup_table_filename = os.path.join(dirname, "__lookup_table__")
        _save_lookup_tables_by_notify(executor, lookup_table_filename,
                                      main_program._distributed_lookup_table,
                                      main_program._endpoints)
T
tangwei12 已提交
675

676

677 678 679
def load_inference_model(dirname,
                         executor,
                         model_filename=None,
T
tangwei12 已提交
680 681
                         params_filename=None,
                         pserver_endpoints=None):
682 683 684
    """
    Load inference model from a directory

F
fengjiayi 已提交
685 686 687 688
    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.
689
                                  If it is None, the default filename
F
fengjiayi 已提交
690 691 692
                                  '__model__' will be used.
                                  Default: None
        params_filename(str|None): The name of file to load all parameters.
693 694 695
                                   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 已提交
696
                                   files, set it as 'None'.
697 698 699 700
        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 已提交
701 702 703

    Returns:
        tuple: The return of this function is a tuple with three elements:
704 705 706 707 708
        (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 已提交
709 710 711 712 713 714 715 716 717 718
        results.

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

    Examples:
        .. code-block:: python

            exe = fluid.Executor(fluid.CPUPlace())
            path = "./infer_model"
719
            endpoints = ["127.0.0.1:2023","127.0.0.1:2024"]
720
            [inference_program, feed_target_names, fetch_targets] =
F
fengjiayi 已提交
721 722 723 724 725
                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)

726 727 728
            # if we need lookup table, we will use:
            fluid.io.load_inference_model(dirname=path, executor=exe, pserver_endpoints=endpoints)

729 730 731 732 733
            # 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 已提交
734
            # program to get the inference result.
735

736 737 738 739
    """
    if not os.path.isdir(dirname):
        raise ValueError("There is no directory named '%s'", dirname)

740 741
    if model_filename is not None:
        model_filename = os.path.basename(model_filename)
742
    else:
743 744 745 746 747
        model_filename = "__model__"
    model_filename = os.path.join(dirname, model_filename)

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

749
    with open(model_filename, "rb") as f:
750 751
        program_desc_str = f.read()

752
    program = Program.parse_from_string(program_desc_str)
X
Xin Pan 已提交
753
    if not core._is_program_version_supported(program._version()):
X
version  
Xin Pan 已提交
754 755 756
        raise ValueError("Unsupported program version: %d\n" %
                         program._version())
    # Binary data also need versioning.
757
    load_persistables(executor, dirname, program, params_filename)
758

T
tangwei12 已提交
759
    if pserver_endpoints:
T
tangwei12 已提交
760
        program = _endpoints_replacement(program, pserver_endpoints)
T
tangwei12 已提交
761

762 763
    feed_target_names = program.desc.get_feed_target_names()
    fetch_target_names = program.desc.get_fetch_target_names()
764 765 766 767 768
    fetch_targets = [
        program.global_block().var(name) for name in fetch_target_names
    ]

    return [program, feed_target_names, fetch_targets]
X
xuwei06 已提交
769 770


T
tangwei12 已提交
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
def _save_lookup_tables_by_notify(executor, dirname, lookup_table,
                                  pserver_endpoints):
    """
    This function will send checkpoint notify message from Trainer 0
    to all the pservers.
    The checkpoint notify message contains lookup table name,
    the absolute path on pserver to save lookup_table.

    Args:
        executor(Executor): The executor to run for send checkpoint notify.
        dirname(str): The folder where to save.
        lookup_table(string): the lookup table name, when use distribute
            lookup table, we can get lookup table name by DistributeTranspiler.
            table_name
        ps_endpoint_list(list): the parameter server ip:port list.
            when use distribute lookup table, we can get ps_endpoint_list by
            distribute arguments.
    Return:
        None

    Examples:
        .. code-block:: python

            exe = fluid.Executor(fluid.CPUPlace())
            param_path = "./my_paddle_model"
            table_name = "share_w"
            ps_endpoints = ["127.0.0.1:6000","127.0.0.1:6001"]

            _save_pserver_vars_by_notify(executor=exe,
                    dirname=param_path, lookup_table=table_name,
                    pserver_endpoints=ps_endpoints)
    """

    pserver_notify_program = Program()
    pserver_notify_block = pserver_notify_program.global_block()

    attrs = {}
T
bug fix  
tangwei12 已提交
808
    attrs['epmap'] = pserver_endpoints
T
tangwei12 已提交
809 810 811 812 813 814 815 816 817 818 819
    attrs['dir'] = dirname
    attrs['lookup_table'] = lookup_table

    pserver_notify_block.append_op(
        type='checkpoint_notify', inputs={}, outputs={}, attrs=attrs)
    executor.run(pserver_notify_program)


def _endpoints_replacement(program, endpoints):
    ENDPOINT_MAP = "epmap"
    for op in program.global_block().ops:
T
tangwei12 已提交
820 821
        if op.has_attr(ENDPOINT_MAP):
            op.set_attr(ENDPOINT_MAP, endpoints)
T
fix  
tangwei12 已提交
822
    program._sync_with_cpp()
T
tangwei12 已提交
823
    return program
T
tangwei12 已提交
824 825


X
xuwei06 已提交
826 827
def get_parameter_value(para, executor):
    """
F
fengjiayi 已提交
828 829 830 831 832 833 834 835 836 837 838
    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 已提交
839

F
fengjiayi 已提交
840 841
    Examples:
        .. code-block:: python
X
xuwei06 已提交
842

F
fengjiayi 已提交
843 844 845
            exe = fluid.Executor(fluid.CPUPlace())
            param = fluid.default_main_program().global_block().var('fc.w')
            p = fluid.io.get_parameter_value(param, exe)
846

X
xuwei06 已提交
847
    """
X
xuwei06 已提交
848 849
    assert is_parameter(para)

X
xuwei06 已提交
850 851 852 853 854 855 856 857
    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 已提交
858
    Get the LoDTensor value of a certain parameter by its name.
X
xuwei06 已提交
859

F
fengjiayi 已提交
860 861 862 863 864 865 866
    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 已提交
867

F
fengjiayi 已提交
868 869
    Returns:
        numpy.array: The parameter's values.
870

F
fengjiayi 已提交
871 872 873 874 875
    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.
876

F
fengjiayi 已提交
877 878 879 880 881
    Examples:
        .. code-block:: python

            exe = fluid.Executor(fluid.CPUPlace())
            p = fluid.io.get_parameter_value('fc.w', exe)
X
xuwei06 已提交
882 883
    """
    if program is None:
Y
Yu Yang 已提交
884
        program = default_main_program()
X
xuwei06 已提交
885 886
    var = program.global_block().var(name)
    return get_parameter_value(var, executor)
T
tangwei12 已提交
887 888


T
tangwei12 已提交
889 890
def _load_slice_up_vars(executor, dirname, slice_vars_and_attrs):
    if not slice_vars_and_attrs:
891 892 893 894 895
        return

    load_prog = Program()
    load_block = load_prog.global_block()

T
tangwei12 已提交
896
    for var_tuple in slice_vars_and_attrs:
897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929
        orig_var = var_tuple[0]
        start = var_tuple[1]
        slice_var = var_tuple[2]
        end = start + reduce(lambda x, y: x * y, slice_var.shape)

        clone_orig_var = load_block.create_var(
            name=orig_var.name,
            type=orig_var.type,
            shape=orig_var.shape,
            dtype=orig_var.dtype,
            persistable=True)

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

        load_block.append_op(
            type='load',
            inputs={},
            outputs={'Out': [clone_orig_var]},
            attrs={'file_path': os.path.join(dirname, clone_orig_var.name)})
        load_block.append_op(
            type="slice",
            inputs={'Input': clone_orig_var},
            outputs={'Out': clone_slice_var},
            attrs={'axes': [0],
                   'starts': [start],
                   'ends': [end]})

    executor.run(load_prog)