io.py 36.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 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

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

__all__ = [
T
tangwei12 已提交
29
    'save_vars', 'save_params', 'save_persistables', 'load_vars', 'load_params',
30
    'load_persistables', 'save_inference_model', 'load_inference_model'
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
    """
    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

68
            param = fluid.default_main_program().global_block().var('fc.b')
F
fengjiayi 已提交
69 70
            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
            raise TypeError("program should be as Program type or None")

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

176 177 178 179 180
        if main_program is None:
            main_program = default_main_program()
        if not isinstance(main_program, Program):
            raise TypeError("program should be as Program type or None")

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

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

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

209 210 211 212 213 214 215 216 217 218
        # if there is lookup table, the trainer 0 will notify all pserver to save.
        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__")
            attrs = {}
            attrs['epmap'] = main_program._endpoints
            attrs['dir'] = lookup_table_filename
            attrs['lookup_table'] = main_program._distributed_lookup_table
            save_block.append_op(
                type='checkpoint_notify', inputs={}, outputs={}, attrs=attrs)

219 220 221
        executor.run(save_program)


222
def save_params(executor, dirname, main_program=None, filename=None):
223
    """
F
fengjiayi 已提交
224 225 226
    This function filters out all parameters from the give `main_program`
    and then save them to the folder `dirname` or the file `filename`.

227 228 229
    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 已提交
230 231
    the file name.

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


270
def save_persistables(executor, dirname, main_program=None, filename=None):
271
    """
272 273
    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 已提交
274 275
    or file `filename`.

276 277 278
    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 已提交
279 280 281 282 283
    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.
284 285
        main_program(Program|None): The program whose persistbale variables will
                                    be saved. If it is None, the default main
F
fengjiayi 已提交
286 287
                                    program will be used automatically.
                                    Default: None
288
        filename(str|None): The file to saved all variables. If you prefer to
F
fengjiayi 已提交
289 290 291 292 293 294 295 296 297 298 299 300
                            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()
301
            fluid.io.save_persistables(executor=exe, dirname=param_path,
F
fengjiayi 已提交
302
                                       main_program=None)
303 304 305 306
    """
    save_vars(
        executor,
        dirname=dirname,
307
        main_program=main_program,
308
        vars=None,
309
        predicate=is_persistable,
310
        filename=filename)
311 312


313 314 315 316 317
def load_vars(executor,
              dirname,
              main_program=None,
              vars=None,
              predicate=None,
318
              filename=None):
319
    """
F
fengjiayi 已提交
320 321
    Load variables from the given directory by executor.

322 323 324 325
    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 已提交
326 327
    are assigned, the `main_program` and the `predicate` will be ignored.

328 329 330
    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 已提交
331
    use `filename` to specify it.
332

F
fengjiayi 已提交
333 334 335
    Args:
        executor(Executor): The executor to run for loading variables.
        dirname(str): The directory path.
336 337
        main_program(Program|None): The program whose variables will be loaded.
                                    If it is None, the default main program will
F
fengjiayi 已提交
338 339
                                    be used automatically.
                                    Default: None
340
        vars(list[Variable]|None): The list that contains all variables to load.
F
fengjiayi 已提交
341 342
                                   It has a higher priority than the `main_program`.
                                   Default: None
343 344 345 346
        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 已提交
347 348
                                  `vars` is None).
                                  Default: None
349
        filename(str|None): The file which saved all required variables. If variables
F
fengjiayi 已提交
350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368
                            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
369

F
fengjiayi 已提交
370 371 372 373 374 375 376 377 378
            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]
379
            fluid.io.load_vars(executor=exe, dirname=path, vars=var_list,
F
fengjiayi 已提交
380
                               filename="vars_file")
381
            # var_a, var_b and var_c will be loaded. And they are supposed to haven
F
fengjiayi 已提交
382
            # been saved in the same file named 'var_file' in the path "./my_paddle_model".
383 384
    """
    if vars is None:
385
        if main_program is None:
Y
Yu Yang 已提交
386
            main_program = default_main_program()
387
        if not isinstance(main_program, Program):
388 389 390 391 392
            raise TypeError("program's type should be Program")

        load_vars(
            executor,
            dirname=dirname,
T
tangwei12 已提交
393
            main_program=main_program,
394
            vars=list(filter(predicate, main_program.list_vars())),
395
            filename=filename)
396 397 398
    else:
        load_prog = Program()
        load_block = load_prog.global_block()
399

400 401 402 403 404 405 406 407 408
        if main_program is None:
            main_program = default_main_program()
        if not isinstance(main_program, Program):
            raise TypeError("program should be as Program type or None")

        load_slice_vars = []
        for each_var in main_program._slice_vars_and_attrs:
            load_slice_vars.append(each_var[2].name)

409
        load_var_map = {}
410 411
        for each_var in vars:
            assert isinstance(each_var, Variable)
T
tangwei12 已提交
412 413
            if each_var.type == core.VarDesc.VarType.RAW:
                continue
414 415
            if each_var.name in load_slice_vars:
                continue
416
            new_var = _clone_var_in_block_(load_block, each_var)
417
            if filename is None:
418 419 420 421 422 423 424 425
                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

426
        if filename is not None:
427 428 429 430
            load_var_list = []
            for name in sorted(load_var_map.keys()):
                load_var_list.append(load_var_map[name])

431
            load_block.append_op(
432
                type='load_combine',
433
                inputs={},
434
                outputs={"Out": load_var_list},
435
                attrs={'file_path': os.path.join(dirname, filename)})
436 437
        executor.run(load_prog)

438 439
        # load slice vars on pserver, if have it.
        _load_slice_up_vars(executor, dirname,
T
tangwei12 已提交
440
                            main_program._slice_vars_and_attrs)
441

442

443
def load_params(executor, dirname, main_program=None, filename=None):
444
    """
F
fengjiayi 已提交
445
    This function filters out all parameters from the give `main_program`
F
fengjiayi 已提交
446
    and then trys to load these parameters from the folder `dirname` or
F
fengjiayi 已提交
447 448
    the file `filename`.

449 450 451
    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 已提交
452 453
    `filename` to specify the file name.

454 455 456 457
    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 已提交
458 459 460 461 462 463 464 465

    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
466
        filename(str|None): The file which saved all parameters. If parameters
F
fengjiayi 已提交
467 468 469 470 471 472 473 474 475 476 477 478
                            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()
479
            fluid.io.load_params(executor=exe, dirname=param_path,
F
fengjiayi 已提交
480
                                main_program=None)
481 482
    """
    load_vars(
483 484 485
        executor,
        dirname=dirname,
        main_program=main_program,
486
        predicate=is_parameter,
487
        filename=filename)
488 489


490
def load_persistables(executor, dirname, main_program=None, filename=None):
491
    """
492 493
    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 已提交
494 495
    `dirname` or the file `filename`.

496 497 498
    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 已提交
499 500 501 502 503
    the file name.

    Args:
        executor(Executor): The executor to run for loading persistable variables.
        dirname(str): The directory path.
504 505
        main_program(Program|None): The program whose persistbale variables will
                                    be loaded. If it is None, the default main
F
fengjiayi 已提交
506 507
                                    program will be used automatically.
                                    Default: None
508
        filename(str|None): The file which saved all variables. If variables were
F
fengjiayi 已提交
509 510 511 512 513 514 515 516 517 518 519 520
                            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()
521
            fluid.io.load_persistables(executor=exe, dirname=param_path,
F
fengjiayi 已提交
522
                                       main_program=None)
523 524
    """
    load_vars(
525 526 527
        executor,
        dirname=dirname,
        main_program=main_program,
528
        predicate=is_persistable,
529
        filename=filename)
530 531


532 533 534
def prepend_feed_ops(inference_program,
                     feed_target_names,
                     feed_holder_name='feed'):
Q
Qiao Longfei 已提交
535 536 537
    if len(feed_target_names) == 0:
        return

K
Kexin Zhao 已提交
538 539
    global_block = inference_program.global_block()
    feed_var = global_block.create_var(
540 541 542
        name=feed_holder_name,
        type=core.VarDesc.VarType.FEED_MINIBATCH,
        persistable=True)
K
Kexin Zhao 已提交
543

544
    for i, name in enumerate(feed_target_names):
K
fix bug  
Kexin Zhao 已提交
545
        out = global_block.var(name)
W
Wu Yi 已提交
546
        global_block._prepend_op(
K
Kexin Zhao 已提交
547 548
            type='feed',
            inputs={'X': [feed_var]},
K
fix bug  
Kexin Zhao 已提交
549
            outputs={'Out': [out]},
K
Kexin Zhao 已提交
550 551 552
            attrs={'col': i})


553 554 555
def append_fetch_ops(inference_program,
                     fetch_target_names,
                     fetch_holder_name='fetch'):
K
Kexin Zhao 已提交
556 557
    global_block = inference_program.global_block()
    fetch_var = global_block.create_var(
558 559 560
        name=fetch_holder_name,
        type=core.VarDesc.VarType.FETCH_LIST,
        persistable=True)
K
Kexin Zhao 已提交
561

562
    for i, name in enumerate(fetch_target_names):
K
Kexin Zhao 已提交
563 564 565 566 567 568 569
        global_block.append_op(
            type='fetch',
            inputs={'X': [name]},
            outputs={'Out': [fetch_var]},
            attrs={'col': i})


570 571 572 573
def save_inference_model(dirname,
                         feeded_var_names,
                         target_vars,
                         executor,
574
                         main_program=None,
575
                         model_filename=None,
576 577
                         params_filename=None,
                         export_for_deployment=True):
578
    """
F
fengjiayi 已提交
579 580 581 582 583
    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.
584
        feeded_var_names(list[str]): Names of variables that need to be feeded data
F
fengjiayi 已提交
585
                                     during inference.
586
        target_vars(list[Variable]): Variables from which we can get inference
F
fengjiayi 已提交
587 588
                                     results.
        executor(Executor): The executor that saves the inference model.
589 590
        main_program(Program|None): The original program, which will be pruned to
                                    build the inference model. If is setted None,
F
fengjiayi 已提交
591 592
                                    the default main program will be used.
                                    Default: None.
593 594
        model_filename(str|None): The name of file to save the inference program
                                  itself. If is setted None, a default filename
F
fengjiayi 已提交
595
                                  `__model__` will be used.
596 597
        params_filename(str|None): The name of file to save all related parameters.
                                   If it is setted None, parameters will be saved
F
fengjiayi 已提交
598
                                   in separate files .
X
Xin Pan 已提交
599 600 601 602 603
        export_for_deployment(bool): If True, programs are modified to only support
                                     direct inference deployment. Otherwise,
                                     more information will be stored for flexible
                                     optimization and re-training. Currently, only
                                     True is supported.
604

F
fengjiayi 已提交
605 606 607 608 609 610 611 612 613
    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 已提交
614

F
fengjiayi 已提交
615 616 617 618 619
            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)

620 621 622
            # 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 已提交
623
            # and parameters are going to be saved in separate files under folder
624
            # "./infer_model".
625 626

    """
M
minqiyang 已提交
627
    if isinstance(feeded_var_names, six.string_types):
F
fengjiayi 已提交
628
        feeded_var_names = [feeded_var_names]
X
Xin Pan 已提交
629
    elif export_for_deployment:
Q
Qiao Longfei 已提交
630
        if len(feeded_var_names) > 0:
631
            # TODO(paddle-dev): polish these code blocks
Q
Qiao Longfei 已提交
632
            if not (bool(feeded_var_names) and all(
M
minqiyang 已提交
633
                    isinstance(name, six.string_types)
634
                    for name in feeded_var_names)):
M
minqiyang 已提交
635
                raise ValueError("'feed_var_names' should be a list of str.")
F
fengjiayi 已提交
636 637

    if isinstance(target_vars, Variable):
F
fengjiayi 已提交
638
        target_vars = [target_vars]
X
Xin Pan 已提交
639
    elif export_for_deployment:
F
fengjiayi 已提交
640 641 642 643
        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.")

644
    if main_program is None:
Y
Yu Yang 已提交
645
        main_program = default_main_program()
X
Xin Pan 已提交
646

647 648
    # when a pserver and a trainer running on the same machine, mkdir may conflict
    try:
649
        os.makedirs(dirname)
650 651 652 653
    except OSError as e:
        if e.errno != errno.EEXIST:
            raise

X
Xin Pan 已提交
654 655 656 657 658
    if model_filename is not None:
        model_basename = os.path.basename(model_filename)
    else:
        model_basename = "__model__"
    model_basename = os.path.join(dirname, model_basename)
659

X
Xin Pan 已提交
660 661 662 663
    # When export_for_deployment is true, we modify the program online so that
    # it can only be loaded for inference directly. If it's false, the whole
    # original program and related meta are saved so that future usage can be
    # more flexible.
664 665 666

    origin_program = main_program.clone()

X
Xin Pan 已提交
667
    if export_for_deployment:
X
Xin Pan 已提交
668 669
        main_program = main_program.clone()
        global_block = main_program.global_block()
X
Xin Pan 已提交
670 671 672 673
        for i, op in enumerate(global_block.ops):
            op.desc.set_is_target(False)
            if op.type == "feed" or op.type == "fetch":
                global_block._remove_op(i)
X
Xin Pan 已提交
674
        main_program.desc.flush()
X
Xin Pan 已提交
675

X
Xin Pan 已提交
676 677
        main_program = main_program._prune(targets=target_vars)
        main_program = main_program._inference_optimize(prune_read_op=True)
X
Xin Pan 已提交
678 679
        fetch_var_names = [v.name for v in target_vars]

X
Xin Pan 已提交
680 681 682 683 684
        prepend_feed_ops(main_program, feeded_var_names)
        append_fetch_ops(main_program, fetch_var_names)

        with open(model_basename, "wb") as f:
            f.write(main_program.desc.serialize_to_string())
X
Xin Pan 已提交
685 686 687
    else:
        # TODO(panyx0718): Save more information so that it can also be used
        # for training and more flexible post-processing.
X
Xin Pan 已提交
688 689
        with open(model_basename + ".main_program", "wb") as f:
            f.write(main_program.desc.serialize_to_string())
T
tangwei12 已提交
690

691 692
    main_program._copy_dist_param_info_from(origin_program)

X
fix  
Xin Pan 已提交
693 694
    if params_filename is not None:
        params_filename = os.path.basename(params_filename)
695

X
fix  
Xin Pan 已提交
696 697
    save_persistables(executor, dirname, main_program, params_filename)

698

699 700 701
def load_inference_model(dirname,
                         executor,
                         model_filename=None,
T
tangwei12 已提交
702 703
                         params_filename=None,
                         pserver_endpoints=None):
704 705 706
    """
    Load inference model from a directory

F
fengjiayi 已提交
707 708 709 710
    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.
711
                                  If it is None, the default filename
F
fengjiayi 已提交
712 713 714
                                  '__model__' will be used.
                                  Default: None
        params_filename(str|None): The name of file to load all parameters.
715 716 717
                                   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 已提交
718
                                   files, set it as 'None'.
719 720 721 722
        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 已提交
723 724 725

    Returns:
        tuple: The return of this function is a tuple with three elements:
726 727 728 729 730
        (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 已提交
731 732 733 734 735 736 737 738 739 740
        results.

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

    Examples:
        .. code-block:: python

            exe = fluid.Executor(fluid.CPUPlace())
            path = "./infer_model"
741
            endpoints = ["127.0.0.1:2023","127.0.0.1:2024"]
742
            [inference_program, feed_target_names, fetch_targets] =
F
fengjiayi 已提交
743 744 745 746 747
                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)

748 749 750
            # if we need lookup table, we will use:
            fluid.io.load_inference_model(dirname=path, executor=exe, pserver_endpoints=endpoints)

751 752 753 754 755
            # 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 已提交
756
            # program to get the inference result.
757

758 759 760 761
    """
    if not os.path.isdir(dirname):
        raise ValueError("There is no directory named '%s'", dirname)

762 763
    if model_filename is not None:
        model_filename = os.path.basename(model_filename)
764
    else:
765 766 767 768 769
        model_filename = "__model__"
    model_filename = os.path.join(dirname, model_filename)

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

771
    with open(model_filename, "rb") as f:
772 773
        program_desc_str = f.read()

774
    program = Program.parse_from_string(program_desc_str)
X
Xin Pan 已提交
775
    if not core._is_program_version_supported(program._version()):
X
version  
Xin Pan 已提交
776 777 778
        raise ValueError("Unsupported program version: %d\n" %
                         program._version())
    # Binary data also need versioning.
779
    load_persistables(executor, dirname, program, params_filename)
780

T
tangwei12 已提交
781
    if pserver_endpoints:
T
tangwei12 已提交
782
        program = _endpoints_replacement(program, pserver_endpoints)
T
tangwei12 已提交
783

784 785
    feed_target_names = program.desc.get_feed_target_names()
    fetch_target_names = program.desc.get_fetch_target_names()
786 787 788 789 790
    fetch_targets = [
        program.global_block().var(name) for name in fetch_target_names
    ]

    return [program, feed_target_names, fetch_targets]
X
xuwei06 已提交
791 792


T
tangwei12 已提交
793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829
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 已提交
830
    attrs['epmap'] = pserver_endpoints
T
tangwei12 已提交
831 832 833 834 835 836 837 838 839 840 841
    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 已提交
842 843
        if op.has_attr(ENDPOINT_MAP):
            op.set_attr(ENDPOINT_MAP, endpoints)
T
fix  
tangwei12 已提交
844
    program._sync_with_cpp()
T
tangwei12 已提交
845
    return program
T
tangwei12 已提交
846 847


X
xuwei06 已提交
848 849
def get_parameter_value(para, executor):
    """
F
fengjiayi 已提交
850 851 852 853 854 855 856 857 858 859 860
    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 已提交
861

F
fengjiayi 已提交
862 863
    Examples:
        .. code-block:: python
X
xuwei06 已提交
864

F
fengjiayi 已提交
865 866 867
            exe = fluid.Executor(fluid.CPUPlace())
            param = fluid.default_main_program().global_block().var('fc.w')
            p = fluid.io.get_parameter_value(param, exe)
868

X
xuwei06 已提交
869
    """
X
xuwei06 已提交
870 871
    assert is_parameter(para)

X
xuwei06 已提交
872 873 874 875 876 877 878 879
    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 已提交
880
    Get the LoDTensor value of a certain parameter by its name.
X
xuwei06 已提交
881

F
fengjiayi 已提交
882 883 884 885 886 887 888
    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 已提交
889

F
fengjiayi 已提交
890 891
    Returns:
        numpy.array: The parameter's values.
892

F
fengjiayi 已提交
893 894 895 896 897
    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.
898

F
fengjiayi 已提交
899 900 901 902 903
    Examples:
        .. code-block:: python

            exe = fluid.Executor(fluid.CPUPlace())
            p = fluid.io.get_parameter_value('fc.w', exe)
X
xuwei06 已提交
904 905
    """
    if program is None:
Y
Yu Yang 已提交
906
        program = default_main_program()
X
xuwei06 已提交
907 908
    var = program.global_block().var(name)
    return get_parameter_value(var, executor)
T
tangwei12 已提交
909 910


T
tangwei12 已提交
911 912
def _load_slice_up_vars(executor, dirname, slice_vars_and_attrs):
    if not slice_vars_and_attrs:
913 914 915 916
        return

    load_prog = Program()
    load_block = load_prog.global_block()
T
tangwei12 已提交
917
    need_delete_vars = []
918

T
tangwei12 已提交
919
    for var_tuple in slice_vars_and_attrs:
920 921 922
        orig_var = var_tuple[0]
        start = var_tuple[1]
        slice_var = var_tuple[2]
T
tangwei12 已提交
923
        end = start + slice_var.shape[0]
924

925 926 927
        orig_var_name = orig_var.name
        orig_var.name = "{}.origin".format(orig_var_name)

928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945
        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]},
946
            attrs={'file_path': os.path.join(dirname, orig_var_name)})
947 948 949 950 951 952 953
        load_block.append_op(
            type="slice",
            inputs={'Input': clone_orig_var},
            outputs={'Out': clone_slice_var},
            attrs={'axes': [0],
                   'starts': [start],
                   'ends': [end]})
T
tangwei12 已提交
954
        need_delete_vars.append(clone_orig_var)
955

T
tangwei12 已提交
956 957 958
    load_block.append_op(
        type='delete_var',
        inputs={'X': need_delete_vars}, )
959
    executor.run(load_prog)