io.py 30.5 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
import os
T
bug fix  
tangwei12 已提交
16
import errno
T
tangwei12 已提交
17 18
import time
import shutil
19
import six
20

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

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


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

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

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


def is_persistable(var):
F
fengjiayi 已提交
53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68
    """
    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)
    """
69
    if var.desc.type() == core.VarDesc.VarType.FEED_MINIBATCH or \
Y
yuyang18 已提交
70 71
            var.desc.type() == core.VarDesc.VarType.FETCH_LIST or \
            var.desc.type() == core.VarDesc.VarType.READER:
72
        return False
73 74 75 76 77 78 79 80
    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 已提交
81
        dtype=var.dtype,
82 83 84 85 86
        type=var.type,
        lod_level=var.lod_level,
        persistable=True)


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

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

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

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

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

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

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

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

199 200 201
        executor.run(save_program)


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

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

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


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

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


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

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

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

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

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

        load_vars(
            executor,
            dirname=dirname,
373
            vars=list(filter(predicate, main_program.list_vars())),
374
            filename=filename)
375 376 377
    else:
        load_prog = Program()
        load_block = load_prog.global_block()
378 379

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

394
        if filename is not None:
395 396 397 398
            load_var_list = []
            for name in sorted(load_var_map.keys()):
                load_var_list.append(load_var_map[name])

399
            load_block.append_op(
400
                type='load_combine',
401
                inputs={},
402
                outputs={"Out": load_var_list},
403
                attrs={'file_path': os.path.join(dirname, filename)})
404

405 406 407
        executor.run(load_prog)


408
def load_params(executor, dirname, main_program=None, filename=None):
409
    """
F
fengjiayi 已提交
410
    This function filters out all parameters from the give `main_program`
F
fengjiayi 已提交
411
    and then trys to load these parameters from the folder `dirname` or
F
fengjiayi 已提交
412 413
    the file `filename`.

414 415 416
    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 已提交
417 418
    `filename` to specify the file name.

419 420 421 422
    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 已提交
423 424 425 426 427 428 429 430

    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
431
        filename(str|None): The file which saved all parameters. If parameters
F
fengjiayi 已提交
432 433 434 435 436 437 438 439 440 441 442 443
                            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()
444
            fluid.io.load_params(executor=exe, dirname=param_path,
F
fengjiayi 已提交
445
                                main_program=None)
446 447
    """
    load_vars(
448 449 450
        executor,
        dirname=dirname,
        main_program=main_program,
451
        predicate=is_parameter,
452
        filename=filename)
453 454


455
def load_persistables(executor, dirname, main_program=None, filename=None):
456
    """
457 458
    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 已提交
459 460
    `dirname` or the file `filename`.

461 462 463
    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 已提交
464 465 466 467 468
    the file name.

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


497 498
def get_inference_program(target_vars, main_program=None):
    if main_program is None:
Y
Yu Yang 已提交
499
        main_program = default_main_program()
500 501
    if not isinstance(target_vars, list):
        target_vars = [target_vars]
W
wanghaoshuang 已提交
502 503 504
    vars = []
    for var in target_vars:
        if isinstance(var, Evaluator):
W
wanghaoshuang 已提交
505 506
            vars.extend(var.states)
            vars.extend(var.metrics)
W
wanghaoshuang 已提交
507 508 509
        else:
            vars.append(var)
    pruned_program = main_program.prune(targets=vars)
510 511 512 513
    inference_program = pruned_program.inference_optimize()
    return inference_program


514 515 516
def prepend_feed_ops(inference_program,
                     feed_target_names,
                     feed_holder_name='feed'):
Q
Qiao Longfei 已提交
517 518 519
    if len(feed_target_names) == 0:
        return

K
Kexin Zhao 已提交
520 521
    global_block = inference_program.global_block()
    feed_var = global_block.create_var(
522 523 524
        name=feed_holder_name,
        type=core.VarDesc.VarType.FEED_MINIBATCH,
        persistable=True)
K
Kexin Zhao 已提交
525

526
    for i, name in enumerate(feed_target_names):
K
fix bug  
Kexin Zhao 已提交
527
        out = global_block.var(name)
W
Wu Yi 已提交
528
        global_block._prepend_op(
K
Kexin Zhao 已提交
529 530
            type='feed',
            inputs={'X': [feed_var]},
K
fix bug  
Kexin Zhao 已提交
531
            outputs={'Out': [out]},
K
Kexin Zhao 已提交
532 533 534
            attrs={'col': i})


535 536 537
def append_fetch_ops(inference_program,
                     fetch_target_names,
                     fetch_holder_name='fetch'):
K
Kexin Zhao 已提交
538 539
    global_block = inference_program.global_block()
    fetch_var = global_block.create_var(
540 541 542
        name=fetch_holder_name,
        type=core.VarDesc.VarType.FETCH_LIST,
        persistable=True)
K
Kexin Zhao 已提交
543

544
    for i, name in enumerate(fetch_target_names):
K
Kexin Zhao 已提交
545 546 547 548 549 550 551
        global_block.append_op(
            type='fetch',
            inputs={'X': [name]},
            outputs={'Out': [fetch_var]},
            attrs={'col': i})


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

F
fengjiayi 已提交
584 585 586 587 588 589 590 591 592
    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 已提交
593

F
fengjiayi 已提交
594 595 596 597 598
            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)

599 600 601
            # 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 已提交
602
            # and parameters are going to be saved in separate files under folder
603
            # "./infer_model".
604 605

    """
606
    if isinstance(feeded_var_names, six.binary_type):
F
fengjiayi 已提交
607
        feeded_var_names = [feeded_var_names]
608 609
    elif isinstance(feeded_var_names, six.text_type):
        feeded_var_names = [feeded_var_names.encode()]
F
fengjiayi 已提交
610
    else:
Q
Qiao Longfei 已提交
611
        if len(feeded_var_names) > 0:
612
            # TODO(paddle-dev): polish these code blocks
Q
Qiao Longfei 已提交
613
            if not (bool(feeded_var_names) and all(
614 615 616 617 618 619 620 621 622 623 624
                    isinstance(name, six.binary_type)
                    for name in feeded_var_names)):
                if not (all(
                        isinstance(name, six.text_type)
                        for name in feeded_var_names)):
                    raise ValueError(
                        "'feed_var_names' should be a list of str.")
                else:
                    feeded_var_names = [
                        name.encode() for name in feeded_var_names
                    ]
F
fengjiayi 已提交
625 626

    if isinstance(target_vars, Variable):
F
fengjiayi 已提交
627
        target_vars = [target_vars]
F
fengjiayi 已提交
628 629 630 631 632
    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.")

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

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

640
    # Clear the is_target information and remove the existed feed and fetch op
641
    global_block = copy_program.global_block()
642 643 644
    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 已提交
645
            global_block._remove_op(i)
646
    copy_program.desc.flush()
647

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

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

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

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

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

668
    save_persistables(executor, dirname, inference_program, params_filename)
669 670


671 672 673 674
def load_inference_model(dirname,
                         executor,
                         model_filename=None,
                         params_filename=None):
675 676 677
    """
    Load inference model from a directory

F
fengjiayi 已提交
678 679 680 681
    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.
682
                                  If it is None, the default filename
F
fengjiayi 已提交
683 684 685
                                  '__model__' will be used.
                                  Default: None
        params_filename(str|None): The name of file to load all parameters.
686 687 688
                                   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 已提交
689 690 691 692
                                   files, set it as 'None'.

    Returns:
        tuple: The return of this function is a tuple with three elements:
693 694 695 696 697
        (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 已提交
698 699 700 701 702 703 704 705 706 707
        results.

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

    Examples:
        .. code-block:: python

            exe = fluid.Executor(fluid.CPUPlace())
            path = "./infer_model"
708
            [inference_program, feed_target_names, fetch_targets] =
F
fengjiayi 已提交
709 710 711 712 713
                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)

714 715 716 717 718
            # 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 已提交
719
            # program to get the inference result.
720

721 722 723 724
    """
    if not os.path.isdir(dirname):
        raise ValueError("There is no directory named '%s'", dirname)

725 726
    if model_filename is not None:
        model_filename = os.path.basename(model_filename)
727
    else:
728 729 730 731 732
        model_filename = "__model__"
    model_filename = os.path.join(dirname, model_filename)

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

734
    with open(model_filename, "rb") as f:
735 736
        program_desc_str = f.read()

737
    program = Program.parse_from_string(program_desc_str)
738
    load_persistables(executor, dirname, program, params_filename)
739

740 741
    feed_target_names = program.desc.get_feed_target_names()
    fetch_target_names = program.desc.get_fetch_target_names()
742 743 744 745 746
    fetch_targets = [
        program.global_block().var(name) for name in fetch_target_names
    ]

    return [program, feed_target_names, fetch_targets]
X
xuwei06 已提交
747 748 749 750


def get_parameter_value(para, executor):
    """
F
fengjiayi 已提交
751 752 753 754 755 756 757 758 759 760 761
    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 已提交
762

F
fengjiayi 已提交
763 764
    Examples:
        .. code-block:: python
X
xuwei06 已提交
765

F
fengjiayi 已提交
766 767 768
            exe = fluid.Executor(fluid.CPUPlace())
            param = fluid.default_main_program().global_block().var('fc.w')
            p = fluid.io.get_parameter_value(param, exe)
769

X
xuwei06 已提交
770
    """
X
xuwei06 已提交
771 772
    assert is_parameter(para)

X
xuwei06 已提交
773 774 775 776 777 778 779 780
    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 已提交
781
    Get the LoDTensor value of a certain parameter by its name.
X
xuwei06 已提交
782

F
fengjiayi 已提交
783 784 785 786 787 788 789
    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 已提交
790

F
fengjiayi 已提交
791 792
    Returns:
        numpy.array: The parameter's values.
793

F
fengjiayi 已提交
794 795 796 797 798
    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.
799

F
fengjiayi 已提交
800 801 802 803 804
    Examples:
        .. code-block:: python

            exe = fluid.Executor(fluid.CPUPlace())
            p = fluid.io.get_parameter_value('fc.w', exe)
X
xuwei06 已提交
805 806
    """
    if program is None:
Y
Yu Yang 已提交
807
        program = default_main_program()
X
xuwei06 已提交
808 809
    var = program.global_block().var(name)
    return get_parameter_value(var, executor)