tensor.py 21.4 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
#
Y
yuyang18 已提交
9
# Unlessf required by applicable law or agreed to in writing, software
D
dzhwinter 已提交
10 11 12 13 14
# 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

Y
Yu Yang 已提交
17
from ..layer_helper import LayerHelper
18
from ..param_attr import ParamAttr
X
xuwei06 已提交
19 20
from ..framework import convert_np_dtype_to_dtype_
from ..framework import Variable
21
from ..initializer import Constant, force_init_on_cpu
22
from ..core import VarDesc
23
from .layer_function_generator import templatedoc
X
xuwei06 已提交
24
import numpy
Y
Yu Yang 已提交
25 26

__all__ = [
27 28 29 30
    'create_tensor', 'create_parameter', 'create_global_var', 'cast', 'concat',
    'sums', 'assign', 'fill_constant_batch_size_like', 'fill_constant',
    'argmin', 'argmax', 'argsort', 'ones', 'zeros', 'reverse', 'has_inf',
    'has_nan', 'isfinite'
Y
Yu Yang 已提交
31 32 33
]


X
xuwei06 已提交
34
def create_tensor(dtype, name=None, persistable=False):
35
    """
Q
update  
qiaolongfei 已提交
36
    Create an variable, which will hold a LoDTensor with data type dtype.
37 38

    Args:
Q
update  
qiaolongfei 已提交
39
        dtype(string): 'float32'|'int32'|..., the data type of the
40
            created tensor.
Q
update  
qiaolongfei 已提交
41
        name(string): The name of the created tensor, if not set,
42
            the name will be a random unique one.
Q
update  
qiaolongfei 已提交
43
        persistable(bool): Set the persistable flag of the create tensor.
44 45 46 47 48 49 50 51 52

    Returns:
        Variable: The tensor variable storing the created tensor.

    Examples:
        .. code-block:: python

          tensor = fluid.layers.create_tensor(dtype='float32')
    """
Y
Yu Yang 已提交
53
    helper = LayerHelper("create_tensor", **locals())
X
xuwei06 已提交
54 55
    return helper.create_variable(
        name=helper.name, dtype=dtype, persistable=persistable)
Y
Yu Yang 已提交
56 57


58 59
def create_parameter(shape,
                     dtype,
X
xuwei06 已提交
60
                     name=None,
61 62 63 64
                     attr=None,
                     is_bias=False,
                     default_initializer=None):
    """
Y
yuyang18 已提交
65 66 67 68 69 70
    Create a parameter. The parameter is a learnable variable, which can have
    gradient, and can be optimized.

    NOTE: this is a very low-level API. This API is useful when you create
    operator by your self. instead of using layers.

71 72 73 74 75 76 77 78 79 80 81
    Args:
        shape(list[int]): shape of the parameter
        dtype(string): element type of the parameter
        attr(ParamAttr): attributes of the parameter
        is_bias(bool): This can affect which default initializer is chosen
                       when default_initializer is None. If is_bias,
                       initializer.Constant(0.0) will be used. Otherwise,
                       Xavier() will be used.
        default_initializer(Initializer): initializer for the parameter

    Returns:
Y
yuyang18 已提交
82 83 84 85 86 87
        the created parameter.

    Examples:
        >>> W = fluid.layers.create_parameter(shape=[784, 200], dtype='float32')
        >>> data = fluid.layers.data(name="img", shape=[64, 784], append_batch_size=False)
        >>> hidden = fluid.layers.matmul(x=data, y=W)
88
    """
Q
Qiao Longfei 已提交
89
    helper = LayerHelper("create_parameter", **locals())
90
    if attr is None:
X
xuwei06 已提交
91
        attr = ParamAttr(name=name)
92 93 94 95
    return helper.create_parameter(attr, shape, dtype, is_bias,
                                   default_initializer)


96 97 98 99 100 101 102
def create_global_var(shape,
                      value,
                      dtype,
                      persistable=False,
                      force_cpu=False,
                      name=None):
    """
X
Xin Pan 已提交
103
    Create a new tensor variable with value in the global block(block 0).
F
fengjiayi 已提交
104

105 106
    Args:
        shape(list[int]): shape of the variable
F
fengjiayi 已提交
107 108 109 110 111 112 113 114 115 116
        value(float): the value of the variable. The new created 
                      variable will be filled with it.
        dtype(string): data type of the variable
        persistable(bool): if this variable is persistable. 
                           Default: False
        force_cpu(bool): force this variable to be on CPU. 
                         Default: False
        name(str|None): The name of the variable. If set to None the variable 
                        name will be generated automatically. 
                        Default: None
117 118 119

    Returns:
        Variable: the created Variable
F
fengjiayi 已提交
120 121 122 123 124 125

    Examples:
        .. code-block:: python

            var = fluid.create_global_var(shape=[2,3], value=1.0, dtype='float32', 
                                 persistable=True, force_cpu=True, name='new_var')
126
    """
Q
Qiao Longfei 已提交
127 128 129 130
    helper = LayerHelper("global_var", **locals())
    var = helper.create_global_variable(
        dtype=dtype, shape=shape, persistable=persistable, name=name)
    helper.set_variable_initializer(
131 132
        var, initializer=Constant(
            value=float(value), force_cpu=force_cpu))
Q
Qiao Longfei 已提交
133 134 135
    return var


136
def cast(x, dtype):
Y
Yu Yang 已提交
137
    """
Y
Yibing Liu 已提交
138 139 140 141 142 143 144 145 146 147 148 149
    This layer takes in the Variable :attr:`x` with :attr:`x.dtype` and casts 
    it to the output with :attr:`dtype`.

    Args:
        x (Variable): The input Variable for casting.
        dtype(np.dtype|core.VarDesc.VarType|str): Data type of the output Variable.

    Returns:
        Variable: The output Variable after casting.

    Examples:
        .. code-block:: python
F
fengjiayi 已提交
150

Y
Yibing Liu 已提交
151 152
            data = fluid.layers.data(name='x', shape=[13], dtype='float32')
            result = fluid.layers.cast(x=data, dtype='float64')
Y
Yu Yang 已提交
153 154
    """
    helper = LayerHelper('cast', **locals())
X
Xin Pan 已提交
155
    out = helper.create_variable_for_type_inference(dtype=dtype)
Y
Yu Yang 已提交
156 157 158 159 160 161 162 163 164
    helper.append_op(
        type='cast',
        inputs={'X': [x]},
        outputs={'Out': [out]},
        attrs={'in_dtype': x.dtype,
               'out_dtype': out.dtype})
    return out


165
def concat(input, axis=0, name=None):
Y
Yu Yang 已提交
166
    """
167 168 169
    **Concat**

    This function concatenates the input along the axis mentioned
Y
Yu Yang 已提交
170
    and returns that as the output.
171 172 173 174

    Args:
        input(list): List of tensors to be concatenated
        axis(int): Integer axis along which the tensors will be concatenated
175 176
        name(str|None): A name for this layer(optional). If set None, the layer
                       will be named automatically.
177 178 179 180 181 182

    Returns:
        Variable: Output variable of the concatenation

    Examples:
        .. code-block:: python
F
fengjiayi 已提交
183

F
fengjiayi 已提交
184
           out = fluid.layers.concat(input=[Efirst, Esecond, Ethird, Efourth])
Y
Yu Yang 已提交
185 186
    """
    helper = LayerHelper('concat', **locals())
X
Xin Pan 已提交
187
    out = helper.create_variable_for_type_inference(dtype=helper.input_dtype())
Y
Yu Yang 已提交
188 189 190 191 192 193 194 195
    helper.append_op(
        type='concat',
        inputs={'X': input},
        outputs={'Out': [out]},
        attrs={'axis': axis})
    return out


196
def sums(input, out=None):
F
fengjiayi 已提交
197 198
    """
    This function performs the sum operation on the input and returns the
K
kavyasrinet 已提交
199 200 201 202 203
    result as the output.

    Args:
        input (Variable|list): The input tensor that has the elements
                               that need to be summed up.
F
fengjiayi 已提交
204
        out (Variable|None): Output parameter. The sum result.
F
fengjiayi 已提交
205
                             Default: None
K
kavyasrinet 已提交
206 207

    Returns:
F
fengjiayi 已提交
208
        Variable: the sum of input. The same as the argument 'out'
K
kavyasrinet 已提交
209 210

    Examples:
F
fengjiayi 已提交
211
        .. code-block:: python
K
kavyasrinet 已提交
212 213 214 215 216 217

          tmp = fluid.layers.zeros(shape=[10], dtype='int32')
          i = fluid.layers.fill_constant(shape=[1], dtype='int64', value=10)
          a0 = layers.array_read(array=tmp, i=i)
          i = layers.increment(x=i)
          a1 = layers.array_read(array=tmp, i=i)
Y
Yu Yang 已提交
218 219
          mean_a0 = layers.mean(a0)
          mean_a1 = layers.mean(a1)
K
kavyasrinet 已提交
220
          a_sum = layers.sums(input=[mean_a0, mean_a1])
Y
Yu Yang 已提交
221 222 223
    """
    helper = LayerHelper('sum', **locals())
    if out is None:
X
Xin Pan 已提交
224 225
        out = helper.create_variable_for_type_inference(
            dtype=helper.input_dtype())
T
tensor-tang 已提交
226 227 228 229 230
    helper.append_op(
        type='sum',
        inputs={'X': input},
        outputs={'Out': out},
        attrs={'use_mkldnn': False})
Y
Yu Yang 已提交
231 232 233
    return out


F
fengjiayi 已提交
234
def assign(input, output=None):
235 236 237 238 239 240
    """
    **Assign**

    This function copies the *input* Variable to the *output* Variable.

    Args:
X
xuwei06 已提交
241
        input(Variable|numpy.ndarray): The source variable
F
fengjiayi 已提交
242
        output(Variable|None): The destination variable
243 244 245 246 247 248

    Returns:
        Variable: The destination variable that was supplied as the *output*.

    Examples:
        .. code-block:: python
249

250 251 252 253
          out = fluid.layers.create_tensor(dtype='float32')
          hidden = fluid.layers.fc(input=data, size=10)
          fluid.layers.assign(hidden, out)
    """
Y
Yu Yang 已提交
254
    helper = LayerHelper('assign', **locals())
F
fengjiayi 已提交
255
    if output is None:
X
Xin Pan 已提交
256
        output = helper.create_variable_for_type_inference(dtype=input.dtype)
X
xuwei06 已提交
257 258
    if isinstance(input, Variable):
        helper.append_op(
R
robot 已提交
259
            type='assign', inputs={'X': [input]}, outputs={'Out': [output]})
X
xuwei06 已提交
260 261
    elif isinstance(input, numpy.ndarray):
        dtype = convert_np_dtype_to_dtype_(input.dtype)
262
        if dtype == VarDesc.VarType.FP32:
X
xuwei06 已提交
263
            value_name = "fp32_values"
264
            values = [float(v) for v in input.flat]
265
        elif dtype == VarDesc.VarType.INT32:
X
xuwei06 已提交
266
            value_name = "int32_values"
267
            values = [int(v) for v in input.flat]
X
xuwei06 已提交
268 269
        else:
            raise ValueError("Unsupported dtype %s", input.dtype)
270 271 272
        if input.size > 1024 * 1024:
            raise ValueError("The size of input is too big. Please consider "
                             "saving it to file and 'load_op' to load it")
X
xuwei06 已提交
273 274 275 276 277 278 279

        helper.append_op(
            type='assign_value',
            outputs={'Out': [output]},
            attrs={
                'dtype': dtype,
                'shape': list(input.shape),
280
                value_name: values
X
xuwei06 已提交
281 282 283 284
            })
    else:
        raise ValueError("Wrong type for assign input: %s" % type(input))

Y
Yu Yang 已提交
285 286 287
    return output


Q
QI JUN 已提交
288
def fill_constant(shape, dtype, value, force_cpu=False, out=None):
Y
Yu Yang 已提交
289
    """
290 291
    **fill_constant**

292 293
    This function creates a tensor with specified `shape` and `dtype`, and
    initializes it with a constant specifed by `value`.
K
kavyasrinet 已提交
294

295
    The attribute `stop_gradient` of the created tensor is set to True.
296 297

    Args:
298
        shape(tuple|list|None): Shape of the output tensor.
299
        dtype(np.dtype|core.VarDesc.VarType|str): Data type of the output tensor.
300 301
        value(float): The constant value used to initialize the output tensor.
        out(Variable): The output tensor.
302
        force_cpu(True|False): data should be on CPU if set true.
303 304

    Returns:
305
        Variable: The tensor variable storing the output.
306 307 308 309 310

    Examples:
        .. code-block:: python

          data = fluid.layers.fill_constant(shape=[1], value=0, dtype='int64')
Y
Yu Yang 已提交
311
    """
312

Y
Yu Yang 已提交
313 314
    helper = LayerHelper("fill_constant", **locals())
    if out is None:
X
Xin Pan 已提交
315
        out = helper.create_variable_for_type_inference(dtype=dtype)
Y
Yu Yang 已提交
316 317 318 319
    helper.append_op(
        type='fill_constant',
        inputs={},
        outputs={'Out': [out]},
Q
QI JUN 已提交
320 321 322 323
        attrs={
            'shape': shape,
            'dtype': out.dtype,
            'value': float(value),
324
            'force_cpu': force_cpu or force_init_on_cpu()
Q
QI JUN 已提交
325
        })
Y
Yu Yang 已提交
326 327 328 329
    out.stop_gradient = True
    return out


Y
yuyang18 已提交
330
@templatedoc()
Y
Yu Yang 已提交
331 332 333 334 335
def fill_constant_batch_size_like(input,
                                  shape,
                                  dtype,
                                  value,
                                  input_dim_idx=0,
336
                                  output_dim_idx=0):
337
    """
Y
yuyang18 已提交
338
    ${comment}
339 340 341

    It also sets *stop_gradient* to True.

Y
yuyang18 已提交
342 343 344
    >>> data = fluid.layers.fill_constant_batch_size_like(
    >>>             input=like, shape=[1], value=0, dtype='int64')

345
    Args:
Y
yuyang18 已提交
346
        input(${input_type}): ${input_comment}.
347

Y
yuyang18 已提交
348
        shape(${shape_type}): ${shape_comment}.
349

Y
yuyang18 已提交
350 351 352
        dtype(${dtype_type}): ${dtype_comment}.

        value(${value_type}): ${value_comment}.
353

Y
yuyang18 已提交
354 355 356 357 358
        input_dim_idx(${input_dim_idx_type}): ${input_dim_idx_comment}.

        output_dim_idx(${output_dim_idx_type}): ${output_dim_idx_comment}.

    Returns:
Y
yuyang18 已提交
359
        ${out_comment}.
360
    """
Y
Yu Yang 已提交
361
    helper = LayerHelper("fill_constant_batch_size_like", **locals())
X
Xin Pan 已提交
362
    out = helper.create_variable_for_type_inference(dtype=dtype)
Y
Yu Yang 已提交
363 364 365 366 367 368 369 370 371 372 373 374 375 376 377
    helper.append_op(
        type='fill_constant_batch_size_like',
        inputs={'Input': input},
        outputs={'Out': [out]},
        attrs={
            'shape': shape,
            'dtype': out.dtype,
            'value': float(value),
            'input_dim_idx': input_dim_idx,
            'output_dim_idx': output_dim_idx
        })
    out.stop_gradient = True
    return out


S
sneaxiy 已提交
378 379 380 381
def argmin(x, axis=0):
    """
    **argmin**

382
    This function computes the indices of the min elements
S
sneaxiy 已提交
383 384 385 386 387 388
    of the input tensor's element along the provided axis.

    Args:
        x(Variable): The input to compute the indices of
                     the min elements.
        axis(int): Axis to compute indices along.
F
fengjiayi 已提交
389

S
sneaxiy 已提交
390 391
    Returns:
        Variable: The tensor variable storing the output
F
fengjiayi 已提交
392

S
sneaxiy 已提交
393 394
    Examples:
        .. code-block:: python
F
fengjiayi 已提交
395

S
sneaxiy 已提交
396
          out = fluid.layers.argmin(x=in, axis=0)
397
          out = fluid.layers.argmin(x=in, axis=-1)
S
sneaxiy 已提交
398 399
    """
    helper = LayerHelper("arg_min", **locals())
X
Xin Pan 已提交
400
    out = helper.create_variable_for_type_inference(VarDesc.VarType.INT64)
S
sneaxiy 已提交
401 402 403 404 405 406 407 408 409 410 411 412
    helper.append_op(
        type='arg_min',
        inputs={'X': x},
        outputs={'Out': [out]},
        attrs={'axis': axis})
    return out


def argmax(x, axis=0):
    """
    **argmax**

413
    This function computes the indices of the max elements
S
sneaxiy 已提交
414 415 416 417 418 419
    of the input tensor's element along the provided axis.

    Args:
        x(Variable): The input to compute the indices of
                     the max elements.
        axis(int): Axis to compute indices along.
F
fengjiayi 已提交
420

S
sneaxiy 已提交
421 422
    Returns:
        Variable: The tensor variable storing the output
F
fengjiayi 已提交
423

S
sneaxiy 已提交
424 425
    Examples:
        .. code-block:: python
F
fengjiayi 已提交
426

S
sneaxiy 已提交
427
          out = fluid.layers.argmax(x=in, axis=0)
428
          out = fluid.layers.argmax(x=in, axis=-1)
S
sneaxiy 已提交
429 430
    """
    helper = LayerHelper("arg_max", **locals())
X
Xin Pan 已提交
431
    out = helper.create_variable_for_type_inference(VarDesc.VarType.INT64)
S
sneaxiy 已提交
432 433 434 435 436 437 438 439
    helper.append_op(
        type='arg_max',
        inputs={'X': x},
        outputs={'Out': [out]},
        attrs={'axis': axis})
    return out


440
def argsort(input, axis=-1, name=None):
Y
Yibing Liu 已提交
441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467
    """
    Performs sorting on the input Variable along the given axis, and outputs 
    sorted data Varibale and its corresponding index Variable with the same 
    shape as :attr:`input`.

    .. code-block:: text
    
        For example, the given axis is -1 and the input Variable

            input = [[0.15849551, 0.45865775, 0.8563702 ],
                     [0.12070083, 0.28766365, 0.18776911]],

        after argsort, the sorted Vairable becomes

            out = [[0.15849551, 0.45865775, 0.8563702 ],
                   [0.12070083, 0.18776911, 0.28766365]],

        and the sorted indices along the given axis turn outs to be

            indices = [[0, 1, 2], 
                       [0, 2, 1]]

    Args:
        input(Variable): The input Variable for sorting.
        axis(int): The axis along which to sort the input Variable. When 
                   :attr:`axis` < 0, the actual axis will be :attr:`axis` + 
                   rank(:attr:`input`). Default -1, the last dimension.
468 469
        name(str|None): (optional) A name for this layer. If set None, the 
                   layer will be named automatically.
Y
Yibing Liu 已提交
470 471 472 473 474 475 476 477 478 479 480

    Returns:
        tuple: A tuple of sorted data Variable and the sorted indices.

    Examples:
        .. code-block:: python

            input = fluid.layers.data(data=[2, 3])
            out, indices = fluid.layers.argsort(input, axis=0)
    """
    helper = LayerHelper("argsort", **locals())
X
Xin Pan 已提交
481 482 483 484
    out = helper.create_variable_for_type_inference(
        dtype=input.dtype, stop_gradient=True)
    ids = helper.create_variable_for_type_inference(
        VarDesc.VarType.INT64, stop_gradient=True)
Y
Yibing Liu 已提交
485 486 487 488
    helper.append_op(
        type='argsort',
        inputs={'X': input},
        outputs={'Out': out,
489 490
                 'Indices': ids},
        attrs={'axis': axis})
Y
Yibing Liu 已提交
491 492 493
    return out, ids


Y
Yang Yu 已提交
494
def ones(shape, dtype, force_cpu=False):
Y
Yu Yang 已提交
495
    """
496 497 498 499 500 501 502 503 504
    **ones**

    This function creates a tensor of specified *shape* and
    *dtype*, and initializes this with 1.

    It also sets *stop_gradient* to True.

    Args:
        shape(tuple|list|None): Shape of output tensor
505
        dtype(np.dtype|core.VarDesc.VarType|str): Data type of output tensor
506 507 508 509 510 511 512 513

    Returns:
        Variable: The tensor variable storing the output

    Examples:
        .. code-block:: python

          data = fluid.layers.ones(shape=[1], dtype='int64')
Y
Yu Yang 已提交
514 515 516 517
    """
    return fill_constant(value=1.0, **locals())


Y
Yang Yu 已提交
518
def zeros(shape, dtype, force_cpu=False):
Y
Yu Yang 已提交
519
    """
520 521 522 523 524 525 526 527
    **zeros**

    This function creates a tensor of specified *shape* and
    *dtype*, and initializes this with 0.

    It also sets *stop_gradient* to True.

    Args:
W
wanghaoshuang 已提交
528 529 530
        shape(tuple|list|None): Shape of output tensor.
        dtype(np.dtype|core.VarDesc.VarType|str): Data type of output tensor.
        force_cpu(bool, default False): Whether to make output stay on CPU.
531 532

    Returns:
W
wanghaoshuang 已提交
533
        Variable: The tensor variable storing the output.
534 535 536 537 538

    Examples:
        .. code-block:: python

          data = fluid.layers.zeros(shape=[1], dtype='int64')
Y
Yu Yang 已提交
539 540
    """
    return fill_constant(value=0.0, **locals())
541 542


F
fengjiayi 已提交
543 544 545 546 547 548 549 550
def reverse(x, axis):
    """
    **reverse**

    This function reverse the input 'x' along given axises.

    Args:
        x(Vairbale): the input to be reversed.
551 552 553
        axis(int|tuple|list): Axis that along which order of elements
                    is reversed. If it is a tuple or a list, reversing
                    will be apply on each axis in the tuple or list.
F
fengjiayi 已提交
554 555 556 557 558 559 560 561 562 563 564 565 566 567

    Returns:
        Variable: The reversed tensor.

    Examples:
        .. code-block:: python

          out = fluid.layers.reverse(x=in, axis=0)
          # or:
          out = fluid.layers.reverse(x=in, axis=[0,1])
    """
    if isinstance(axis, int):
        axis = [axis]
    helper = LayerHelper("reverse", **locals())
X
Xin Pan 已提交
568
    out = helper.create_variable_for_type_inference(dtype=x.dtype)
F
fengjiayi 已提交
569 570 571 572 573 574 575 576
    helper.append_op(
        type='reverse',
        inputs={'Input': x},
        outputs={'Out': [out]},
        attrs={'axis': axis})
    return out


577 578 579 580 581 582 583
def save(x, file_path, overwrite=True):
    """
    Saves a variable as a file.

    Args:
        x(variable): The Tensor/LoDTensor to be saved.
        file_path(str): The file path where the variable will be saved.
584 585 586
        overwrite(bool): Whether or not cover the given file when it has already
            existed. If it's set 'False' and the file is existed, a runtime
            error will be thrown.
587 588 589 590 591 592 593 594 595 596 597 598 599 600 601
    """
    helper = LayerHelper("save", **locals())
    helper.append_op(
        type="save",
        inputs={"input": x},
        outputs={},
        args={"file_path": file_path,
              "overwrite": overwrite})


def save_combine(x, file_path, overwrite=True):
    """
    Saves a list of variables into a single file.

    Args:
602 603
        x(list): A list of Tensor/LoDTensor variables to be saved together in
                 a single file.
604
        file_path(str): The file path where variables will be saved.
605
        overwrite(bool): Whether or not cover the given file when it has already
606 607
            existed. If it's set 'False' and the file is existed, a runtime
            error will be thrown.
608 609 610 611 612 613 614 615 616 617 618 619 620 621 622

    Returns:
        There is no return value.

    Examples:

        .. code-block:: python

            v1 = fluid.layers.data(name="data",
                                   shape=(4, 6),
                                   dtype="float32")
            v2 = fluid.layers.data(name="data",
                                   shape=(6, 8, 4),
                                   dtype="float32")
            normed = fluid.layers.save_combine([v1, v2], file_path="output")
623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646
    """
    helper = LayerHelper("save_combine", **locals())
    helper.append_op(
        type="save_combine",
        inputs={"input": x},
        outputs={},
        args={"file_path": file_path,
              "overwrite": overwrite})


def load_combine(out, file_path):
    """
    Loads a list of vairables from a single file.

    Args:
        out(list): The list of variables to be read from the disk file.
        file_path(str): The path of the disk file.
    """
    helper = LayerHelper("load_combine", **locals())
    helper.append_op(
        type="load_combine",
        inputs={},
        output={"Out": out},
        args={"file_path": file_path})
647 648 649 650 651 652 653 654 655 656 657 658 659


def has_inf(x):
    """
    Test if any of x contains an infinity number

    Args:
       x(variable): The Tensor/LoDTensor to be checked.

    Returns:
        Variable: The tensor variable storing the output, only a bool value.
    """
    helper = LayerHelper("isinf", **locals())
X
Xin Pan 已提交
660
    out = helper.create_variable_for_type_inference(dtype=x.dtype)
661 662 663 664 665 666 667 668 669 670 671 672 673 674 675
    helper.append_op(type="isinf", inputs={"X": x}, outputs={"Out": out})
    return out


def has_nan(x):
    """
    Test if any of x contains a NAN

    Args:
       x(variable): The Tensor/LoDTensor to be checked.

    Returns:
        Variable: The tensor variable storing the output, only a bool value.
    """
    helper = LayerHelper("isnan", **locals())
X
Xin Pan 已提交
676
    out = helper.create_variable_for_type_inference(dtype=x.dtype)
677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692
    helper.append_op(type="isnan", inputs={"X": x}, outputs={"Out": out})
    return out


def isfinite(x):
    """
    Test if any of x contains an infinity/NAN number. If all the elements are finite,
    returns true, else false.

    Args:
       x(variable): The Tensor/LoDTensor to be checked.

    Returns:
        Variable: The tensor variable storing the output, contains a bool value.
    """
    helper = LayerHelper("isfinite", **locals())
X
Xin Pan 已提交
693
    out = helper.create_variable_for_type_inference(dtype=x.dtype)
694 695
    helper.append_op(type="isfinite", inputs={"X": x}, outputs={"Out": out})
    return out