io.py 30.3 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 558
                         model_filename=None,
                         params_filename=None):
559
    """
F
fengjiayi 已提交
560 561 562 563 564
    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.
565
        feeded_var_names(list[str]): Names of variables that need to be feeded data
F
fengjiayi 已提交
566
                                     during inference.
567
        target_vars(list[Variable]): Variables from which we can get inference
F
fengjiayi 已提交
568 569
                                     results.
        executor(Executor): The executor that saves the inference model.
570 571
        main_program(Program|None): The original program, which will be pruned to
                                    build the inference model. If is setted None,
F
fengjiayi 已提交
572 573
                                    the default main program will be used.
                                    Default: None.
574 575
        model_filename(str|None): The name of file to save the inference program
                                  itself. If is setted None, a default filename
F
fengjiayi 已提交
576
                                  `__model__` will be used.
577 578
        params_filename(str|None): The name of file to save all related parameters.
                                   If it is setted None, parameters will be saved
F
fengjiayi 已提交
579
                                   in separate files .
580

F
fengjiayi 已提交
581 582 583 584 585 586 587 588 589
    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 已提交
590

F
fengjiayi 已提交
591 592 593 594 595
            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)

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

    """
603
    if isinstance(feeded_var_names, six.binary_type):
F
fengjiayi 已提交
604
        feeded_var_names = [feeded_var_names]
605 606
    elif isinstance(feeded_var_names, six.text_type):
        feeded_var_names = [feeded_var_names.encode()]
F
fengjiayi 已提交
607
    else:
Q
Qiao Longfei 已提交
608
        if len(feeded_var_names) > 0:
609
            # TODO(paddle-dev): polish these code blocks
Q
Qiao Longfei 已提交
610
            if not (bool(feeded_var_names) and all(
611 612 613 614 615 616 617 618 619 620 621
                    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 已提交
622 623

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

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

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

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

645
    pruned_program = copy_program.prune(targets=target_vars)
646
    inference_program = pruned_program.inference_optimize()
647 648
    fetch_var_names = [v.name for v in target_vars]

K
Kexin Zhao 已提交
649 650
    prepend_feed_ops(inference_program, feeded_var_names)
    append_fetch_ops(inference_program, fetch_var_names)
651

652 653
    if model_filename is not None:
        model_filename = os.path.basename(model_filename)
654
    else:
655 656
        model_filename = "__model__"
    model_filename = os.path.join(dirname, model_filename)
657

658 659 660 661
    if params_filename is not None:
        params_filename = os.path.basename(params_filename)

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

664
    save_persistables(executor, dirname, inference_program, params_filename)
665 666


667 668 669 670
def load_inference_model(dirname,
                         executor,
                         model_filename=None,
                         params_filename=None):
671 672 673
    """
    Load inference model from a directory

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

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

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

    Examples:
        .. code-block:: python

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

710 711 712 713 714
            # 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 已提交
715
            # program to get the inference result.
716

717 718 719 720
    """
    if not os.path.isdir(dirname):
        raise ValueError("There is no directory named '%s'", dirname)

721 722
    if model_filename is not None:
        model_filename = os.path.basename(model_filename)
723
    else:
724 725 726 727 728
        model_filename = "__model__"
    model_filename = os.path.join(dirname, model_filename)

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

730
    with open(model_filename, "rb") as f:
731 732
        program_desc_str = f.read()

733
    program = Program.parse_from_string(program_desc_str)
734
    load_persistables(executor, dirname, program, params_filename)
735

736 737
    feed_target_names = program.desc.get_feed_target_names()
    fetch_target_names = program.desc.get_fetch_target_names()
738 739 740 741 742
    fetch_targets = [
        program.global_block().var(name) for name in fetch_target_names
    ]

    return [program, feed_target_names, fetch_targets]
X
xuwei06 已提交
743 744 745 746


def get_parameter_value(para, executor):
    """
F
fengjiayi 已提交
747 748 749 750 751 752 753 754 755 756 757
    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 已提交
758

F
fengjiayi 已提交
759 760
    Examples:
        .. code-block:: python
X
xuwei06 已提交
761

F
fengjiayi 已提交
762 763 764
            exe = fluid.Executor(fluid.CPUPlace())
            param = fluid.default_main_program().global_block().var('fc.w')
            p = fluid.io.get_parameter_value(param, exe)
765

X
xuwei06 已提交
766
    """
X
xuwei06 已提交
767 768
    assert is_parameter(para)

X
xuwei06 已提交
769 770 771 772 773 774 775 776
    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 已提交
777
    Get the LoDTensor value of a certain parameter by its name.
X
xuwei06 已提交
778

F
fengjiayi 已提交
779 780 781 782 783 784 785
    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 已提交
786

F
fengjiayi 已提交
787 788
    Returns:
        numpy.array: The parameter's values.
789

F
fengjiayi 已提交
790 791 792 793 794
    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.
795

F
fengjiayi 已提交
796 797 798 799 800
    Examples:
        .. code-block:: python

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