control_flow.py 63.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
# 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.
D
dzhwinter 已提交
14
import contextlib
D
dzhwinter 已提交
15

Y
yuyang18 已提交
16
from layer_function_generator import autodoc, templatedoc
Y
Yu Yang 已提交
17
from tensor import assign, fill_constant
18
from .. import core
19
from ..framework import Program, Variable, Operator
20
from ..layer_helper import LayerHelper, unique_name
J
JiayiFeng 已提交
21
from ..initializer import force_init_on_cpu
22
from ops import logical_and, logical_not, logical_or
Y
yuyang18 已提交
23
import numpy
D
dzhwinter 已提交
24

Q
QI JUN 已提交
25
__all__ = [
Y
ying 已提交
26 27 28 29 30 31 32
    'split_lod_tensor',
    'merge_lod_tensor',
    'BlockGuard',
    'BlockGuardWithCompletion',
    'StaticRNNMemoryLink',
    'WhileGuard',
    'While',
33
    'Switch',
Y
ying 已提交
34 35 36 37 38 39 40 41
    'lod_rank_table',
    'max_sequence_len',
    'lod_tensor_to_array',
    'array_to_lod_tensor',
    'increment',
    'array_write',
    'create_array',
    'less_than',
42
    'equal',
Y
ying 已提交
43 44 45 46 47 48 49 50 51 52
    'array_read',
    'shrink_memory',
    'array_length',
    'IfElse',
    'DynamicRNN',
    'ConditionalBlock',
    'StaticRNN',
    'reorder_lod_tensor_by_rank',
    'ParallelDo',
    'Print',
53
    'is_empty',
D
dzhwinter 已提交
54 55
]

Y
Yu Yang 已提交
56

57
def split_lod_tensor(input, mask, level=0):
58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87
    """
    **split_lod_tensor**

    This function takes in an input that contains the complete lod information,
    and takes in a mask which is used to mask certain parts of the input.
    The output is the true branch and the false branch with the mask applied to
    the input at a certain level in the tensor.

    Args:
        input(tuple|list|None): The input tensor that contains complete
                                lod information needed to construct the output.
        mask(list): A bool column vector which masks the input.
        level(int): The specific lod level to rank.

    Returns:
        Variable: The true branch of tensor as per the mask applied to input.
        Variable: The false branch of tensor as per the mask applied to input.

    Examples:
        .. code-block:: python

          x = layers.data(name='x', shape=[1])
          x.persistable = True

          y = layers.data(name='y', shape=[1])
          y.persistable = True

          out_true, out_false = layers.split_lod_tensor(
                input=x, mask=y, level=level)
    """
88
    helper = LayerHelper('split_lod_tensor', **locals())
F
fengjiayi 已提交
89 90
    out_true = helper.create_tmp_variable(dtype=input.dtype)
    out_false = helper.create_tmp_variable(dtype=input.dtype)
91 92 93 94 95 96 97 98 99 100 101 102
    helper.append_op(
        type='split_lod_tensor',
        inputs={
            'X': input,
            'Mask': mask,
        },
        outputs={'OutTrue': out_true,
                 'OutFalse': out_false},
        attrs={'level': level})
    return out_true, out_false


103
def merge_lod_tensor(in_true, in_false, x, mask, level=0):
104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137
    """
    **merge_lod_tensor**

    This function takes in an input :math:`x`, the True branch, the False
    branch and a binary :math:`mask`. Using this information, this function
    merges the True and False branches of the tensor into a single Output
    at a certain lod level indiacted by :math:`level`.

    Args:
        in_true(tuple|list|None): The True branch to be merged.
        in_false(tuple|list|None): The False branch to be merged.
        x(tuple|list|None): The input tensor that contains complete
                            lod information needed to construct the output.
        mask(list): A bool column vector which masks the input.
        level(int): The specific lod level to rank.

    Returns:
        Variable: The merged output tensor.

    Examples:
        .. code-block:: python

          x = layers.data(
                      name='x', shape=[1], dtype='float32', stop_gradient=False)
          y = layers.data(
                name='y', shape=[1], dtype='bool', stop_gradient=False)

          level = 0

          out_true, out_false = layers.split_lod_tensor(
                input=x, mask=y, level=level)
          out = layers.merge_lod_tensor(
                in_true=out_true, in_false=out_false, mask=y, x=x, level=level)
    """
138
    helper = LayerHelper('merge_lod_tensor', **locals())
F
fengjiayi 已提交
139
    out = helper.create_tmp_variable(dtype=in_true.dtype)
140 141 142 143 144 145 146 147 148 149 150
    helper.append_op(
        type='merge_lod_tensor',
        inputs={'X': x,
                'Mask': mask,
                'InTrue': in_true,
                'InFalse': in_false},
        outputs={'Out': out},
        attrs={'level': level})
    return out


Y
Yan Chunwei 已提交
151 152 153 154 155 156 157
def Print(input,
          first_n=-1,
          message=None,
          summarize=-1,
          print_tensor_name=True,
          print_tensor_type=True,
          print_tensor_shape=True,
Y
yangyaming 已提交
158 159
          print_tensor_lod=True,
          print_phase='both'):
Y
Yan Chunwei 已提交
160 161 162 163 164 165 166 167 168 169
    '''
    **Print operator**

    This creates a print op that will print when a tensor is accessed.

    Wraps the tensor passed in so that whenever that a tensor is accessed,
    the message `message` is printed, along with the current value of the
    tensor `t`.

    Args:
Y
yangyaming 已提交
170 171 172 173 174 175 176 177 178
        input (Variable): A Tensor to print.
        summarize (int): Print this number of elements in the tensor, will print
                all if left is negative.
        message (str): A string message to print as a prefix.
        first_n (int): Only log `first_n` number of times.
        print_tensor_name (bool): Print the tensor name.
        print_tensor_type (bool): Print the tensor type.
        print_tensor_shape (bool): Print the tensor shape.
        print_tensor_lod (bool): Print the tensor lod.
179
        print_phase (str): Which phase to displace, including 'forward',
Y
yangyaming 已提交
180 181
                'backward' and 'both'. If set to 'backward' or 'both', will
                print the gradients of input tensor.
Y
Yan Chunwei 已提交
182 183

    Returns:
Y
yangyaming 已提交
184
        Variable: Output tensor, same data with input tensor.
Y
Yan Chunwei 已提交
185 186 187 188 189 190 191 192 193

    Examples:
        .. code-block:: python

        value = some_layer(...)
        Print(value, summarize=10,
              message="The content of some_layer: ")
    '''
    helper = LayerHelper('print', **locals())
Y
yangyaming 已提交
194
    out = helper.create_tmp_variable(dtype=helper.input_dtype())
Y
Yan Chunwei 已提交
195 196
    helper.append_op(
        type='print',
Y
yangyaming 已提交
197
        inputs={'In': input},
Y
Yan Chunwei 已提交
198 199 200 201 202 203 204 205
        attrs={
            'first_n': first_n,
            'summarize': summarize,
            'message': message or "",
            'print_tensor_name': print_tensor_name,
            'print_tensor_type': print_tensor_type,
            'print_tensor_shape': print_tensor_shape,
            'print_tensor_lod': print_tensor_lod,
Y
yangyaming 已提交
206 207 208
            'print_phase': print_phase.upper()
        },
        outputs={'Out': out})
Y
Yan Chunwei 已提交
209 210 211
    return out


Y
Yu Yang 已提交
212 213
class BlockGuard(object):
    """
214 215 216 217
    BlockGuard class.

    BlockGuard class is used to create a sub-block in a program by
    using the Python `with` keyword.
Y
Yu Yang 已提交
218 219
    """

220 221
    def __init__(self, main_program):
        if not isinstance(main_program, Program):
Y
Yu Yang 已提交
222
            raise TypeError("BlockGuard takes a program")
223
        self.main_program = main_program
Y
Yu Yang 已提交
224 225

    def __enter__(self):
226
        self.main_program.create_block()
Y
Yu Yang 已提交
227 228

    def __exit__(self, exc_type, exc_val, exc_tb):
229
        self.main_program.rollback()
Y
Yu Yang 已提交
230 231 232 233 234
        if exc_type is not None:
            return False  # re-raise exception
        return True


Y
Yang Yang 已提交
235
class ParallelDo(object):
236
    """
Y
Yang Yang 已提交
237
    ParallelDo class.
238

Y
Yang Yang 已提交
239 240 241
    ParallelDo class is used to create a ParallelDo.
    """

Y
Yang Yang 已提交
242
    def __init__(self, places, use_nccl=False, name=None):
Y
Yang Yang 已提交
243 244 245 246 247
        self.helper = LayerHelper("parallel_do", name=name)
        self.inputs = []
        self.places = places
        self.outputs = []
        self.status = StaticRNN.BEFORE_RNN_BLOCK
Y
Yang Yang 已提交
248
        self.use_nccl = use_nccl
Y
Yang Yang 已提交
249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271

    def do(self):
        return BlockGuardWithCompletion(self)

    def parent_block(self):
        prog = self.helper.main_program
        parent_idx = prog.current_block().parent_idx
        assert parent_idx >= 0
        parent_block = prog.block(parent_idx)
        return parent_block

    def __call__(self, *args, **kwargs):
        if self.status != StaticRNN.AFTER_RNN_BLOCK:
            raise ValueError("RNN output can only be retrieved after rnn block")
        if len(self.outputs) == 0:
            raise ValueError("RNN has no output")
        elif len(self.outputs) == 1:
            return self.outputs[0]
        else:
            return self.outputs

    def read_input(self, var):
        self.inputs.append(var)
Y
Yang Yang 已提交
272
        return var
Y
Yang Yang 已提交
273 274 275 276 277 278 279 280 281 282

    def write_output(self, var):
        self.outputs.append(var)

    def get_parameters(self):
        main_program = self.helper.main_program
        current_block = main_program.current_block()
        parent_block = self.parent_block()

        local_inputs = set()
Y
Yang Yang(Tony) 已提交
283
        params = list()
Y
Yang Yang 已提交
284 285 286 287 288 289 290 291
        for var in self.inputs:
            local_inputs.add(var.name)

        for op in current_block.ops:
            for iname in op.input_names:
                for in_var_name in op.input(iname):
                    if in_var_name not in local_inputs:
                        params.append(in_var_name)
Y
Yang Yang(Tony) 已提交
292 293 294 295 296

            for oname in op.output_names:
                for out_var_name in op.output(oname):
                    local_inputs.add(out_var_name)

Y
Yang Yang 已提交
297
        params = list(set(params))
Y
Yang Yang 已提交
298 299 300 301 302 303 304 305 306 307 308

        return [parent_block.var(name) for name in params]

    def complete_op(self):
        main_program = self.helper.main_program
        current_block = main_program.current_block()
        parent_block = self.parent_block()

        step_scope = parent_block.create_var(
            type=core.VarDesc.VarType.STEP_SCOPES)

Y
Yang Yang 已提交
309 310 311 312 313 314 315 316 317 318
        self.outputs = [
            parent_block.create_var(
                name=o.name,
                shape=o.shape,
                dtype=o.dtype,
                lod_level=o.lod_level,
                persistable=o.persistable,
                stop_gradient=o.stop_gradient) for o in self.outputs
        ]

Y
Yang Yang 已提交
319
        inputs = [parent_block.var(i.name) for i in self.inputs]
Y
Yang Yang 已提交
320
        outputs = [parent_block.var(o.name) for o in self.outputs]
Y
Yang Yang 已提交
321 322 323 324 325 326 327 328

        parent_block.append_op(
            type='parallel_do',
            inputs={
                'inputs': inputs,
                'parameters': self.get_parameters(),
                'places': self.places
            },
Y
Yang Yang 已提交
329
            outputs={'outputs': outputs,
Y
Yang Yang 已提交
330
                     'parallel_scopes': [step_scope]},
Y
Yang Yang 已提交
331 332
            attrs={'sub_block': current_block,
                   'use_nccl': self.use_nccl})
Y
Yang Yang 已提交
333 334 335 336 337 338 339


class BlockGuardWithCompletion(BlockGuard):
    """
    BlockGuardWithCompletion class.

    BlockGuardWithCompletion class is used to create an op with a block in a program.
340 341
    """

Y
Yu Yang 已提交
342
    def __init__(self, rnn):
Y
Yang Yang 已提交
343 344 345 346
        if not (isinstance(rnn, StaticRNN) or isinstance(rnn, ParallelDo)):
            raise TypeError(
                "BlockGuardWithCompletion takes a StaticRNN or ParallelDo")
        super(BlockGuardWithCompletion, self).__init__(rnn.helper.main_program)
Y
Yu Yang 已提交
347 348 349 350
        self.rnn = rnn

    def __enter__(self):
        self.rnn.status = StaticRNN.IN_RNN_BLOCK
Y
Yang Yang 已提交
351
        return super(BlockGuardWithCompletion, self).__enter__()
Y
Yu Yang 已提交
352 353

    def __exit__(self, exc_type, exc_val, exc_tb):
Y
Yu Yang 已提交
354 355
        if exc_type is not None:
            return False
Y
Yu Yang 已提交
356
        self.rnn.status = StaticRNN.AFTER_RNN_BLOCK
Y
Yang Yang 已提交
357 358 359
        self.rnn.complete_op()
        return super(BlockGuardWithCompletion, self).__exit__(exc_type, exc_val,
                                                              exc_tb)
Y
Yu Yang 已提交
360 361 362 363


class StaticRNNMemoryLink(object):
    """
364 365 366 367 368 369 370 371 372 373 374 375
    StaticRNNMemoryLink class.

    Args:
        init: the initial variable for Memory
        init: Variable
        pre_mem: the memory variable in previous time step
        pre_mem: Variable
        mem: the memory variable in current time step
        mem: Variable

    StaticRNNMemoryLink class is used to create a link between two
    memory cells of a StaticRNN.
Y
Yu Yang 已提交
376 377 378 379 380 381 382 383 384
    """

    def __init__(self, init, pre_mem, mem=None):
        self.init = init
        self.pre_mem = pre_mem
        self.mem = mem


class StaticRNN(object):
385 386 387 388 389 390
    """
    StaticRNN class.

    StaticRNN class is used to create a StaticRNN. The RNN will have its
    own parameters like inputs, outputs, memories, status and length.
    """
Y
Yu Yang 已提交
391 392 393 394
    BEFORE_RNN_BLOCK = 0
    IN_RNN_BLOCK = 1
    AFTER_RNN_BLOCK = 2

395 396
    def __init__(self, name=None):
        self.helper = LayerHelper("static_rnn", name=name)
Y
Yu Yang 已提交
397 398 399 400 401 402 403 404
        self.memories = {}  # memory map, from pre_mem.name --> MemoryLink
        self.inputs = []  # input variable list in current block
        self.outputs = []  # output variable list in parent block
        self.status = StaticRNN.BEFORE_RNN_BLOCK  # status flag.
        # sequence length, since it is a static RNN, sequence length are fixed.
        self.seq_len = None

    def step(self):
Y
Yang Yang 已提交
405
        return BlockGuardWithCompletion(self)
Y
Yu Yang 已提交
406 407 408 409 410

    def _assert_in_rnn_block_(self, method):
        if self.status != StaticRNN.IN_RNN_BLOCK:
            raise ValueError("You must invoke {0} in rnn block".format(method))

411 412 413 414 415 416 417
    def memory(self,
               init=None,
               shape=None,
               batch_ref=None,
               init_value=0.0,
               init_batch_dim_idx=0,
               ref_batch_dim_idx=1):
418 419 420 421 422 423 424 425 426
        """
        Args:
            init: boot memory, if not set, a shape, batch_ref must be provided
            shape: shape of the boot memory
            batch_ref: batch size reference variable
            init_value: the init value of boot memory
            init_batch_dim_idx: the index of batch size in init's dimension
            ref_batch_dim_idx: the index of batch size in batch_ref's dimension
        """
Y
Yu Yang 已提交
427 428
        self._assert_in_rnn_block_('memory')
        if init is None:
429
            if shape is None or batch_ref is None:
Y
Yu Yang 已提交
430
                raise ValueError(
431
                    "if init is None, memory at least need shape and batch_ref")
Y
Yu Yang 已提交
432
            parent_block = self.parent_block()
Y
Yu Yang 已提交
433 434
            var_name = unique_name.generate("@".join(
                [self.helper.name, "memory_boot"]))
Y
Yu Yang 已提交
435
            boot_var = parent_block.create_var(
436 437
                name=var_name,
                shape=shape,
F
fengjiayi 已提交
438
                dtype=batch_ref.dtype,
439
                persistable=False)
Y
Yu Yang 已提交
440 441

            parent_block.append_op(
442 443
                type="fill_constant_batch_size_like",
                inputs={'Input': [batch_ref]},
Y
Yu Yang 已提交
444 445 446
                outputs={'Out': [boot_var]},
                attrs={
                    'value': init_value,
447
                    'shape': boot_var.shape,
F
fengjiayi 已提交
448
                    'dtype': boot_var.dtype,
449 450
                    'input_dim_idx': ref_batch_dim_idx,
                    'output_dim_idx': init_batch_dim_idx
Y
Yu Yang 已提交
451 452 453 454 455
                })

            return self.memory(init=boot_var)
        else:
            pre_mem = self.helper.create_variable(
Y
Yu Yang 已提交
456
                name=unique_name.generate("@".join([self.helper.name, "mem"])),
F
fengjiayi 已提交
457
                dtype=init.dtype,
Y
Yu Yang 已提交
458 459 460 461 462 463 464 465 466 467
                shape=init.shape)
            self.memories[pre_mem.name] = StaticRNNMemoryLink(
                init=init, pre_mem=pre_mem)
            return pre_mem

    def step_input(self, x):
        self._assert_in_rnn_block_('step_input')
        if not isinstance(x, Variable):
            raise TypeError("step input takes a Variable")
        if self.seq_len is None:
Y
Yu Yang 已提交
468 469
            self.seq_len = x.shape[0]
        elif self.seq_len != x.shape[0]:
Y
Yu Yang 已提交
470 471 472
            raise ValueError("Static RNN only take fix seq_len input")

        ipt = self.helper.create_variable(
F
fengjiayi 已提交
473
            name=x.name, dtype=x.dtype, shape=list(x.shape[1:]), type=x.type)
Y
Yu Yang 已提交
474 475 476 477 478 479 480 481
        self.inputs.append(ipt)
        return ipt

    def step_output(self, o):
        self._assert_in_rnn_block_('step_output')
        if not isinstance(o, Variable):
            raise TypeError("step output takes a Variable")

F
fengjiayi 已提交
482
        tmp_o = self.helper.create_tmp_variable(dtype=o.dtype)
Y
Yu Yang 已提交
483 484 485 486
        self.helper.append_op(
            type='rnn_memory_helper',
            inputs={'X': [o]},
            outputs={'Out': tmp_o},
F
fengjiayi 已提交
487
            attrs={'dtype': o.dtype})
Y
Yu Yang 已提交
488

Y
Yu Yang 已提交
489
        out_var = self.parent_block().create_var(
Y
Yu Yang 已提交
490 491
            name=tmp_o.name,
            shape=[self.seq_len] + list(tmp_o.shape),
F
fengjiayi 已提交
492
            dtype=tmp_o.dtype)
Y
Yu Yang 已提交
493 494 495 496 497 498 499 500 501 502 503 504 505

        self.outputs.append(out_var)

    def output(self, *outputs):
        for each in outputs:
            self.step_output(each)

    def update_memory(self, mem, var):
        if not isinstance(mem, Variable) or not isinstance(var, Variable):
            raise TypeError("update memory should take variables")
        self.memories[mem.name].mem = var

    def parent_block(self):
506
        prog = self.helper.main_program
Y
Yu Yang 已提交
507 508 509 510 511 512 513 514 515 516 517 518 519 520 521
        parent_idx = prog.current_block().parent_idx
        assert parent_idx >= 0
        parent_block = prog.block(parent_idx)
        return parent_block

    def __call__(self, *args, **kwargs):
        if self.status != StaticRNN.AFTER_RNN_BLOCK:
            raise ValueError("RNN output can only be retrieved after rnn block")
        if len(self.outputs) == 0:
            raise ValueError("RNN has no output")
        elif len(self.outputs) == 1:
            return self.outputs[0]
        else:
            return self.outputs

Y
Yang Yang 已提交
522
    def complete_op(self):
523 524
        main_program = self.helper.main_program
        rnn_block = main_program.current_block()
Y
Yu Yang 已提交
525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563
        parent_block = self.parent_block()

        local_inputs = set()

        for op in rnn_block.ops:
            assert isinstance(op, Operator)
            for oname in op.output_names:
                for out_var_name in op.output(oname):
                    local_inputs.add(out_var_name)

        for var in self.inputs:
            local_inputs.add(var.name)
        for m in self.memories:
            local_inputs.add(m)

        params = list()
        for op in rnn_block.ops:
            assert isinstance(op, Operator)
            for iname in op.input_names:
                for in_var_name in op.input(iname):
                    if in_var_name not in local_inputs:
                        params.append(in_var_name)

        parameters = [parent_block.var(name) for name in params]

        step_scope = parent_block.create_var(
            type=core.VarDesc.VarType.STEP_SCOPES)

        inlinks = [parent_block.var(i.name) for i in self.inputs]
        outlinks = self.outputs

        boot_memories = []
        pre_memories = []
        memories = []
        for _, mem in self.memories.iteritems():
            boot_memories.append(mem.init)
            pre_memories.append(mem.pre_mem.name)
            mem_var = rnn_block.var(mem.mem.name)
            assert isinstance(mem_var, Variable)
F
fengjiayi 已提交
564
            new_mem = self.helper.create_tmp_variable(dtype=mem_var.dtype)
Y
Yu Yang 已提交
565 566 567 568 569

            rnn_block.append_op(
                type='rnn_memory_helper',
                inputs={'X': [mem_var]},
                outputs={'Out': [new_mem]},
F
fengjiayi 已提交
570
                attrs={'dtype': mem_var.dtype})
Y
Yu Yang 已提交
571 572 573 574 575 576 577 578 579 580 581 582 583 584 585

            memories.append(new_mem.name)

        parent_block.append_op(
            type='recurrent',
            inputs={
                'inputs': inlinks,
                'initial_states': boot_memories,
                'parameters': parameters
            },
            outputs={'outputs': outlinks,
                     'step_scopes': [step_scope]},
            attrs={
                'ex_states': pre_memories,
                'states': memories,
586
                'sub_block': rnn_block
Y
Yu Yang 已提交
587
            })
Y
Yu Yang 已提交
588 589


Y
Yang Yang(Tony) 已提交
590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609
class WhileGuard(BlockGuard):
    def __init__(self, while_op):
        if not isinstance(while_op, While):
            raise TypeError("WhileGuard takes a while op")
        super(WhileGuard, self).__init__(while_op.helper.main_program)
        self.while_op = while_op

    def __enter__(self):
        self.while_op.status = While.IN_WHILE_BLOCK
        return super(WhileGuard, self).__enter__()

    def __exit__(self, exc_type, exc_val, exc_tb):
        if exc_type is not None:
            return False
        self.while_op.status = While.AFTER_WHILE_BLOCK
        self.while_op.complete()
        return super(WhileGuard, self).__exit__(exc_type, exc_val, exc_tb)


class While(object):
X
Xin Pan 已提交
610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663
    """
    while loop control flow.

    Args:
        cond (Variable): condition used to compare.
        name (str): The name of this layer.

    Examples:
          .. code-block:: python

            # The value these d0, d1 and d2 can be fed from python.
            d0 = fluid.layers.data(
                "d0", shape=[10], append_batch_size=False, dtype='float32')
            d1 = fluid.layers.data(
                "d1", shape=[10], append_batch_size=False, dtype='float32')
            d2 = fluid.layers.data(
                "d2", shape=[10], append_batch_size=False, dtype='float32')
            i = fluid.layers.zeros(shape=[1], dtype='int64')
            i.stop_gradient = True
            init = fluid.layers.zeros(shape=[10], dtype='float32')
            # Initialize mem_array from init
            mem_array = fluid.layers.array_write(x=init, i=i)
            # Initialize data_array from d0
            data_array = fluid.layers.array_write(x=d0, i=i)
            # Set a value to data_array using d1[i].
            i = fluid.layers.increment(i)
            fluid.layers.array_write(d1, i, array=data_array)
            # Set a value to data_array using d2[i].
            i = fluid.layers.increment(i)
            fluid.layers.array_write(d2, i, array=data_array)
            # Create a idx to start the while loop.
            i = fluid.layers.zeros(shape=[1], dtype='int64')
            i.stop_gradient = True

            array_len = fluid.layers.fill_constant(
                shape=[1], dtype='int64', value=3)
            array_len.stop_gradient = True
            # Create the while loop condition.
            cond = fluid.layers.less_than(x=i, y=array_len)

            # Within the loop, perform sums.
            while_op = fluid.layers.While(cond=cond)
            with while_op.block():
                d = fluid.layers.array_read(array=data_array, i=i)
                prev = fluid.layers.array_read(array=mem_array, i=i)
                result = fluid.layers.sums(input=[d, prev])

                i = fluid.layers.increment(x=i, in_place=True)
                fluid.layers.array_write(result, i=i, array=mem_array)
                fluid.layers.less_than(x=i, y=array_len, cond=cond)

            sum_result = fluid.layers.array_read(array=mem_array, i=i)
    """

Y
Yang Yang(Tony) 已提交
664 665 666 667
    BEFORE_WHILE_BLOCK = 0
    IN_WHILE_BLOCK = 1
    AFTER_WHILE_BLOCK = 2

668 669
    def __init__(self, cond, name=None):
        self.helper = LayerHelper("while", name=name)
Y
Yang Yang(Tony) 已提交
670 671 672 673
        self.status = While.BEFORE_WHILE_BLOCK
        if not isinstance(cond, Variable):
            raise TypeError("condition should be a variable")
        assert isinstance(cond, Variable)
674
        if cond.dtype != core.VarDesc.VarType.BOOL:
Y
Yang Yang(Tony) 已提交
675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711
            raise TypeError("condition should be a bool variable")
        if reduce(lambda a, b: a * b, cond.shape, 1) != 1:
            raise TypeError("condition should be a bool scalar")
        self.cond_var = cond

    def block(self):
        return WhileGuard(self)

    def complete(self):
        main_program = self.helper.main_program
        while_block = main_program.current_block()
        parent_block = main_program.block(main_program.current_block()
                                          .parent_idx)

        inner_outputs = {self.cond_var.name}
        x_name_list = set()
        for op in while_block.ops:
            for iname in op.input_names:
                for in_var_name in op.input(iname):
                    if in_var_name not in inner_outputs:
                        x_name_list.add(in_var_name)

            for oname in op.output_names:
                for out_var_name in op.output(oname):
                    inner_outputs.add(out_var_name)

        out_vars = []
        for inner_out_name in inner_outputs:
            if inner_out_name in parent_block.vars:
                out_vars.append(parent_block.var(inner_out_name))

        step_scope = parent_block.create_var(
            type=core.VarDesc.VarType.STEP_SCOPES)

        parent_block.append_op(
            type='while',
            inputs={
Y
Yu Yang 已提交
712 713
                'X':
                [parent_block.var_recursive(x_name) for x_name in x_name_list],
Y
Yang Yang(Tony) 已提交
714 715 716 717
                'Condition': [self.cond_var]
            },
            outputs={'Out': out_vars,
                     'StepScopes': [step_scope]},
718
            attrs={'sub_block': while_block})
Y
Yang Yang(Tony) 已提交
719 720


721
def lod_rank_table(x, level=0):
Y
yangyaming 已提交
722 723 724
    """LoD Rank Table Operator. Given an input variable **x** and a level number
    of LoD, this layer creates a LodRankTable object. A LoDRankTable object
    contains a list of bi-element tuples. Each tuple consists of an index and
725
    a length, both of which are int type. Refering to specified level of LoD,
Y
yangyaming 已提交
726 727 728
    the index is the sequence index number and the length representes the
    sequence length. Please note that the list is ranked in descending order by
    the length. The following is an example:
Y
yangyaming 已提交
729 730 731 732

        .. code-block:: text

            x is a LoDTensor:
Y
yangyaming 已提交
733
                x.lod = [[0,                2, 3],
Y
yangyaming 已提交
734 735 736
                         [0,             5, 6, 7]]
                x.data = [a, b, c, d, e, f, g]

Y
yangyaming 已提交
737 738 739
            1. set level to 0:
                Create lod rank table:
                    lod_rank_table_obj = lod_rank_table(x, level=0)
Y
yangyaming 已提交
740

Y
yangyaming 已提交
741 742 743 744 745 746 747 748 749
                Get:
                    lod_rank_table_obj.items() = [(0, 2), (1, 1)]

            2. set level to 1:
                Create lod rank table:
                    lod_rank_table_obj = lod_rank_table(x, level=1)

                Get:
                    lod_rank_table_obj.items() = [(0, 5), (1, 1), (2, 1)]
Y
yangyaming 已提交
750 751 752 753

    Args:
        x (Variable): Input variable, a LoDTensor based which to create the lod
            rank table.
Y
yangyaming 已提交
754 755
        level (int): Specify the LoD level, on which to create the lod rank
            table.
Y
yangyaming 已提交
756 757 758 759 760 761 762 763

    Returns:
        Variable: The created LoDRankTable object.

    Examples:
        .. code-block:: python

            x = fluid.layers.data(name='x', shape=[10],
764
                                  dtype='float32', lod_level=1)
Y
yangyaming 已提交
765
            out = layers.lod_rank_table(x=x, level=0)
766
    """
Y
Yu Yang 已提交
767 768 769
    helper = LayerHelper("lod_rank_table", **locals())
    table = helper.create_variable(
        type=core.VarDesc.VarType.LOD_RANK_TABLE,
Y
Yu Yang 已提交
770
        name=unique_name.generate("lod_rank_table"))
Y
Yu Yang 已提交
771 772 773 774 775 776
    helper.append_op(
        type='lod_rank_table',
        inputs={'X': x},
        outputs={'Out': table},
        attrs={'level': level})
    return table
Y
Yu Yang 已提交
777 778


Y
yuyang18 已提交
779
@templatedoc()
780
def max_sequence_len(rank_table):
Y
yuyang18 已提交
781 782 783 784 785 786 787 788
    """
    ${comment}

    >>> import paddle.fluid as fluid
    >>> x = fluid.layers.data(name='x', shape=[10], dtype='float32',
    >>>                       lod_level=1)
    >>> rank_table = layers.lod_rank_table(x=x, level=0)
    >>> max_seq_len = layers.max_sequence_len(rank_table)
Y
yangyaming 已提交
789 790

    Args:
Y
yuyang18 已提交
791
        rank_table(${rank_table_type}): ${rank_table_comment}.
Y
yangyaming 已提交
792 793

    Returns:
Y
yuyang18 已提交
794
        ${out_comment}.
F
fengjiayi 已提交
795 796 797 798 799 800 801 802 803 804
    """
    helper = LayerHelper("max_seqence_len", **locals())
    res = helper.create_tmp_variable(dtype="int64")
    helper.append_op(
        type="max_sequence_len",
        inputs={"RankTable": rank_table},
        outputs={"Out": res})
    return res


805
def lod_tensor_to_array(x, table):
806
    """ Convert a LOD_TENSOR to an LOD_TENSOR_ARRAY.
807 808

    Args:
809
        x (Variable|list): The LOD tensor to be converted to a LOD tensor array.
810 811 812 813 814 815 816 817 818 819 820 821 822 823
        table (ParamAttr|list): The variable that stores the level of lod
                                which is ordered by sequence length in
                                descending order.

    Returns:
        Variable: The variable of type array that has been converted from a
                  tensor.

    Examples:
        .. code-block:: python

          x = fluid.layers.data(name='x', shape=[10])
          table = fluid.layers.lod_rank_table(x, level=0)
          array = fluid.layers.lod_tensor_to_array(x, table)
824
    """
825 826
    helper = LayerHelper("lod_tensor_to_array", **locals())
    array = helper.create_variable(
Y
Yu Yang 已提交
827
        name=unique_name.generate("lod_tensor_to_array"),
828
        type=core.VarDesc.VarType.LOD_TENSOR_ARRAY,
F
fengjiayi 已提交
829
        dtype=x.dtype)
830 831 832 833 834 835 836 837
    helper.append_op(
        type='lod_tensor_to_array',
        inputs={'X': x,
                'RankTable': table},
        outputs={'Out': array})
    return array


838
def array_to_lod_tensor(x, table):
839
    """Convert a LoD_Tensor_Aarry to an LoDTensor.
840 841

    Args:
842
        x (Variable|list): The lod tensor array to be converted to a tensor.
843 844 845 846 847 848 849 850 851 852 853 854 855 856 857
        table (ParamAttr|list): The variable that stores the level of lod
                                which is ordered by sequence length in
                                descending order.

    Returns:
        Variable: The variable of type tensor that has been converted
                  from an array.

    Examples:
        .. code-block:: python

          x = fluid.layers.data(name='x', shape=[10])
          table = fluid.layers.lod_rank_table(x, level=0)
          array = fluid.layers.lod_tensor_to_array(x, table)
          lod_tensor = fluid.layers.array_to_lod_tensor(array, table)
858
    """
859
    helper = LayerHelper("array_to_lod_tensor", **locals())
F
fengjiayi 已提交
860
    tmp = helper.create_tmp_variable(dtype=x.dtype)
861 862 863 864 865 866 867 868
    helper.append_op(
        type="array_to_lod_tensor",
        inputs={'X': x,
                'RankTable': table},
        outputs={'Out': tmp})
    return tmp


869
def increment(x, value=1.0, in_place=True):
870 871
    """
    This function performs an operation that increments each value in the
872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888
    input :math:`x` by an amount: :math:`value` as mentioned in the input
    parameter. This operation is performed in-place by default.

    Args:
        x (Variable|list): The tensor that has the input values.
        value (float): The amount by which the values should be incremented.
        in_place (bool): If the increment should be performed in-place.

    Returns:
        Variable: The tensor variable storing the transformation of
                  element-wise increment of each value in the input.

    Examples:
        .. code-block:: python

          data = fluid.layers.data(name='data', shape=[32, 32], dtype='float32')
          data = fluid.layers.increment(x=data, value=3.0, in_place=True)
889
    """
Y
Yu Yang 已提交
890
    helper = LayerHelper("increment", **locals())
Y
Yang Yang(Tony) 已提交
891
    if not in_place:
F
fengjiayi 已提交
892
        out = helper.create_tmp_variable(dtype=x.dtype)
Y
Yang Yang(Tony) 已提交
893 894
    else:
        out = x
Y
Yu Yang 已提交
895 896 897
    helper.append_op(
        type='increment',
        inputs={'X': [x]},
Y
Yang Yu 已提交
898
        outputs={'Out': [out]},
899
        attrs={'step': float(value)})
Y
Yang Yu 已提交
900
    return out
Y
Yu Yang 已提交
901 902


903
def array_write(x, i, array=None):
904 905 906 907 908
    """
    This function writes the given input variable to the specified position
    indicating by the arrary index to an output LOD_TENSOR_ARRAY. If the
    output LOD_TENSOR_ARRAY is not given(None), a new one will be created and
    returned.
909 910 911

    Args:
        x (Variable|list): The input tensor from which the data will be read.
912 913 914 915 916 917 918 919
        i (Variable|list): The index of the output LOD_TENSOR_ARRAY, pointing to
                           the position to which the input tensor will be
                           written.
        array (Variable|list): The output LOD_TENSOR_ARRAY to which the input
                               tensor will be written. If this parameter is
                               NONE, a new LOD_TENSOR_ARRAY will be created and
                               returned.

920
    Returns:
921
        Variable: The output LOD_TENSOR_ARRAY where the input tensor is written.
922 923 924 925 926 927 928

    Examples:
        .. code-block::python

          tmp = fluid.layers.zeros(shape=[10], dtype='int32')
          i = fluid.layers.fill_constant(shape=[1], dtype='int64', value=10)
          arr = layers.array_write(tmp, i=i)
929
    """
Y
Yu Yang 已提交
930 931 932 933 934
    helper = LayerHelper('array_write', **locals())
    if array is None:
        array = helper.create_variable(
            name="{0}.out".format(helper.name),
            type=core.VarDesc.VarType.LOD_TENSOR_ARRAY,
F
fengjiayi 已提交
935
            dtype=x.dtype)
Y
Yu Yang 已提交
936 937 938 939 940 941 942 943
    helper.append_op(
        type='write_to_array',
        inputs={'X': [x],
                'I': [i]},
        outputs={'Out': [array]})
    return array


944
def create_array(dtype):
945 946 947 948 949 950 951 952 953 954 955 956 957 958 959
    """This function creates an array of type :math:`LOD_TENSOR_ARRAY` using the
    LayerHelper.

    Args:
        dtype (int|float): The data type of the elements in the array.

    Returns:
        Variable: The tensor variable storing the elements of data type.

    Examples:
        .. code-block:: python

          data = fluid.layers.create_array(dtype='float32')

    """
Y
Yang Yang(Tony) 已提交
960 961 962 963 964 965 966
    helper = LayerHelper("array", **locals())
    return helper.create_variable(
        name="{0}.out".format(helper.name),
        type=core.VarDesc.VarType.LOD_TENSOR_ARRAY,
        dtype=dtype)


Y
yuyang18 已提交
967 968
@templatedoc()
def less_than(x, y, force_cpu=None, cond=None, **ignored):
969
    """
Y
yuyang18 已提交
970
    ${comment}
971

Y
yuyang18 已提交
972 973
    >>> import paddle.fluid as fluid
    >>> less = fluid.layers.less_than(x=label, y=limit)
974 975

    Args:
Y
yuyang18 已提交
976 977 978
        x(${x_type}): ${x_comment}.
        y(${y_type}): ${y_comment}.
        force_cpu(${force_cpu_type}): ${force_cpu_comment}.
979 980 981
        cond(Variable|None): Optional output variable to store the result of *less_than*

    Returns:
Y
yuyang18 已提交
982
        ${out_comment}.
983
    """
Y
Yang Yang(Tony) 已提交
984 985 986 987 988
    helper = LayerHelper("less_than", **locals())
    if cond is None:
        cond = helper.create_tmp_variable(dtype='bool')
        cond.stop_gradient = True

Y
yuyang18 已提交
989 990 991 992 993 994
    attrs = dict()
    if force_cpu is not None:
        attrs['force_cpu'] = force_cpu
    elif force_init_on_cpu():
        attrs['force_cpu'] = force_init_on_cpu()

Y
Yang Yang(Tony) 已提交
995
    helper.append_op(
J
JiayiFeng 已提交
996 997 998 999
        type='less_than',
        inputs={'X': [x],
                'Y': [y]},
        outputs={'Out': [cond]},
Y
yuyang18 已提交
1000
        attrs=attrs)
Y
Yang Yang(Tony) 已提交
1001 1002 1003
    return cond


1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033
def equal(x, y, cond=None, **ignored):
    """
    **equal**

    This layer returns the truth value of :math:`x == y` elementwise.

    Args:
        x(Variable): First operand of *equal*
        y(Variable): Second operand of *equal*
        cond(Variable|None): Optional output variable to store the result of *equal*

    Returns:
        Variable: The tensor variable storing the output of *equal*.

    Examples:
        .. code-block:: python

          less = fluid.layers.equal(x=label, y=limit)
    """
    helper = LayerHelper("equal", **locals())
    if cond is None:
        cond = helper.create_tmp_variable(dtype='bool')
        cond.stop_gradient = True

    helper.append_op(
        type='equal', inputs={'X': [x],
                              'Y': [y]}, outputs={'Out': [cond]})
    return cond


1034
def array_read(array, i):
K
kavyasrinet 已提交
1035
    """This function performs the operation to read the data in as an
1036
    LOD_TENSOR_ARRAY.
K
kavyasrinet 已提交
1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047
    Args:
        array (Variable|list): The input tensor that will be written to an array.
        i (Variable|list): The subscript index in tensor array, that points the
                           place where data will be written to.
    Returns:
        Variable: The tensor type variable that has the data written to it.
    Examples:
        .. code-block::python
          tmp = fluid.layers.zeros(shape=[10], dtype='int32')
          i = fluid.layers.fill_constant(shape=[1], dtype='int64', value=10)
          arr = layers.array_read(tmp, i=i)
1048
    """
Y
Yu Yang 已提交
1049 1050 1051 1052 1053
    helper = LayerHelper('array_read', **locals())
    if not isinstance(
            array,
            Variable) or array.type != core.VarDesc.VarType.LOD_TENSOR_ARRAY:
        raise TypeError("array should be tensor array vairable")
F
fengjiayi 已提交
1054
    out = helper.create_tmp_variable(dtype=array.dtype)
Y
Yu Yang 已提交
1055 1056 1057 1058 1059 1060
    helper.append_op(
        type='read_from_array',
        inputs={'X': [array],
                'I': [i]},
        outputs={'Out': [out]})
    return out
Y
Yang Yu 已提交
1061 1062


1063
def shrink_memory(x, i, table):
1064
    """
Y
yuyang18 已提交
1065
    This function creates an operator to shrink rnn memory using the RankTable
1066
    as mentioned in the input parameter.
Y
yuyang18 已提交
1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086

    NOTE: This API is very low-level API. It is used by DynamicRNN only.

    Since the Dynamic RNN uses no-padding way to implement RNN. The sequence
    will be sorted by order, and the length of valid memory will be shrink after
    each time step.

    Args:
        x(Variable): The memory object in the previous time step.
        i(Variable): The step count variable. A int scalar as LoDTensor.
        table(Variable): The RNNRankTable object.

    Returns:
        the memory variable after shrink.

    Examples:

        Since this API is very low level API. The example is not provided.
        Please reference the implementation of class DynamicRNN for detail
        usage.
1087
    """
Y
Yang Yu 已提交
1088
    helper = LayerHelper('shrink_memory', **locals())
F
fengjiayi 已提交
1089
    out = helper.create_tmp_variable(dtype=x.dtype)
Y
Yang Yu 已提交
1090
    helper.append_op(
Y
Yang Yu 已提交
1091
        type='shrink_rnn_memory',
Y
Yang Yu 已提交
1092 1093 1094 1095 1096 1097
        inputs={'X': [x],
                'I': [i],
                'RankTable': [table]},
        outputs={'Out': [out]},
        attrs={})
    return out
Y
Yang Yu 已提交
1098 1099


1100
def array_length(array):
K
kavyasrinet 已提交
1101
    """This function performs the operation to find the length of the input
1102
    LOD_TENSOR_ARRAY.
K
kavyasrinet 已提交
1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117

    Args:
        array (LOD_TENSOR_ARRAY): The input array that will be used
                                  to compute the length.

    Returns:
        Variable: The length of the input LoDTensorArray.

    Examples:
        .. code-block::python

          tmp = fluid.layers.zeros(shape=[10], dtype='int32')
          i = fluid.layers.fill_constant(shape=[1], dtype='int64', value=10)
          arr = fluid.layers.array_write(tmp, i=i)
          arr_len = fluid.layers.array_length(arr)
1118
    """
Y
Yang Yu 已提交
1119 1120 1121 1122 1123 1124
    helper = LayerHelper('array_length', **locals())
    tmp = helper.create_tmp_variable(dtype='int64')
    tmp.stop_gradient = True
    helper.append_op(
        type='lod_array_length', inputs={'X': [array]}, outputs={'Out': [tmp]})
    return tmp
Y
Yu Yang 已提交
1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143


class ConditionalBlockGuard(BlockGuard):
    def __init__(self, block):
        if not isinstance(block, ConditionalBlock):
            raise TypeError("block should be conditional block")
        super(ConditionalBlockGuard, self).__init__(block.helper.main_program)
        self.block = block

    def __enter__(self):
        return super(ConditionalBlockGuard, self).__enter__()

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.block.complete()
        return super(ConditionalBlockGuard, self).__exit__(exc_type, exc_val,
                                                           exc_tb)


class ConditionalBlock(object):
1144
    def __init__(self, inputs, is_scalar_condition=False, name=None):
Y
Yu Yang 已提交
1145 1146 1147 1148
        for each_input in inputs:
            if not isinstance(each_input, Variable):
                raise TypeError("Each input should be variable")
        self.inputs = inputs
1149
        self.is_scalar_condition = is_scalar_condition
1150
        self.helper = LayerHelper('conditional_block', name=name)
Y
Yu Yang 已提交
1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174

    def block(self):
        return ConditionalBlockGuard(self)

    def complete(self):
        inside_block = self.helper.main_program.current_block()
        parent_block = self.helper.main_program.block(inside_block.parent_idx)

        intermediate = set()
        params = set()

        for each_op in inside_block.ops:
            assert isinstance(each_op, Operator)
            for iname in each_op.input_names:
                for in_var_name in each_op.input(iname):
                    if in_var_name not in intermediate:
                        params.add(in_var_name)

            for oname in each_op.output_names:
                for out_var_name in each_op.output(oname):
                    intermediate.add(out_var_name)
        input_set = set([ipt.name for ipt in self.inputs])

        param_list = [
Q
Qingsheng Li 已提交
1175
            parent_block.var_recursive(each_name) for each_name in params
Y
Yu Yang 已提交
1176 1177 1178 1179 1180
            if each_name not in input_set
        ]

        out_list = [
            parent_block.var(var_name) for var_name in parent_block.vars
X
xuwei06 已提交
1181
            if var_name in intermediate
Y
Yu Yang 已提交
1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193
        ]

        step_scope = parent_block.create_var(
            type=core.VarDesc.VarType.STEP_SCOPES)
        parent_block.append_op(
            type='conditional_block',
            inputs={
                'X': self.inputs,
                'Params': param_list,
            },
            outputs={'Out': out_list,
                     'Scope': [step_scope]},
1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253
            attrs={
                'sub_block': inside_block,
                'is_scalar_condition': self.is_scalar_condition
            })


class Switch(object):
    def __init__(self, name=None):
        self.helper = LayerHelper('switch', name=name)
        self.inside_scope = False
        self.pre_not_conditions = []

    def case(self, condition):
        """create a new block for this condition
        """
        if not self.inside_scope:
            raise ValueError("case should be called inside with")

        if len(self.pre_not_conditions) == 0:
            cond_block = ConditionalBlock([condition], is_scalar_condition=True)
            not_cond = logical_not(x=condition)
            self.pre_not_conditions.append(not_cond)
        else:
            pre_cond_num = len(self.pre_not_conditions)
            pre_not_cond = self.pre_not_conditions[pre_cond_num - 1]
            new_not_cond = logical_and(
                x=pre_not_cond, y=logical_not(x=condition))
            self.pre_not_conditions.append(new_not_cond)
            cond_block = ConditionalBlock(
                [logical_and(
                    x=pre_not_cond, y=condition)],
                is_scalar_condition=True)

        return ConditionalBlockGuard(cond_block)

    def default(self):
        """create a default case for this switch
        """
        pre_cond_num = len(self.pre_not_conditions)
        if pre_cond_num == 0:
            raise ValueError("there should be at least one condition")
        cond_block = ConditionalBlock(
            [self.pre_not_conditions[pre_cond_num - 1]],
            is_scalar_condition=True)
        return ConditionalBlockGuard(cond_block)

    def __enter__(self):
        """
        set flag that now is inside switch.block {}
        :return:
        """
        self.inside_scope = True
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.inside_scope = False
        if exc_type is not None:
            return False  # re-raise exception

        return True
Y
Yu Yang 已提交
1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289


class IfElseBlockGuard(object):
    def __init__(self, is_true, ifelse):
        if not isinstance(ifelse, IfElse):
            raise TypeError("ifelse must be an instance of IfElse class")

        if ifelse.status != IfElse.OUT_IF_ELSE_BLOCKS:
            raise ValueError("You cannot invoke IfElse.block() inside a block")

        self.is_true = is_true
        self.ie = ifelse
        if is_true:
            self.cond_block = ifelse.conditional_true_block
        else:
            self.cond_block = ifelse.conditional_false_block

        if not isinstance(self.cond_block, ConditionalBlock):
            raise TypeError("Unexpected situation")

        self.cond_block = self.cond_block.block()

    def __enter__(self):
        self.ie.status = IfElse.IN_IF_ELSE_TRUE_BLOCKS if self.is_true else IfElse.IN_IF_ELSE_FALSE_BLOCKS
        self.cond_block.__enter__()

    def __exit__(self, exc_type, exc_val, exc_tb):
        if not self.cond_block.__exit__(exc_type, exc_val, exc_tb):
            # re-raise inside exception
            return False
        if len(self.ie.output_table[1 if self.is_true else 0]) == 0:
            raise ValueError("Must set output inside block")
        self.ie.status = IfElse.OUT_IF_ELSE_BLOCKS


class IfElse(object):
X
Xin Pan 已提交
1290 1291 1292 1293 1294 1295 1296 1297 1298
    """
    if-else control flow.

    Args:
        cond (Variable): condition used to compare.
        name (str, default None): The name of this layer.

    Examples:
          .. code-block:: python
X
Xin Pan 已提交
1299

X
improve  
Xin Pan 已提交
1300
            limit = fluid.layers.fill_constant_batch_size_like(
X
Xin Pan 已提交
1301
                input=label, dtype='int64', shape=[1], value=5.0)
X
improve  
Xin Pan 已提交
1302 1303
            cond = fluid.layers.less_than(x=label, y=limit)
            ie = fluid.layers.IfElse(cond)
X
Xin Pan 已提交
1304 1305
            with ie.true_block():
                true_image = ie.input(image)
X
improve  
Xin Pan 已提交
1306 1307
                hidden = fluid.layers.fc(input=true_image, size=100, act='tanh')
                prob = fluid.layers.fc(input=hidden, size=10, act='softmax')
X
Xin Pan 已提交
1308 1309 1310 1311
                ie.output(prob)

            with ie.false_block():
                false_image = ie.input(image)
X
improve  
Xin Pan 已提交
1312 1313 1314
                hidden = fluid.layers.fc(
                    input=false_image, size=200, act='tanh')
                prob = fluid.layers.fc(input=hidden, size=10, act='softmax')
X
Xin Pan 已提交
1315 1316 1317
                ie.output(prob)
            prob = ie()
    """
Y
Yu Yang 已提交
1318 1319 1320 1321
    OUT_IF_ELSE_BLOCKS = 0
    IN_IF_ELSE_TRUE_BLOCKS = 1
    IN_IF_ELSE_FALSE_BLOCKS = 2

1322
    def __init__(self, cond, name=None):
Y
Yu Yang 已提交
1323 1324
        if not isinstance(cond, Variable):
            raise TypeError("cond must be a Variable")
1325
        self.helper = LayerHelper('ifelse', name=name)
Y
Yu Yang 已提交
1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338
        self.cond = cond
        self.input_table = {}
        self.status = IfElse.OUT_IF_ELSE_BLOCKS
        self.conditional_true_block = ConditionalBlock(inputs=[self.cond])
        self.conditional_false_block = ConditionalBlock(inputs=[self.cond])
        self.output_table = ([], [])  # (true_outs, false_outs)

    def input(self, x):
        if self.status == IfElse.OUT_IF_ELSE_BLOCKS:
            raise ValueError("input must in true/false blocks")
        if id(x) not in self.input_table:
            parent_block = self.parent_block()
            out_true = parent_block.create_var(
Y
Yu Yang 已提交
1339
                name=unique_name.generate('ifelse_input' + self.helper.name),
F
fengjiayi 已提交
1340
                dtype=x.dtype)
Y
Yu Yang 已提交
1341 1342

            out_false = parent_block.create_var(
Y
Yu Yang 已提交
1343
                name=unique_name.generate('ifelse_input' + self.helper.name),
F
fengjiayi 已提交
1344
                dtype=x.dtype)
Y
Yu Yang 已提交
1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384
            parent_block.append_op(
                type='split_lod_tensor',
                inputs={
                    'X': x,
                    'Mask': self.cond,
                },
                outputs={'OutTrue': out_true,
                         'OutFalse': out_false},
                attrs={'level': 0})
            self.input_table[id(x)] = (out_true, out_false)
        else:
            out_true, out_false = self.input_table[id(x)]

        if self.status == IfElse.IN_IF_ELSE_TRUE_BLOCKS:
            return out_true
        else:
            return out_false

    def parent_block(self):
        current_block = self.helper.main_program.current_block()
        return self.helper.main_program.block(current_block.parent_idx)

    def true_block(self):
        return IfElseBlockGuard(True, self)

    def false_block(self):
        return IfElseBlockGuard(False, self)

    def output(self, *outs):
        if self.status == self.OUT_IF_ELSE_BLOCKS:
            raise ValueError("output can only be invoked in the sub-block")

        out_table = self.output_table[1 if self.status ==
                                      self.IN_IF_ELSE_TRUE_BLOCKS else 0]
        parent_block = self.parent_block()
        for each_out in outs:
            if not isinstance(each_out, Variable):
                raise TypeError("Each output should be a variable")
            # create outside tensor
            outside_out = parent_block.create_var(
Y
Yu Yang 已提交
1385 1386
                name=unique_name.generate("_".join(
                    [self.helper.name, 'output'])),
F
fengjiayi 已提交
1387
                dtype=each_out.dtype)
Y
Yu Yang 已提交
1388 1389 1390
            out_table.append(outside_out)

            # assign local var to outside
1391
            assign(input=each_out, output=outside_out)
Y
Yu Yang 已提交
1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414

    def __call__(self):
        if self.status != self.OUT_IF_ELSE_BLOCKS:
            raise ValueError("IfElse::__call__ must be out of sub-block")
        false_len, true_len = map(len, self.output_table)
        if false_len == 0 and true_len == 0:
            raise ValueError("Must invoke true_block/false_block before "
                             "__call__")
        elif false_len != true_len and false_len != 0 and true_len != 0:
            raise ValueError("The output side must be same")
        elif false_len == 0 or true_len == 0:
            return self.output_table[0 if false_len != 0 else 1]

        # else none of false_len/true_len is zero
        # merge together
        rlist = []
        for false_var, true_var in zip(*self.output_table):
            rlist.append(
                merge_lod_tensor(
                    in_true=true_var,
                    in_false=false_var,
                    mask=self.cond,
                    x=self.cond,
1415
                    level=0))
Y
Yu Yang 已提交
1416
        return rlist
1417 1418 1419


class DynamicRNN(object):
Y
yuyang18 已提交
1420
    """
Y
yuyang18 已提交
1421 1422 1423
    The dynamic RNN can process a batch of sequence data. The length of each
    sample sequence can be different. This API automatically process them in
    batch.
Y
yuyang18 已提交
1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451

    The input lod must be set. Please reference `lod_tensor`

    >>> import paddle.fluid as fluid
    >>> data = fluid.layers.data(name='sentence', dtype='int64', lod_level=1)
    >>> embedding = fluid.layers.embedding(input=data, size=[65535, 32],
    >>>                                    is_sparse=True)
    >>>
    >>> drnn = fluid.layers.DynamicRNN()
    >>> with drnn.block():
    >>>     word = drnn.step_input(embedding)
    >>>     prev = drnn.memory(shape=[200])
    >>>     hidden = fluid.layers.fc(input=[word, prev], size=200, act='relu')
    >>>     drnn.update_memory(prev, hidden)  # set prev to hidden
    >>>     drnn.output(hidden)
    >>>
    >>> # last is the last time step of rnn. It is the encoding result.
    >>> last = fluid.layers.sequence_last_step(drnn())

    The dynamic RNN will unfold sequence into timesteps. Users need to define
    how to process each time step during the :code:`with` block.

    The `memory` is used staging data cross time step. The initial value of
    memory can be zero or another variable.

    The dynamic RNN can mark multiple variables as its output. Use `drnn()` to
    get the output sequence.
    """
1452 1453 1454 1455
    BEFORE_RNN = 0
    IN_RNN = 1
    AFTER_RNN = 2

1456 1457
    def __init__(self, name=None):
        self.helper = LayerHelper('dynamic_rnn', name=name)
1458 1459 1460 1461
        self.status = DynamicRNN.BEFORE_RNN
        self.lod_rank_table = None
        self.max_seq_len = None
        self.step_idx = None
1462 1463
        self.zero_idx = fill_constant(
            shape=[1], value=0, dtype='int64', force_cpu=True)
1464 1465 1466 1467 1468 1469 1470 1471 1472 1473
        self.mem_dict = dict()
        self.output_array = []
        self.outputs = []
        self.cond = self.helper.create_tmp_variable(dtype='bool')
        self.cond.stop_gradient = False
        self.while_op = While(self.cond)
        self.input_array = []
        self.mem_link = []

    def step_input(self, x):
Y
yuyang18 已提交
1474 1475 1476 1477 1478 1479 1480 1481 1482
        """
        Mark a sequence as a dynamic RNN input.
        Args:
            x(Variable): The input sequence.

        Returns:
            The current timestep in the input sequence.

        """
1483 1484 1485
        self._assert_in_rnn_block_("step_input")
        if not isinstance(x, Variable):
            raise TypeError(
1486
                "step_input() can only take a Variable as its input.")
1487 1488 1489
        parent_block = self._parent_block_()
        if self.lod_rank_table is None:
            self.lod_rank_table = parent_block.create_var(
Y
Yu Yang 已提交
1490
                name=unique_name.generate('lod_rank_table'),
1491 1492 1493 1494 1495 1496 1497
                type=core.VarDesc.VarType.LOD_RANK_TABLE)
            self.lod_rank_table.stop_gradient = True
            parent_block.append_op(
                type='lod_rank_table',
                inputs={"X": x},
                outputs={"Out": self.lod_rank_table})
            self.max_seq_len = parent_block.create_var(
Y
Yu Yang 已提交
1498 1499
                name=unique_name.generate('dynamic_rnn_max_seq_len'),
                dtype='int64')
1500 1501 1502 1503 1504 1505 1506 1507 1508 1509
            self.max_seq_len.stop_gradient = False
            parent_block.append_op(
                type='max_sequence_len',
                inputs={'RankTable': self.lod_rank_table},
                outputs={"Out": self.max_seq_len})
            self.cond.stop_gradient = True
            parent_block.append_op(
                type='less_than',
                inputs={'X': self.step_idx,
                        'Y': self.max_seq_len},
J
JiayiFeng 已提交
1510 1511
                outputs={'Out': self.cond},
                attrs={'force_cpu': True})
1512 1513

        input_array = parent_block.create_var(
Y
Yu Yang 已提交
1514
            name=unique_name.generate('dynamic_rnn_input_array'),
1515 1516 1517 1518 1519 1520 1521 1522
            type=core.VarDesc.VarType.LOD_TENSOR_ARRAY,
            dtype=x.dtype)
        self.input_array.append((input_array, x.dtype))
        parent_block.append_op(
            type='lod_tensor_to_array',
            inputs={'X': x,
                    'RankTable': self.lod_rank_table},
            outputs={'Out': input_array})
1523
        return array_read(array=input_array, i=self.step_idx)
1524

Y
yangyaming 已提交
1525
    def static_input(self, x):
Y
yuyang18 已提交
1526 1527 1528 1529 1530 1531 1532 1533 1534
        """
        Mark a variable as a RNN input. The input will not be scattered into
        time steps.
        Args:
            x(Variable): The input variable.

        Returns:
            The input variable that can access in RNN.
        """
Y
yangyaming 已提交
1535 1536 1537 1538 1539 1540 1541 1542 1543
        self._assert_in_rnn_block_("static_input")
        if not isinstance(x, Variable):
            raise TypeError(
                "static_input() can only take a Variable as its input")
        if self.lod_rank_table is None:
            raise RuntimeError(
                "static_input() must be called after step_input().")
        parent_block = self._parent_block_()
        x_reordered = parent_block.create_var(
Y
Yu Yang 已提交
1544
            name=unique_name.generate("dynamic_rnn_static_input_reordered"),
Y
yangyaming 已提交
1545 1546 1547 1548 1549 1550 1551 1552 1553
            type=core.VarDesc.VarType.LOD_TENSOR,
            dtype=x.dtype)
        parent_block.append_op(
            type='reorder_lod_tensor_by_rank',
            inputs={'X': [x],
                    'RankTable': [self.lod_rank_table]},
            outputs={'Out': [x_reordered]})
        return shrink_memory(x_reordered, self.step_idx, self.lod_rank_table)

1554 1555
    @contextlib.contextmanager
    def block(self):
Y
yuyang18 已提交
1556 1557 1558 1559
        """
        The block for user to define operators in RNN. See the class docstring
        for more details.
        """
1560 1561
        if self.status != DynamicRNN.BEFORE_RNN:
            raise ValueError("rnn.block() can only be invoke once")
1562 1563
        self.step_idx = fill_constant(
            shape=[1], dtype='int64', value=0, force_cpu=True)
1564 1565 1566 1567
        self.step_idx.stop_gradient = False
        self.status = DynamicRNN.IN_RNN
        with self.while_op.block():
            yield
1568
            increment(x=self.step_idx, value=1.0, in_place=True)
1569 1570

            for new_mem, mem_array in self.mem_link:
1571 1572
                array_write(x=new_mem, i=self.step_idx, array=mem_array)

J
JiayiFeng 已提交
1573 1574 1575 1576 1577
            less_than(
                x=self.step_idx,
                y=self.max_seq_len,
                force_cpu=True,
                cond=self.cond)
1578 1579 1580 1581 1582

        self.status = DynamicRNN.AFTER_RNN
        for each_array in self.output_array:
            self.outputs.append(
                array_to_lod_tensor(
1583
                    x=each_array, table=self.lod_rank_table))
1584 1585

    def __call__(self, *args, **kwargs):
Y
yuyang18 已提交
1586 1587 1588
        """
        Get the output of RNN. This API should only be invoked after RNN.block()
        """
1589
        if self.status != DynamicRNN.AFTER_RNN:
1590 1591
            raise ValueError(("Output of the dynamic RNN can only be visited "
                              "outside the rnn block."))
1592 1593 1594 1595 1596
        if len(self.outputs) == 1:
            return self.outputs[0]
        else:
            return self.outputs

1597 1598 1599 1600 1601 1602
    def memory(self,
               init=None,
               shape=None,
               value=0.0,
               need_reorder=False,
               dtype='float32'):
Y
yuyang18 已提交
1603
        """
Y
yuyang18 已提交
1604
        Create a memory variable for dynamic rnn.
Y
yuyang18 已提交
1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666

        If the :code:`init` is not None, :code:`memory` will be initialized by
        this variable. The :code:`need_reorder` is used to reorder the memory as
        the input variable. It should be set to true when the initialized memory
        depends on the input sample.

        For example,

        >>> import paddle.fluid as fluid
        >>> sentence = fluid.layers.data(
        >>>                 name='sentence', dtype='float32', shape=[32])
        >>> boot_memory = fluid.layers.data(
        >>>                 name='boot', dtype='float32', shape=[10])
        >>>
        >>> drnn = fluid.layers.DynamicRNN()
        >>> with drnn.block():
        >>>     word = drnn.step_input(sentence)
        >>>     memory = drnn.memory(init=boot_memory, need_reorder=True)
        >>>     hidden = fluid.layers.fc(
        >>>                 input=[word, memory], size=10, act='tanh')
        >>>     drnn.update_memory(ex_mem=memory, new_mem=hidden)
        >>>     drnn.output(hidden)
        >>> rnn_output = drnn()


        Otherwise, if :code:`shape`, :code:`value`, :code:`dtype` are set, the
        :code:`memory` will be initialized by this :code:`value`.

        For example,

        >>> import paddle.fluid as fluid
        >>> sentence = fluid.layers.data(
        >>>                 name='sentence', dtype='float32', shape=[32])
        >>>
        >>> drnn = fluid.layers.DynamicRNN()
        >>> with drnn.block():
        >>>     word = drnn.step_input(sentence)
        >>>     memory = drnn.memory(shape=[10], dtype='float32', value=0)
        >>>     hidden = fluid.layers.fc(
        >>>             input=[word, memory], size=10, act='tanh')
        >>>     drnn.update_memory(ex_mem=memory, new_mem=hidden)
        >>>     drnn.output(hidden)
        >>> rnn_output = drnn()


        Args:
            init(Variable|None): The initialized variable.

            shape(list|tuple): The memory shape. NOTE the shape does not contain
            batch_size.

            value(float): the initalized value.

            need_reorder(bool): True if the initialized memory depends on the
            input sample.

            dtype(str|numpy.dtype): The data type of the initialized memory.

        Returns:
            the memory variable.

        """
1667 1668 1669 1670 1671 1672
        self._assert_in_rnn_block_('memory')
        if init is not None:
            if not isinstance(init, Variable):
                raise TypeError(
                    "The input arg `init` of memory() must be a Variable")
            parent_block = self._parent_block_()
1673 1674 1675 1676 1677 1678 1679 1680
            init_tensor = init
            if need_reorder == True:
                if self.lod_rank_table is None:
                    raise ValueError(
                        'If set need_reorder to True, make sure step_input be '
                        'invoked before '
                        'memory(init=init, need_reordered=True, ...).')
                init_reordered = parent_block.create_var(
Y
Yu Yang 已提交
1681
                    name=unique_name.generate('dynamic_rnn_mem_init_reordered'),
1682 1683 1684 1685 1686 1687 1688 1689 1690 1691
                    type=core.VarDesc.VarType.LOD_TENSOR,
                    dtype=init.dtype)
                parent_block.append_op(
                    type='reorder_lod_tensor_by_rank',
                    inputs={
                        'X': [init_tensor],
                        'RankTable': [self.lod_rank_table]
                    },
                    outputs={'Out': [init_reordered]})
                init_tensor = init_reordered
1692
            mem_array = parent_block.create_var(
Y
Yu Yang 已提交
1693
                name=unique_name.generate('dynamic_rnn_mem_array'),
1694 1695 1696 1697
                type=core.VarDesc.VarType.LOD_TENSOR_ARRAY,
                dtype=init.dtype)
            parent_block.append_op(
                type='write_to_array',
1698
                inputs={'X': init_tensor,
1699 1700
                        'I': self.zero_idx},
                outputs={'Out': mem_array})
1701
            retv = array_read(array=mem_array, i=self.step_idx)
1702
            retv = shrink_memory(
1703
                x=retv, i=self.step_idx, table=self.lod_rank_table)
1704 1705 1706 1707 1708 1709 1710 1711 1712
            self.mem_dict[retv.name] = mem_array
            return retv
        else:
            if len(self.input_array) == 0:
                raise ValueError(
                    "step_input should be invoked before memory(shape=..., value=...)"
                )
            parent_block = self._parent_block_()
            init = parent_block.create_var(
Y
Yu Yang 已提交
1713
                name=unique_name.generate('mem_init'), dtype=dtype)
1714
            arr, dtype = self.input_array[0]
Y
Yu Yang 已提交
1715 1716
            in0 = parent_block.create_var(
                name=unique_name.generate('in0'), dtype=dtype)
1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733
            parent_block.append_op(
                type='read_from_array',
                inputs={'X': [arr],
                        'I': [self.zero_idx]},
                outputs={'Out': [in0]})
            parent_block.append_op(
                type='fill_constant_batch_size_like',
                inputs={'Input': [in0]},
                outputs={'Out': [init]},
                attrs={
                    'shape': [-1] + shape,
                    'value': float(value),
                    'dtype': init.dtype
                })
            return self.memory(init=init)

    def update_memory(self, ex_mem, new_mem):
Y
yuyang18 已提交
1734 1735 1736 1737 1738 1739 1740 1741 1742 1743
        """
        Update the memory from ex_mem to new_mem. NOTE that the shape and data
        type of :code:`ex_mem` and :code:`new_mem` must be same.
        Args:
            ex_mem(Variable): the memory variable.
            new_mem(Variable): the plain variable generated in RNN block.

        Returns:
            None
        """
1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760
        self._assert_in_rnn_block_('update_memory')
        if not isinstance(ex_mem, Variable):
            raise TypeError("The input arg `ex_mem` of update_memory() must "
                            "be a Variable")
        if not isinstance(new_mem, Variable):
            raise TypeError("The input arg `new_mem` of update_memory() must "
                            "be a Variable")

        mem_array = self.mem_dict.get(ex_mem.name, None)
        if mem_array is None:
            raise ValueError("Please invoke memory before update_memory")
        if self.lod_rank_table is None:
            raise ValueError("Please invoke step_input before update_memory")

        self.mem_link.append((new_mem, mem_array))

    def output(self, *outputs):
Y
yuyang18 已提交
1761 1762 1763 1764 1765 1766 1767 1768 1769
        """
        mark the RNN output variables.

        Args:
            outputs: The output variables.

        Returns:
            None
        """
1770 1771 1772 1773
        self._assert_in_rnn_block_('output')
        parent_block = self._parent_block_()
        for each in outputs:
            outside_array = parent_block.create_var(
Y
Yu Yang 已提交
1774
                name=unique_name.generate("_".join(
1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792
                    [self.helper.name, "output_array", each.name])),
                type=core.VarDesc.VarType.LOD_TENSOR_ARRAY,
                dtype=each.dtype)
            array_write(x=each, i=self.step_idx, array=outside_array)
            self.output_array.append(outside_array)

    def _parent_block_(self):
        prog = self.helper.main_program
        parent_idx = prog.current_block().parent_idx
        assert parent_idx >= 0
        parent_block = prog.block(parent_idx)

        return parent_block

    def _assert_in_rnn_block_(self, method):
        if self.status != DynamicRNN.IN_RNN:
            raise ValueError("{0} can only be invoked inside rnn block.".format(
                method))
Y
Yang Yu 已提交
1793 1794


1795
@autodoc()
Y
Yang Yu 已提交
1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807
def reorder_lod_tensor_by_rank(x, rank_table):
    helper = LayerHelper('reorder_lod_tensor_by_rank', **locals())
    helper.is_instance('x', Variable)
    helper.is_instance('rank_table', Variable)

    out = helper.create_tmp_variable(dtype=x.dtype)
    helper.append_op(
        type='reorder_lod_tensor_by_rank',
        inputs={'X': [x],
                'RankTable': [rank_table]},
        outputs={'Out': [out]})
    return out
1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844


def is_empty(x, cond=None, **ignored):
    """
    **Is Empty**

    This layer returns the truth value of whether the variable is empty.

    Args:
        x(Variable): Operand of *is_empty*
        cond(Variable|None): Optional output variable to store the result
                             of *is_empty*

    Returns:
        Variable: The tensor variable storing the output of *is_empty*.

    Raises:
        TypeError: If input cond is not a variable, or cond's dtype is
                   not bool

    Examples:
        .. code-block:: python

          less = fluid.layers.is_empty(x=input)
    """
    helper = LayerHelper("is_empty", **locals())
    if cond is None:
        cond = helper.create_tmp_variable(dtype='bool')
        cond.stop_gradient = True
    elif not isinstance(cond, Variable):
        raise TypeError("cond takes a variable")
    elif cond.dtype != 'bool':
        raise TypeError("The data type of cond must be bool")

    helper.append_op(
        type='is_empty', inputs={'X': [x]}, outputs={'Out': [cond]})
    return cond