o Ne@sddlmZddlmZddlmZmZddlmZm Z m Z ddl m Z ddl mZmZmZmZmZmZmZdd lmZmZdd lmZmZmZdd lmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%dd l&Z&dd l'Z'dd l(Z(dd l)m*Z*m+Z+ddl,m-Z-m.Z.m/Z/m0Z0ddl m1Z2ddl3m4Z4ddl5m6Z6m7Z7gdZ8ddZ9ddZ:ddZ;ddZe ! " " " " " #dd$d%Z?dd&d'Z@Gd(d)d)eAZBGd*d+d+eBZCGd,d-d-eAZDGd.d/d/eAZEGd0d1d1eBZFd2d3ZGGd4d5d5eAZHeIeJe(jKfZLd6d7ZMdd9d:ZNd;d<ZOdd=d>ZPed?d@ZQdAdBZRdCdDZSddFdGZTddHdIZUddJdKZVeddLdMZWeddNdOZXeddPdQZYeddRdSZZddTdUZ[ddVdWZ\dXdYZ]dZd[Z^d\d]Z_Gd^d_d_eBZ`Gd`dadaeAZadbdcZbddddeZcdfdgZddhdiZedjdkZfdldmZgdndoZhddpdqZiGdrdsdseAZjGdtdudueAZkGdvdwdweAZlGdxdydyeAZmddzd{Zned|d}Zodd~dZpd S))print_function)signature_safe_contextmanager)autodoc templatedoc)assigncast fill_constant)core)ProgramVariableOperator_non_static_mode static_only_in_legacy_dygraphin_dygraph_mode) LayerHelper unique_name) logical_and logical_not logical_or) assert_same_structure map_structurehold_mutable_varscopy_mutable_varspadding_to_same_structure is_sequencepack_sequence_asflatten to_sequenceN)reducepartial) convert_dtypecheck_variable_and_dtype check_type check_dtype)compat)_infer_var_data_type_shape_)_C_ops _legacy_C_ops)WhileSwitch increment array_write create_array less_than less_equal greater_than greater_equalequal not_equal array_read array_lengthcondIfElse DynamicRNN StaticRNNreorder_lod_tensor_by_rankPrintAssertis_emptycase switch_case while_loopcCs^td it}t|dtdt|ddgdt|dttfd|jd||dd|id|S) a **select_output** This API takes in one input and multiple outputs and an integer mask. It selects the output specified by the mask and copy the input to selected output. It is useful in control flow. Args: input(Variable): The input variable outputs(tuple|list): The output variables mask(Variable): A tensor containing 1 integer number selecting which output to be copied with input Returns: Variable: The outputs variables select_outputinputmaskint32outputsXMaskOuttypeinputsrHN)rD)rlocalsr%r r$listtuple append_op)rErHrFhelperrUPD:\Projects\ConvertPro\env\Lib\site-packages\paddle/fluid/layers/control_flow.pyrDUsrDcCsBt|t|krtd|d||Sttdd||}|S)u* This function infer the output shape by following algorithm: 1. if the dims is different, raise a error. 2. compare axis one by one: if a == b: we set axis to a if a != b: we set axis to -1 for compatibility，non declarative mode, we just return second_shape. zDthe input shapes of select_input should have the same rank, but get z, cSs||kr|SdSNrUabrUrUrVz+_select_input_infer_shape..)lenwarningswarnrQmap)Z first_shapeZ second_shapeZ out_shaperUrUrV_select_input_infer_shapers rbcCstd it}t|dttfdt|ddgdt|dj|dj}|dj}|dj }|j |||d}|j d||dd |id |S) a{ **select_input** This API takes in multiple inputs and uses an integer mask to select one input to output. It is useful in control flow. Args: inputs(tuple|list): The input variables mask(Variable): A tensor containing 1 integer number selecting which input to output Returns: Variable: The selected input variable select_inputrOrFrGrrdtypeshaperNrIrLrMN)rc) rrPr%rQrRr$rbrfrerNcreate_variablerS)rOrFrTZ output_shapeZ output_dtype output_typeoutrUrUrVrcs  rcc sddlmddlm|\}}t|rt|r dSt|trDt|trDzt||WStyC}z td|d|d}~wwt|t r_t|t |r_||krV|S||g}net|t rit|tsst|t rt|tr||g}t d t |t |n;t|rt|tft st|rt|tft rfdd}||}}||g}n td t |t |zt||WSty}z td|d|d}~ww) Nr)to_static_variable UndefinedVarz/Exceptions throwed while doing select_input on z: zReturn results from different branches in cond are not same type: false_var returned by fasle_fn is '{}' and true_var of true_fn is '{}'cst|r|S|SN) isinstance)rZrlrjrUrVcreate_var_if_not_undefined_vars zGselect_input_with_buildin_type..create_var_if_not_undefined_varzUnsupported return type of true_fn and false_fn in cond: false_var returned by fasle_fn is '{}' and true_var of true_fn is '{}')Z:paddle.fluid.dygraph.dygraph_to_static.variable_trans_funcrj,paddle.fluid.dygraph.dygraph_to_static.utilsrlrnr rc Exception RuntimeErrorsupport_ret_buildin_typerNr_r`format TypeError)rOrFname false_vartrue_varerprUrorVselect_input_with_buildin_types        r{cCst|dttttdfdt|dttfdt|dtdtd it}|j|j d}|j|j d}|j d||d||d d|id ||fS) a 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. Mainly used in IfElse to split data into two parts. Args: input(Variable|tuple|list|None): The input tensor that contains complete lod information needed to construct the output. mask(Variable|list): A bool column vector which masks the input. level(int): The specific lod level to split. Returns: tuple(Variable, Variable): The true branch of tensor as per the mask applied to input. The false branch of tensor as per the mask applied to input. Examples: .. code-block:: python import paddle.fluid as fluid x = fluid.layers.data(name='x', shape=[1]) x.persistable = True y = fluid.layers.data(name='y', shape=[1]) y.persistable = True out_true, out_false = fluid.layers.split_lod_tensor( input=x, mask=y, level=level) rENzfluid.layers.split_lod_tensorrFlevelsplit_lod_tensorrerIZOutTrueZOutFalserNrOrHattrs)r}) r%r rQrRrNintrrP"create_variable_for_type_inferencererS)rErFr|rTout_true out_falserUrUrVr}s(" r}cCstd it}t|dttttdfdt|dttfdt|dttttdfdt|dttttdfd|j|jd}|j d||||d d |id |id |S)a **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 tensor as output at a certain lod level indicated by :math:`level`. Used in IfElse to merge the output if True block and False Block. Args: in_true(Variable|tuple|list|None): The True branch to be merged. in_false(Variable|tuple|list|None): The False branch to be merged. x(Variable|tuple|list|None): The input tensor that contains complete lod information needed to construct the output. mask(Variable|list): A bool column vector which masks the input. level(int): The specific lod level to merge. Returns: Variable: The merged output tensor. Examples: .. code-block:: python import paddle.fluid as fluid 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) merge_lod_tensorxNzfluid.layers.merge_lod_tensorrFin_truein_falser~)rJrKZInTrueZInFalserLr|r)r) rrPr%r rQrRrNrrerS)rrrrFr|rTrirUrUrVr1s8% rrXTbothc Cspt|dgddtd|jfit} | |j} | jdd|id| i|||p)d|||||| d d | S) a7 :api_attr: Static Graph **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: input (Variable): A Tensor to print. summarize (int): Number of elements in the tensor to be print. If it's value is -1, then all elements in the tensor will be print. message (str): A string message to print as a prefix. first_n (int): Only log `first_n` number of times. print_tensor_name (bool, optional): Print the tensor name. Default: True. print_tensor_type (bool, optional): Print the tensor type. Defaultt: True. print_tensor_shape (bool, optional): Print the tensor shape. Default: True. print_tensor_layout (bool, optional): Print the tensor layout. Default: True. print_tensor_lod (bool, optional): Print the tensor lod. Default: True. print_phase (str): Which phase to displace, including 'forward', 'backward' and 'both'. Default: 'both'. If set to 'backward', will only print the gradients of input tensor; If set to 'both', will both print the input tensor itself and the gradients of input tensor. Returns: Variable: Output tensor. NOTES: The input and output are two different variables, and in the following process, you should use the output variable but not the input, otherwise, the print layer doesn't have backward. Examples: .. code-block:: python import paddle paddle.enable_static() x = paddle.full(shape=[2, 3], fill_value=3, dtype='int64') out = paddle.static.Print(x, message="The content of input layer:") main_program = paddle.static.default_main_program() exe = paddle.static.Executor(place=paddle.CPUPlace()) res = exe.run(main_program, fetch_list=[out]) # Variable: fill_constant_1.tmp_0 # - message: The content of input layer: # - lod: {} # - place: CPUPlace # - shape: [2, 3] # - layout: NCHW # - dtype: long # - data: [3 3 3 3 3 3] rE)float32float64rGint64boolzfluid.layers.Printprint_printInrL) first_n summarizemessageprint_tensor_nameprint_tensor_typeprint_tensor_shapeprint_tensor_layoutprint_tensor_lod print_phaser)r$rrwrPrrerSupper) rErrrrrrrrrrToutputrUrUrVr>ts0F r>cCst|ddgdt|dtttdfdt|dtdt|dttdfd|r*|nd|j}t|fit }|j d ||durBgnt|d d|id }|S) a This API creates an op that asserts the given condition is true. If the condition is false, prints the tensors in data. ``summarize`` specifies the number of the elements in the tensors to print. Args: cond (Variable): The boolean condition tensor whose numel should be 1. data (list|tuple, optional): list or tuple of tensors to print when condition is not true. If it's ``None``, no tensor will be printed. The default value is ``None``. summarize (int, optional): Number of elements in the tensor to be printed. If its value is -1, then all elements in the tensor will be printed. The default value is 20. name (str, optional): The default value is ``None`` . Normally users don't have to set this parameter. For more information, please refer to :ref:`api_guide_Name` . Returns: Operator: the created operation. Raises: TypeError: If ``cond`` is not boolean Variable. TypeError: If ``data`` is not a list or tuple or ``None``. TypeError: If ``summarize`` is not int. TypeError: If ``name`` is not a string or ``None`` . fluid.core.EnforceNotMet: If the condition is False in running time. Examples: .. code-block:: python import paddle.fluid as fluid import paddle.fluid.layers as layers x = layers.fill_constant(shape=[2, 3], dtype='float32', value=2.0) condition = layers.reduce_max(x) < 1.0 # False layers.Assert(condition, [x], 10, "example_assert_layer") exe = fluid.Executor() try: exe.run(fluid.default_main_program()) # Print x and throws paddle.fluid.core.EnforceNotMet exception # Example printed message for x: # # Variable: fill_constant_0.tmp_0 # - lod: {} # - place: CPUPlace() # - shape: [2, 3] # - layout: NCHW # - dtype: float # - data: [2 2 2 2 2 2] except fluid.core.EnforceNotMet as e: print("Assert Exception Example") r9rzfluid.layers.AssertdataNrrwZassert_assert)CondZData)rNrOr) r$r%rQrRrNrstrrwrrPrS)r9rrrwZ layer_namerToprUrUrVr?s7r?c@s(eZdZdZddZddZddZdS) BlockGuardz BlockGuard class. BlockGuard class is used to create a sub-block in a program by using the Python `with` keyword. cCst|ts td||_dS)NzBlockGuard takes a program)rnr rv main_program)selfrrUrUrV__init__&s  zBlockGuard.__init__cCs|jdSrm)rZ _create_blockrrUrUrV __enter__+zBlockGuard.__enter__cCs|j|dur dSdSNFT)rZ _rollbackrexc_typeexc_valexc_tbrUrUrV__exit__.s zBlockGuard.__exit__N)__name__ __module__ __qualname____doc__rrrrUrUrUrVrs  rc8eZdZdZfddZfddZfddZZS)BlockGuardWithCompletionz BlockGuardWithCompletion class. BlockGuardWithCompletion class is used to create an op with a block in a program. c0t|ts tdtt||jj||_dS)Nz*BlockGuardWithCompletion takes a StaticRNN) rnr<rvsuperrrrTrrnn)rr __class__rUrVr<  z!BlockGuardWithCompletion.__init__ctj|j_tt|Srm)r< IN_RNN_BLOCKrstatusrrrrrrUrVrB z"BlockGuardWithCompletion.__enter__c4|durdStj|j_|jtt||||SNF)r<AFTER_RNN_BLOCKrr _complete_oprrrrrrUrVrFs   z!BlockGuardWithCompletion.__exit__rrrrrrr __classcell__rUrUrrVr5s   rc@seZdZdZdddZdS)StaticRNNMemoryLinka StaticRNNMemoryLink class. StaticRNNMemoryLink class is used to create a link between two memory cells of a StaticRNN. NOTE: This is a internal data structure of a very low-level API. Please use StaticRNN instead. Args: init(Variable): the initial variable for Memory. pre_mem(Variable): the memory variable in previous time step. mem(Variable): the memory variable in current time step. NcCs||_||_||_dSrm)initpre_memmem)rrrrrUrUrVras zStaticRNNMemoryLink.__init__rm)rrrrrrUrUrUrVrPsrc@seZdZdZdZdZdZdddZdd Zd d Z     dd dZ ddZ ddZ ddZ ddZddZddZddZdS)r<a :api_attr: Static Graph StaticRNN class. The StaticRNN can process a batch of sequence data. The first dimension of inputs represents sequence length, the length of each input sequence must be equal. StaticRNN will unfold sequence into time steps, user needs to define how to process each time step during the :code:`with` step. Args: name (str, optional): Please refer to :ref:`api_guide_Name`, Default None. Examples: .. code-block:: python import paddle.fluid as fluid import paddle.fluid.layers as layers vocab_size, hidden_size=10000, 200 x = fluid.data(name="x", shape=[None, 1, 1], dtype='int64') # create word sequence x_emb = layers.embedding( input=x, size=[vocab_size, hidden_size], dtype='float32', is_sparse=False) # transform batch size to dim 1 x_emb = layers.transpose(x_emb, perm=[1, 0, 2]) rnn = fluid.layers.StaticRNN() with rnn.step(): # mark created x_emb as input, each step process a word word = rnn.step_input(x_emb) # create prev memory parameter, batch size comes from word prev = rnn.memory(shape=[-1, hidden_size], batch_ref = word) hidden = fluid.layers.fc(input=[word, prev], size=hidden_size, act='relu') # use hidden to update prev rnn.update_memory(prev, hidden) # mark hidden as output rnn.step_output(hidden) # get StaticrNN final output result = rnn() rrrNcCsHt|dttdfdtd|d|_i|_g|_g|_tj |_ d|_ dS)Nrwzfluid.layers.StaticRNNZ static_rnnrw) r%rrNrrTmemoriesrOrHr<BEFORE_RNN_BLOCKrseq_lenrrwrUrUrVrs zStaticRNN.__init__cCt|S)z Define operators in each step. step is used in :code:`with` block, OP in :code:`with` block will be executed sequence_len times (sequence_len is the length of input) )rrrUrUrVstepszStaticRNN.stepcC|jtjkr td|dS)Nz You must invoke {0} in rnn block)rr<r ValueErrorrurmethodrUrUrV_assert_in_rnn_block_s zStaticRNN._assert_in_rnn_block_c Cs|dt|dttdfdt|dtttdfdt|dttdfd|durn|dus3|dur7td|}t d |j j d g}|j |||jd d } |jd d |gid| gi|| j| j||dd|j| dS|j jt d |j j dg|j|jd} t|| d|j| j <| S)a Create a memory variable for static rnn. If the :code:`init` is not None, :code:`memory` will be initialized by this Variable. If the :code:`init` is None, :code:`shape` and :code:`batch_ref` must be set, and this function will create a new variable with shape and batch_ref to initialize :code:`init` Variable. Args: init(Variable, optional): Tensor used to init memory. If it is not set, :code:`shape` and :code:`batch_ref` must be provided. Default: None. shape(list|tuple): When :code:`init` is None use this arg to initialize memory shape. NOTE the shape does not contain batch_size. Default: None. batch_ref(Variable, optional): When :code:`init` is None, memory's batch size will be set as batch_ref's ref_batch_dim_idx value. Default: None. init_value(float, optional): When :code:`init` is None, used to init memory's value. Default: 0.0. init_batch_dim_idx(int, optional): the batch_size axis of the :code:`init` Variable. Default: 0. ref_batch_dim_idx(int, optional): the batch_size axis of the :code:`batch_ref` Variable. Default: 1. Returns: Variable: The memory variable. Examples 1: .. code-block:: python import paddle.fluid as fluid import paddle.fluid.layers as layers vocab_size, hidden_size=10000, 200 x = fluid.data(name="x", shape=[None, 1, 1], dtype='int64') # create word sequence x_emb = layers.embedding( input=x, size=[vocab_size, hidden_size], dtype='float32', is_sparse=False) # transform batch size to dim 1 x_emb = layers.transpose(x_emb, perm=[1, 0, 2]) rnn = fluid.layers.StaticRNN() with rnn.step(): # mark created x_emb as input, each step process a word word = rnn.step_input(x_emb) # create prev memory parameter, batch size comes from word prev = rnn.memory(shape=[-1, hidden_size], batch_ref = word) hidden = fluid.layers.fc(input=[word, prev], size=hidden_size, act='relu') # use hidden to update prev rnn.update_memory(prev, hidden) Examples 2: .. code-block:: python import paddle.fluid as fluid import paddle.fluid.layers as layers vocab_size, hidden_size=10000, 200 x = fluid.data(name="x", shape=[None, 1, 1], dtype='int64') # create word sequence x_emb = layers.embedding( input=x, size=[vocab_size, hidden_size], dtype='float32', is_sparse=False) # transform batch size to dim 1 x_emb = layers.transpose(x_emb, perm=[1, 0, 2]) boot_memory = fluid.layers.data(name='boot', shape=[hidden_size], dtype='float32', lod_level=1) rnn = fluid.layers.StaticRNN() with rnn.step(): # mark created x_emb as input, each step process a word word = rnn.step_input(x_emb) # init memory prev = rnn.memory(init=boot_memory) hidden = fluid.layers.fc(input=[word, prev], size=hidden_size, act='relu') # update hidden with prev rnn.update_memory(prev, hidden) memoryrNzfluid.layers.StaticRNN.memoryrf batch_refz9if init is None, memory at least need shape and batch_ref@Z memory_bootF)rwrfreZ persistablefill_constant_batch_size_likeInputrL)valuerfreZ input_dim_idxZoutput_dim_idxrrr)rwrerf)rr)rr%r rNrQrRr _parent_blockrgenerate_with_ignorable_keyjoinrTrw create_varrerSrfrrgrr) rrrfrZ init_valueZinit_batch_dim_idxZref_batch_dim_idx parent_blockvar_nameZboot_varrrUrUrVrsr V    zStaticRNN.memorycCs|dt|dtd|jdur|jd|_n|jddkr+|j|jdkr+td|jj|j|j t |jdd|j d }|j ||S) a Mark a sequence as a StaticRNN input. Args: x(Variable): The input sequence, the shape of x should be [seq_len, ...]. Returns: Variable: The current time step data in the input sequence. Examples: .. code-block:: python import paddle.fluid as fluid import paddle.fluid.layers as layers vocab_size, hidden_size=10000, 200 x = fluid.data(name="x", shape=[None, 1, 1], dtype='int64') # create word sequence x_emb = layers.embedding( input=x, size=[vocab_size, hidden_size], dtype='float32', is_sparse=False) # transform batch size to dim 1 x_emb = layers.transpose(x_emb, perm=[1, 0, 2]) rnn = fluid.layers.StaticRNN() with rnn.step(): # mark created x_emb as input, each step process a word word = rnn.step_input(x_emb) # create prev memory parameter, batch size comes from word prev = rnn.memory(shape=[-1, hidden_size], batch_ref = word) hidden = fluid.layers.fc(input=[word, prev], size=hidden_size, act='relu') # use hidden to update prev rnn.update_memory(prev, hidden) step_inputrz!fluid.layers.StaticRNN.step_inputNrrXz&Static RNN only take fix seq_len inputr)rwrerfrN)rr%r rrfrrTrgrwrerQrNrOappend)rrZiptrUrUrVrCs '  zStaticRNN.step_inputcCs|dt|dtd|jj|jd}|jjdd|gid|id|jid |j|j |j gt |j |jd }|j |d S) a Mark a sequence as a StaticRNN output. Args: o(Variable): The output sequence. Returns: None. Examples: .. code-block:: python import paddle.fluid as fluid import paddle.fluid.layers as layers vocab_size, hidden_size=10000, 200 x = fluid.data(name="x", shape=[None, 1, 1], dtype='int64') # create word sequence x_emb = layers.embedding( input=x, size=[vocab_size, hidden_size], dtype='float32', is_sparse=False) # transform batch size to dim 1 x_emb = layers.transpose(x_emb, perm=[1, 0, 2]) rnn = fluid.layers.StaticRNN() with rnn.step(): # mark created x_emb as input, each step process a word word = rnn.step_input(x_emb) # create prev memory parameter, batch size comes from word prev = rnn.memory(shape=[-1, hidden_size], batch_ref = word) hidden = fluid.layers.fc(input=[word, prev], size=hidden_size, act='relu') # use hidden to update prev rnn.update_memory(prev, hidden) rnn.step_output(hidden) result = rnn() step_outputoz"fluid.layers.StaticRNN.step_outputr~rnn_memory_helperrJrLrer)rwrfreN)rr%r rTrrerSrrrwrrQrfrHr)rrZtmp_oZout_varrUrUrVrws )zStaticRNN.step_outputcGs|D]}||qdS)a Mark the StaticRNN output variables. Args: outputs: The output Tensor, can mark multiple variables as output Returns: None Examples: .. code-block:: python import paddle.fluid as fluid import paddle.fluid.layers as layers vocab_size, hidden_size=10000, 200 x = fluid.data(name="x", shape=[None, 1, 1], dtype='int64') # create word sequence x_emb = layers.embedding( input=x, size=[vocab_size, hidden_size], dtype='float32', is_sparse=False) # transform batch size to dim 1 x_emb = layers.transpose(x_emb, perm=[1, 0, 2]) rnn = fluid.layers.StaticRNN() with rnn.step(): # mark created x_emb as input, each step process a word word = rnn.step_input(x_emb) # create prev memory parameter, batch size comes from word prev = rnn.memory(shape=[-1, hidden_size], batch_ref = word) hidden = fluid.layers.fc(input=[word, prev], size=hidden_size, act='relu') # use hidden to update prev rnn.update_memory(prev, hidden) # mark each step's hidden and word as output rnn.output(hidden, word) result = rnn() N)r)rrHeachrUrUrVrs) zStaticRNN.outputcCs.t|dtdt|dtd||j|j_dS)aP Update the memory from :code:`mem` to :code:`var`. Args: mem(Variable): the memory variable. var(Variable): the plain variable generated in RNN block, used to update memory. var and mem should have same dims and data type. Returns: None rz$fluid.layers.StaticRNN.update_memoryvarN)r%r rrwr)rrrrUrUrV update_memorys zStaticRNN.update_memorycC,|jj}|j}|dksJ||}|SNrrTr current_block parent_idxblockrprogrrrUrUrVrs    zStaticRNN._parent_blockcOsH|jtjkr tdt|jdkrtdt|jdkr!|jdS|jS)Nz0RNN output can only be retrieved after rnn blockrzRNN has no outputr)rr<rrr^rHrargskwargsrUrUrV__call__s  zStaticRNN.__call__c s|jj}|}|t}|jD]}t|tsJ|jD]}| |D]}| |q%qq|j D]}| |j q2|j D]}| |q>t} |jD] }t|tsUJ|jD]} || D] } | |vrj| | q_qXqLfddt| D} jtjjjd} fdd|j D}|j}g}g}g}t|j D]L\}}||j||jj |jdusJd|jj ||jj }t|tsJ|jj|j d}|j!dd|gid |gid |j id ||j qj!d ||| d || gdt"|dk|||dd dS)Ncg|]}|qSrU)_find_var_recursive).0rwrrUrV  z*StaticRNN._complete_op..rNcsg|]}|jqSrU)rrwrirrUrVr&sz#%s should be updated in every step.r~rrJrLrerZ recurrent)rOZinitial_states parameters)rHZ step_scopesr)Z has_statesZ ex_statesZstates sub_block)#rTrrrsetopsrnr output_namesraddrOrwrrQ input_namesrErrr VarDescVarType STEP_SCOPESrHsix iteritemsrrrrr rrerSr^)rrZ rnn_blockZ local_inputsroname out_var_namermparamsiname in_var_namer step_scopeZinlinksZoutlinksZ boot_memoriesZ pre_memoriesr_rZmem_varnew_memrUrrVrs                zStaticRNN._complete_oprm)NNNrrr)rrrrrrrrrrrrrrrrrrrUrUrUrVr<gs..   4<, r<cs4eZdZfddZfddZfddZZS) WhileGuardcr)NzWhileGuard takes a while op) rnr,rvrrrrTrwhile_op)rrrrUrVrSrzWhileGuard.__init__crrm)r,IN_WHILE_BLOCKrrrrrrrrUrVrYrzWhileGuard.__enter__crr)r,AFTER_WHILE_BLOCKrr _completerrrrrrUrVr]s   zWhileGuard.__exit__)rrrrrrrrUrUrrVrRs  rcCsdd}|jD]8}t|tsJ|jD]}||D]}||vr*|||s*||qq|jD]}||D]} || q6q/qt} |j |j } |D]$}| |} d} | |r_||} | sp| rp| jtjjjkrp| |qL|| }||fS)a# Find inputs and outputs in current control flow block. :param current_block: Current control flow block. :param inner_inputs: Input var name of ops in current block. :param inner_outputs: Output var name of ops in current block. :return: inner_inputs, inner_outputs cSs:ddgi}|j|vr||j}|D] }||vrdSqdS)NZ shuffle_batchZshuffle_batch_seedTFr)rrZIGNORE_VAR_NAMESZ var_namesrwrUrUrVis_ignore_varsps   z3get_inputs_outputs_in_block..is_ignore_varsN)rrnrrrErrrrrrrrZhas_varrrNr r r LOD_TENSOR_ARRAY)rZ inner_inputs inner_outputsrTrrrrrrZremove_inner_inputsrparent_block_varZcurrent_block_varrUrUrVget_inputs_outputs_in_blockes@          r c@s6eZdZdZdZdZdZd ddZd d Zd d Z dS)r,a :api_attr: Static Graph while loop control flow. Repeat while body until cond is False. Note: A new OP :ref:`api_fluid_layers_while_loop` is highly recommended instead of ``While`` if the shape of parameter ``cond`` is [1]. OP :ref:`api_fluid_layers_while_loop` is easier to use and is called with less code but does the same thing as ``While`` . Notice: Local variables created in ``While`` are similar to that created in while of C++, and cannot be referenced externally. As a result, they cannot be obtained through ``fetch_list`` of ``Executor``. If you would like to access the variable out of ``while`` , PaddlePaddle provides ``assign`` API to assign local variables to external. Please refer to example code 2 or refer to `issue#22724 `_. Args: cond(Variable): A Tensor whose data type is bool controlling whether to continue looping. is_test(bool, optional): A flag indicating whether execution is in test phase. Default value is False. name(str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name` . Examples 1: .. code-block:: python import paddle.fluid as fluid import numpy as np i = fluid.layers.fill_constant(shape=[1], dtype='int64', value=0) # loop counter loop_len = fluid.layers.fill_constant(shape=[1],dtype='int64', value=10) # loop length cond = fluid.layers.less_than(x=i, y=loop_len) while_op = fluid.layers.While(cond=cond) with while_op.block(): i = fluid.layers.increment(x=i, value=1, in_place=True) fluid.layers.less_than(x=i, y=loop_len, cond=cond) exe = fluid.Executor(fluid.CPUPlace()) exe.run(fluid.default_startup_program()) res = exe.run(fluid.default_main_program(), feed={}, fetch_list=[i]) print(res) # [array([10])] Examples 2: .. code-block:: python import paddle.fluid as fluid import numpy as np i = fluid.layers.fill_constant(shape=[1], dtype='int64', value=0) loop_len = fluid.layers.fill_constant(shape=[1], dtype='int64', value=10) one = fluid.layers.fill_constant(shape=[1], dtype='float32', value=1) data = fluid.data(name='data', shape=[1], dtype='float32') sums = fluid.layers.fill_constant(shape=[1], dtype='float32', value=0) # Define the variable to be obtained ouside of While, which name should be different from the variable inside the While to be obtained cond = fluid.layers.less_than(x=i, y=loop_len) while_op = fluid.layers.While(cond=cond) with while_op.block(): sums_tensor = fluid.layers.elementwise_add(x=data, y=data) fluid.layers.assign(sums_tensor, sums) # Update the value of sums_tensor defined in While to the sums which defined outside of While through layers.assign i = fluid.layers.increment(x=i, value=1, in_place=True) data = fluid.layers.elementwise_add(x=data, y=one) fluid.layers.less_than(x=i, y=loop_len, cond=cond) feed_data = np.ones(1).astype('float32') exe = fluid.Executor(fluid.CPUPlace()) exe.run(fluid.default_startup_program()) res = exe.run(fluid.default_main_program(), feed={'data': feed_data}, fetch_list=sums) print(res[0]) # [2.] # Because the data in While does not update the value outside the While, the value of sums is [2.] after the loop rrrFNcCs`td|d|_tj|_t|ddgdtdd|jddkr(td t |j||_ ||_ dS) Nwhilerr9rzfluid.layers.WhilecS||SrmrUrYrUrUrVr\z While.__init__..rz8condition expected shape as [1], but given shape as {0}.) rrTr,BEFORE_WHILE_BLOCKrr$r!rfrvrurQcond_varis_test)rr9r&rwrUrUrVrs zWhile.__init__cCrrm)rrrUrUrVrz While.blockc s|jj}|}||j|jjh}t}t||||j\}}g}|D]} |}|r4| |q&|tt dd|O}||jjh8}j t jjjd}jdfdd|D|jgd||gd||jd d dS) NcSs|jSrmrrrUrUrVr\z!While._complete..rr!crrUZ_var_recursive)rZx_namerrUrVrsz#While._complete..)rJ Condition)rLZ StepScopes)rr&r)rTrrrrr%rwrr rrrarr r r r rSr&) rrZ while_blockrZ x_name_listZout_varsinner_out_name inner_varrrUrrVrs>        zWhile._completeFN) rrrrr$rrrrrrUrUrUrVr,sG  r,cCsdd}t|ttjfs!t|trt|trt||dS|}dS|jtjjj krH|j j }| | j }|rD||jsFt||dSdSdSt|trbt|trb|||rbtd|j|jt||dS)zt Assign input to output, but skip the process of copying LoDTensorArray unless it's created in while_block. cSsNt|jt|jkr dSt|j|jD]\}}||kr$d||fvr$dSqdS)NTrXF)r^rfzip)Zx_varZy_varZx_dimZy_dimrUrUrVhas_shape_diff1sz4assign_skip_lod_tensor_array..has_shape_diffNzxIn dy2static mode, we attemp to assign a variable with shape {} into a variable with shape{}, which is not always right.)rnr r ZVarBasertrrNr r rrprogramrrrrwr_r`rurf)rErr0rrrUrUrVassign_skip_lod_tensor_array,s:  r2Fc Cstdit}t|stdt|stdt|dttfdt|dkr+td||}t |dd gdt d d |j d d krLtd t|j t r|d}|r||}t|ttfse|g}t|t|krqtd||d}tt|||sW|St|||} t|} | S| rt|} || }n||}t|ttfs|g}zt||}t||ddWnty} ztd | d} ~ ww||}tt||t||Wd|S1swY|S)a :api_attr: Static Graph while_loop is one of the control flows. Repeats while_loop `body` until `cond` returns False. Notice: Local variables defined in ``body`` cannot be obtained through ``fetch_list`` of ``Executor`` , variables should be defined outside ``body`` and placed in ``loop_vars`` for looping, then these variables can be fetched by ``fetch_list`` . Args: cond(Callable): A callable returning a boolean tensor controlling whether to continue looping. And ``cond`` takes as many arguments as ``loop_vars`` . body(Callable): A callable returning a tuple or list of tensors or LoDTensorArrays of the same arity (length and structure) and types as ``loops_vars`` . And ``body`` takes as many arguments as ``loop_vars`` . loop_vars(list|tuple): A list or tuple of tensors or LoDTensorArrays that is passed to both ``cond`` and ``body`` . is_test(bool, optional): A flag indicating whether execution is in test phase. Default value is False. name(str, optional): Normally there is no need for users to set this property. For more information, please refer to :ref:`api_guide_Name`. Default is None. Returns: A list or tuple of Tensors or LoDTensorArrays which returned by ``body`` . Examples: .. code-block:: python import paddle paddle.enable_static() def cond(i, ten): return i < ten def body(i, ten): i = i + 1 return [i, ten] main_program = paddle.static.default_main_program() startup_program = paddle.static.default_startup_program() with paddle.static.program_guard(main_program, startup_program): i = paddle.full(shape=[1], fill_value=0, dtype='int64') # loop counter ten = paddle.full(shape=[1], fill_value=10, dtype='int64') # loop length i, ten = paddle.static.nn.while_loop(cond, body, [i, ten]) exe = paddle.static.Executor(paddle.CPUPlace()) res = exe.run(main_program, feed={}, fetch_list=[i]) print(res) # [array([10])] rCz%cond in while_loop should be callablez%body in while_loop should be callable loop_varszfluid.layers.while_looprz+loop_vars in while_loop should not be emptyzvar of cond returnedrcSr"rmrUrYrUrUrVr\r#zwhile_loop..rzPthe shape of the variable returned by cond should be [1],but given shape as {0}.z]body in while_loop should return the same arity (length and structure) and types as loop_varsFZ check_typeszXbody in while_loop should return the same arity (length and structure) as loop_vars: {0}N)rC)rrPcallablervr%rQrRr^rr$r!rfrurnumpyrnrr2r,rrr_deal_with_undefined_varrr) r9bodyr3r&rwrTZpre_condZnow_cond output_varsZwhile_loop_blockZhas_mutable_vars_in_loopZ new_loop_varsrzrUrUrVrCWsr/            rCcs|ddlm}mfdd}t|t|krtdg}t||D]\}}t||s.|dur6|||q!||q!|S)aDeal with undefined var cases, We create undefined variable based on the results of body(). In Dy2Static, we use undefined var to represent the var created in control flow. This function expand the loop_vars and replace original loop_vars. 1. UndefinedVar = Variable # create a variable 2. UndefinedVar = None # create a undefined var with RETURN_NO_VALUE_MAGIC_NUM 3. UndefinedVar = List(int) # create a list of variable 4. UndefinedVar = value # create a variable r)rlcreate_undefined_variablecs>t|tfts |durSt|r tfdd|SdS)NcsSrmrUr(r:rUrVr\r)zC_deal_with_undefined_var..create_var_like..)rnr rtrr)o_varr;rUrVcreate_var_likesz1_deal_with_undefined_var..create_var_likez+The length of loop_vars should be the same.N)rqrlr:r^rr/rnr)r9r3rlr=resultsr<Zl_varrUr;rVr7s   r7cCst|dttfdt|tr$t|D]\}}t|dt|dtdqtd it}|jt j j j t dd}|jdd|id|id|id |S) a 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 a length, both of which are int type. Refering to specified level of LoD, the index is the sequence index number and the length represents the sequence length. Please note that the list is ranked in descending order by the length. The following is an example: .. code-block:: text x is a LoDTensor: x.lod = [[2, 1], [5, 1, 1]] x.data = [a, b, c, d, e, f, g] 1. set level to 0: Create lod rank table: lod_rank_table_obj = lod_rank_table(x, level=0) 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)] Args: x (Variable): Input variable, a LoDTensor based which to create the lod rank table. level (int): Specify the LoD level, on which to create the lod rank table. Returns: Variable: The created LoDRankTable object. Examples: .. code-block:: python import paddle.fluid as fluid x = fluid.layers.data(name='x', shape=[10], dtype='float32', lod_level=1) out = layers.lod_rank_table(x=x, level=0) rlod_rank_tableinput[])rNrwrJrLr|rN)r?)r%r rQrn enumeraterrrPrgr r r LOD_RANK_TABLErgeneraterS)rr|rinput_xrTtablerUrUrVr?s$0 r?cCs8td it}|jdd}|jdd|id|id|S) a ${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) Args: rank_table(${rank_table_type}): ${rank_table_comment}. Returns: ${out_comment}. max_seqence_lenrr~max_sequence_len RankTablerLrMN)rG)rrPrrS) rank_tablerTresrUrUrVrH0s rHcCst|dttfdt|tr$t|D]\}}t|dt|dtdqt|dttfdt|trHt|D]\}}t|dt|dtdq6td it}|jt dt j j j|jd}|jd||dd |id |S) a Convert a LoDTensor to a LoDTensorArray. This function split a LoDTesnor to a LoDTensorArray according to its LoD information. LoDTensorArray is an alias of C++ std::vector in PaddlePaddle. The generated LoDTensorArray of this function can be further read or written by `read_from_array()` and `write_to_array()` operators. However, this function is generally an internal component of PaddlePaddle `DynamicRNN`. Users should not use it directly. Args: x (Variable|list): The LoDTensor to be converted to a LoDTensorArray. table (ParamAttr|list): The variable that stores the level of lod which is ordered by sequence length in descending order. It is generally generated by `layers.lod_rank_table()` API. Returns: Variable: The LoDTensorArray that has been converted from the input tensor. Examples: .. code-block:: python import paddle.fluid as fluid 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) rlod_tensor_to_arrayr@rArFtable[rwrNrerJrIrLrMN)rL)r%r rQrnrBrrrPrgrrDr r r rrerS)rrFrrEtable_xrTarrayrUrUrVrLKs<  rLcCst|dttfdt|tr$t|D]\}}t|dt|dtdqt|dttfdt|trHt|D]\}}t|dt|dtdq6td it}|j|j d}|j d||dd |id |S) a Convert a LoD_Tensor_Aarry to an LoDTensor. Args: x (Variable|list): The lod tensor array to be converted to a tensor. 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 import paddle.fluid as fluid 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) rarray_to_lod_tensorr@rArFrMr~rOrLrMN)rR) r%r rQrnrBrrrPrrerS)rrFrrErPrTtmprUrUrVrRs4  rR?cCsvtr t||St|dgddtd it}|s$|j|jd}n|}|jdd|gid|gidt |id|S) aZ The OP is usually used for control flow to increment the data of :attr:`x` by an amount :attr:`value`. Notice that the number of elements in :attr:`x` must be equal to 1. Parameters: x (Variable): A tensor that must always contain only one element, its data type supports float32, float64, int32 and int64. value (float, optional): The amount to increment the data of :attr:`x`. Default: 1.0. in_place (bool, optional): Whether the OP should be performed in-place. Default: True. Returns: Variable: The elementwise-incremented tensor with the same shape and data type as :attr:`x`. Examples: .. code-block:: python import paddle.fluid as fluid counter = fluid.layers.zeros(shape=[1], dtype='float32') # [0.] fluid.layers.increment(counter) # [1.] rrrrGrr.r~rJrLrrN)r.) rr*Z increment_r$rrPrrerSfloat)rrin_placerTrirUrUrVr.s    r.cCsNtrUt|ts Jdt|tsJd|jdgksJd|d}|dur/t|j}t|ts8Jd|t |ksBJd|t |krN|||<|S| ||St |d d gd t |d td t dit}|durt|tr}|jtjjjkrtd |dur|jd|jtjjj|jd}|jd|g|gdd|gid|S)a This OP writes the input ``x`` into the i-th position of the ``array`` :ref:`api_fluid_LoDTensorArray` and returns the modified array. If ``array`` is none, a new LoDTensorArray will be created and returned. This OP is often used together with :ref:`api_fluid_layers_array_read` OP. Args: x (Variable): The input data to be written into array. It's multi-dimensional Tensor or LoDTensor. Data type: float32, float64, int32, int64. i (Variable): 1-D Tensor with shape [1], which represents the position into which ``x`` is written. Data type: int64. array (LoDTensorArray, optional): The LoDTensorArray into which ``x`` is written. The default value is None, when a new LoDTensorArray will be created and returned as a result. Returns: Variable: The input ``array`` after ``x`` is written into. Examples: .. code-block:: python import paddle.fluid as fluid tmp = fluid.layers.fill_constant(shape=[3, 2], dtype='int64', value=5) i = fluid.layers.fill_constant(shape=[1], dtype='int64', value=10) # Write tmp into the position of arr with subscript 10 and return arr. arr = fluid.layers.array_write(tmp, i=i) # Now, arr is a LoDTensorArray with length 11. We can use array_read OP to read # the data at subscript 10 and print it out. item = fluid.layers.array_read(arr, i=i) input = fluid.layers.Print(item, message="The content of i-th LoDTensor:") main_program = fluid.default_main_program() exe = fluid.Executor(fluid.CPUPlace()) exe.run(main_program) # The printed result is: # 1570533133 The content of i-th LoDTensor: The place is:CPUPlace # Tensor[array_read_0.tmp_0] # shape: [3,2,] # dtype: l # data: 5,5,5,5,5,5, # the output is 2-D Tensor with shape [3,2], which is tmp above. # dtype is the corresponding C++ data type, which may vary in different environments. # Eg: if the data type of tensor is int64, then the corresponding C++ data type is int64_t, # so the dtype value is typeid(int64_t).Name(), which is 'x' on MacOS, 'l' on Linux, # and '__int64' on Windows. They both represent 64-bit integer variables. zBThe input data 'x' in array_write must be Variable in dygraph modez=The index 'i' in array_write must be Variable in dygraph moder4The shape of index 'i' should be [1] in dygraph moderN9The 'array' in array_write must be a list in dygraph modezNThe index 'i' should not be greater than the length of 'array' in dygraph moderrr/rz7array should be tensor array vairable in array_write Op{0}.outrNwrite_to_arrayrJIrLrM)r/)rrnr rfr6itemr0rerQr^rr$r%rrPrNr r r rrvrgrurwrS)rrrQrTrUrUrVr/sp2     r/cCsg}|durt|ttfstdt|t|}|D]}t|ts,tdt|qtr2|Stdit }|j d|j t j jj|d}|D] }t|t||dqK|S) aQ This OP creates an LOD_TENSOR_ARRAY. It is used as the input of :ref:`api_fluid_layers_array_read` and :ref:`api_fluid_layers_array_write`. Also it can be used with :ref:`api_fluid_layers_While` to create RNN network. Args: dtype (str): The data type of the elements in the lod_tensor_array. Support data type: float32, float64, int32, int64. initialized_list(list): Used to initialize as default value for created array. All values in initialized list should be a Tensor. Returns: Variable: The empty lod_tensor_array. The data type of elements in Tensor is ``dtype``. Examples: .. code-block:: python import paddle.fluid as fluid data = fluid.layers.create_array(dtype='float32') # Create a float32 LoDTensorArray. NzDRequire type(initialized_list) should be list/tuple, but received {}zEAll values in `initialized_list` should be Variable, but recevied {}.rQrZrNrrrQ)rQ)rnrQrRrvrurNr rrrPrgrwr r r rr/r8)reZinitialized_listrQvalrTZ tensor_arrayrUrUrVr0Hs8  r0cCst|dgddt|dgdd|durt|dtd|dkr(t|dtdtdit}|dur=|jdd }d |_t}|durH||d<|j d|g|gd d |gi|d |S)a ${comment} Args: x(Tensor): ${x_comment}. y(Tensor): ${y_comment}. force_cpu(${force_cpu_type}): ${force_cpu_comment}. cond(Tensor, optional): Optional output which can be any created Tensor that meets the requirements to store the result of *less_than*. if cond is None, a new Tensor will be created to store the result. name(str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`. Returns: ${out_comment}. Examples: .. code-block:: python import paddle x = paddle.to_tensor([1, 2, 3, 4], dtype='float32') y = paddle.to_tensor([2, 2, 1, 3], dtype='float32') result = paddle.less_than(x, y) print(result) # [True, False, False, False] rrUr1yNr9 force_cpurr~TrJYrLr)r1) r$r%r rrrPr stop_gradientdictrS)rrarbr9rwrTrrUrUrVr1s0    r1cCt|dgddt|dgdd|durt|dtdtd it}|dur2|jdd}d |_t}|jd|g|gd d |gi|d |S)a :alias_main: paddle.less_equal :alias: paddle.less_equal,paddle.tensor.less_equal,paddle.tensor.logic.less_equal :old_api: paddle.fluid.layers.less_equal This OP returns the truth value of :math:`x <= y` elementwise, which is equivalent function to the overloaded operator `<=`. Args: x(Variable): First input to compare which is N-D tensor. The input data type should be float32, float64, int32, int64. y(Variable): Second input to compare which is N-D tensor. The input data type should be float32, float64, int32, int64. cond(Variable, optional): Optional output which can be any created Variable that meets the requirements to store the result of *less_equal*. if cond is None, a new Varibale will be created to store the result. name(str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`. Returns: Variable, the output data type is bool: The tensor variable storing the output, the output shape is same as input :attr:`x`. Examples: .. code-block:: python import paddle.fluid as fluid import numpy as np label = fluid.layers.assign(np.array([1, 3], dtype='int32')) limit = fluid.layers.assign(np.array([1, 2], dtype='int32')) out = fluid.layers.less_equal(x=label, y=limit) #out=[True, False] out1 = label<= limit #out1=[True, False] rrUr2raNr9rr~TrcrLr)r2 r$r%r rrPrrerfrSrrar9rwrTrrUrUrVr2s(    r2cCst|dgddt|dgdd|durt|dtdtdit}|dur2|jdd}d |_t}tr?t ||d S|j d|g|gd d |gi|d |S)a :alias_main: paddle.greater_than :alias: paddle.greater_than,paddle.tensor.greater_than,paddle.tensor.logic.greater_than :old_api: paddle.fluid.layers.greater_than This OP returns the truth value of :math:`x > y` elementwise, which is equivalent function to the overloaded operator `>`. Args: x(Variable): First input to compare which is N-D tensor. The input data type should be float32, float64, int32, int64. y(Variable): Second input to compare which is N-D tensor. The input data type should be float32, float64, int32, int64. cond(Variable, optional): Optional output which can be any created Variable that meets the requirements to store the result of *greater_than*. if cond is None, a new Varibale will be created to store the result. name(str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`. Returns: Variable, the output data type is bool: The tensor variable storing the output, the output shape is same as input :attr:`x` . Examples: .. code-block:: python import paddle.fluid as fluid import numpy as np label = fluid.layers.assign(np.array([2, 3], dtype='int32')) limit = fluid.layers.assign(np.array([3, 2], dtype='int32')) out = fluid.layers.greater_than(x=label, y=limit) #out=[False, True] out1 = label > limit #out1=[False, True] rrUr3raNr9rr~TrXrcrLr)r3) r$r%r rrPrrerfrr*r3rSrirUrUrVr3s,    r3cCrg)a :alias_main: paddle.greater_equal :alias: paddle.greater_equal,paddle.tensor.greater_equal,paddle.tensor.logic.greater_equal :old_api: paddle.fluid.layers.greater_equal This OP returns the truth value of :math:`x >= y` elementwise, which is equivalent function to the overloaded operator `>=`. Args: x(Variable): First input to compare which is N-D tensor. The input data type should be float32, float64, int32, int64. y(Variable): Second input to compare which is N-D tensor. The input data type should be float32, float64, int32, int64. cond(Variable, optional): Optional output which can be any created Variable that meets the requirements to store the result of *greater_equal*. if cond is None, a new Varibale will be created to store the result. name(str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`. Returns: Variable, the output data type is bool: The tensor variable storing the output, the output shape is same as input :attr:`x`. Examples: .. code-block:: python import paddle.fluid as fluid import numpy as np label = fluid.layers.assign(np.array([2, 2], dtype='int32')) limit = fluid.layers.assign(np.array([2, 3], dtype='int32')) out = fluid.layers.greater_equal(x=label, y=limit) #out=[True, False] out_1 = label >= limit #out1=[True, False] rrUr4raNr9rr~TrcrLr)r4rhrirUrUrVr4.s(    r4cCstr d}t|||St|dgddt|dgdd|dur)t|dtdtdit}|dur>|jdd }d |_ |j d|g|gd d |gid |S)ad This layer returns the truth value of :math:`x == y` elementwise. Args: x(Variable): Tensor, data type is float32, float64, int32, int64. y(Variable): Tensor, data type is float32, float64, int32, int64. cond(Variable, optional): Optional output which can be any created Variable that meets the requirements to store the result of *equal*. if cond is None, a new Varibale will be created to store the result. name(str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`. Returns: Variable: output Tensor, it's shape is the same as the input's Tensor, and the data type is bool. Examples: .. code-block:: python import paddle.fluid as fluid import numpy as np out_cond =fluid.data(name="input1", shape=[2], dtype='bool') label = fluid.layers.assign(np.array([3, 3], dtype="int32")) limit = fluid.layers.assign(np.array([3, 2], dtype="int32")) label_cond = fluid.layers.assign(np.array([1, 2], dtype="int32")) out1 = fluid.layers.equal(x=label,y=limit) #out1=[True, False] out2 = fluid.layers.equal(x=label_cond,y=limit, cond=out_cond) #out2=[False, True] out_cond=[False, True] rXrrUr5raNr9rr~TrcrLrM)r5) rr*r5r$r%r rrPrrerS)rrar9rwZ default_axisrTrUrUrVr5gs&   r5cCst|dgddt|dgdd|durt|dtdtd it}|dur2|jdd}d |_|jd|g|gd d |gid |S)a :alias_main: paddle.not_equal :alias: paddle.not_equal,paddle.tensor.not_equal,paddle.tensor.logic.not_equal :old_api: paddle.fluid.layers.not_equal This OP returns the truth value of :math:`x != y` elementwise, which is equivalent function to the overloaded operator `!=`. Args: x(Variable): First input to compare which is N-D tensor. The input data type should be float32, float64, int32, int64. y(Variable): Second input to compare which is N-D tensor. The input data type should be float32, float64, int32, int64. cond(Variable, optional): Optional output which can be any created Variable that meets the requirements to store the result of *not_equal*. if cond is None, a new Varibale will be created to store the result. name(str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`. Returns: Variable, the output data type is bool: The tensor variable storing the output, the output shape is same as input :attr:`x`. Examples: .. code-block:: python import paddle.fluid as fluid label = fluid.layers.data(name='label', shape=[1], dtype='int64') limit = fluid.layers.fill_constant(shape=[1], value=1, dtype='int64') out = fluid.layers.not_equal(x=label, y=limit) rrUr6raNr9rr~TrcrLrM)r6)r$r%r rrPrrerS)rrar9rwrTrUrUrVr6s    r6cCstr*t|ts Jdt|tsJd|jdgksJd|d}||St|ddgdtdit }t|trG|j t j j jkrKtd |j|jd }|jd |g|gd d |gid|S)a This OP is used to read data at the specified position from the input array :ref:`api_fluid_LoDTensorArray` . ``array`` is the input array and ``i`` is the specified read position. This OP is often used together with :ref:`api_fluid_layers_array_write` OP. Case 1: :: Input: The shape of first three tensors are [1], and that of the last one is [1,2]: array = ([0.6], [0.1], [0.3], [0.4, 0.2]) And: i = [3] Output: output = [0.4, 0.2] Args: array (LoDTensorArray): The input LoDTensorArray. i (Variable): 1-D Tensor, whose shape is [1] and dtype is int64. It represents the specified read position of ``array``. Returns: Variable: The LoDTensor or Tensor that is read at the specified position of ``array``. Examples: .. code-block:: python # First we're going to create a LoDTensorArray, then we're going to write the Tensor into # the specified position, and finally we're going to read the Tensor at that position. import paddle.fluid as fluid arr = fluid.layers.create_array(dtype='float32') tmp = fluid.layers.fill_constant(shape=[3, 2], dtype='int64', value=5) i = fluid.layers.fill_constant(shape=[1], dtype='int64', value=10) # tmp is the Tensor with shape [3,2], and if we write it into the position with subscript 10 # of the empty-array: arr, then the length of arr becomes 11. arr = fluid.layers.array_write(tmp, i, array=arr) # Read the data of the position with subscript 10. item = fluid.layers.array_read(arr, i) # You can print out the data via executor. input = fluid.layers.Print(item, message="The LoDTensor of the i-th position:") main_program = fluid.default_main_program() exe = fluid.Executor(fluid.CPUPlace()) exe.run(main_program) # The printed result is: # 1569588169 The LoDTensor of the i-th position: The place is:CPUPlace # Tensor[array_read_0.tmp_0] # shape: [3,2,] # dtype: l # data: 5,5,5,5,5,5, # the output is 2-D Tensor with shape [3,2]. # dtype is the corresponding C++ data type, which may vary in different environments. # Eg: if the data type of tensor is int64, then the corresponding C++ data type is int64_t, # so the dtype value is typeid(int64_t).Name(), which is 'x' on MacOS, 'l' on Linux, # and '__int64' on Windows. They both represent 64-bit integer variables. z6The 'array' in array_read must be list in dygraph modez= r7cCsrtd it}t|dtdt|dtdt|dtd|j|jd}|jd|g|g|gdd|giid |S) a/ This function creates an operator to shrink rnn memory using the RankTable as mentioned in the input parameter. 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. shrink_memoryrrrFr~Zshrink_rnn_memory)rJr]rIrLrN)rk)rrPr%r rrerS)rrrFrTrirUrUrVrk& srkcCstrt|ts Jdt|St|tr|jtjjj kr!t dt d it }|j dd}d|_|jdd|gid |gid |S) a This OP is used to get the length of the input array :ref:`api_fluid_LoDTensorArray` . It can be used together with :ref:`api_fluid_layers_array_read` , :ref:`api_fluid_layers_array_write` , :ref:`api_fluid_layers_While` OP to traverse, read and write LoDTensorArray. Args: array (LoDTensorArray): The input array that will be used to compute the length. Returns: Variable: 1-D Tensor with shape [1], which is the length of array. Datatype: int64. Examples: .. code-block:: python import paddle.fluid as fluid tmp = fluid.layers.zeros(shape=[10], dtype='int32') i = fluid.layers.fill_constant(shape=[1], dtype='int64', value=10) # tmp is 1-D Tensor with shape [10]. We write tmp into arr on subscript 10, # then the length of arr becomes 11. arr = fluid.layers.array_write(tmp, i=i) # return the length of arr arr_len = fluid.layers.array_length(arr) # You can use executor to print out the length of LoDTensorArray. input = fluid.layers.Print(arr_len, message="The length of LoDTensorArray:") main_program = fluid.default_main_program() exe = fluid.Executor(fluid.CPUPlace()) exe.run(main_program) # The printed result is: # 1569576542 The length of LoDTensorArray: The place is:CPUPlace # Tensor[array_length_0.tmp_0] # shape: [1,] # dtype: l # data: 11, # 1-D Tensor with shape [1], whose value is 11. It means that the length of LoDTensorArray # is 11. # dtype is the corresponding C++ data type, which may vary in different environments. # Eg: if the data type of tensor is int64, then the corresponding C++ data type is int64_t, # so the dtype value is typeid(int64_t).Name(), which is 'x' on MacOS, 'l' on Linux, # and '__int64' on Windows. They both represent 64-bit integer variables. rYz8array should be tensor array vairable in array_length Opr8rr~TZlod_array_lengthrJrLrMN)r8)rrnrQr^r rNr r r rrvrrPrrerS)rQrTrSrUrUrVr8M s(. r8cr)ConditionalBlockGuarda? ConditionalBlockGuard is derived from BlockGuard. It is dedicated for holding a ConditionalBlock, and helping users entering and exiting the ConditionalBlock via Python's 'with' keyword. However, ConditionalBlockGuard is generally an internal component of IfElse, users should not use it directly. cs,t|dtdtt||jj||_dS)Nrrl)r%ConditionalBlockrrlrrTrr)rrrrUrVr s zConditionalBlockGuard.__init__cstt|Srm)rrlrrrrUrVr rzConditionalBlockGuard.__enter__cs|jtt||||Srm)rcompleterrlrrrrUrVr s  zConditionalBlockGuard.__exit__rrUrUrrVrl s   rlc@s:eZdZdZdddZddZdd Zd d Zd d ZdS)rma **ConditionalBlock** ConditionalBlock is an operator that bind a block to a specific condition, if the condition matches, the corresponding block will be executed. Args: inputs (Variable): bool conditions. is_scalar_condition (bool): whether the branch is controlled by a scalar. name(str): name of this ConditionalBlock. Examples: .. code-block:: python import paddle.fluid as fluid cond = layers.less_than(x=label, y=limit) true_image, false_image = layers.split_lod_tensor( input=image, mask=cond) true_cond = layers.ConditionalBlock([true_image]) with true_cond.block(): ... with false_cond.block(): ... FNcCs6|D] }t|dtdq||_||_td|d|_dS)NrErmconditional_blockr)r%r rOis_scalar_conditionrrT)rrOrprwZ each_inputrUrUrVr s zConditionalBlock.__init__cCrrm)rlrrUrUrVr r'zConditionalBlock.blockc s|jj}|jj|jt}t}t||||jd\}}fdd|D}g}|D]}|}|r:||q,j t j j j d}jd|j|d||gd||jdd } ||rg||| dSdS) NrTcrrUr*)rZ each_namerrUrVr rz-ConditionalBlock.complete..rro)rr)rLZScope)rrpr)rTrrrrrr rrrr r r r rSrOrp"need_append_conditional_block_gradappend_conditional_block_grad) r inside_block intermediater param_listZout_listr,r-rconditional_block_oprUrrVrn sD       zConditionalBlock.completecCs|j}|j}|dko ||kSrW)backward_block_idxidx)rrtgrad_sub_block_idxZinside_block_idxrUrUrVrr sz3ConditionalBlock.need_append_conditional_block_gradcCs|j}|jj|}t}t}|jD]3}t|tsJ|jD]} | | D] } | |vr1| | q&q|j D]} | | D]} | | q=q6qg} |D]}| |}|r]| t|jqKt|jtt|jg\}}tj}tjjj}|j}||d||||d| |ddd| Dt}|D]%}|jt |s|t!krq|j"t || |||vrqq|#|j|$|j|D] }||vrt%||q|jj&dS)a Append op `conditional_block_grad` manually. When `optimizer.minimize/append_backward` is called in Paddle control flow, grad ops will be appended before appending op `conditional_block` so that op `conditional_block_grad` can't be appended when calling `optimizer.minimize/append_backward`. After appending op `conditional_block`, `conditional_block_grad` is appended manually. Args: parent_block (Block): The block that `conditional_block_op` blongs to. inside_block (Block): The sub block of `conditional_block_op`. conditional_block_op (Operator): The forward op conditional_block. rrz Input@GRADcSsg|]}|dqS)z@GRADrU)rparamrUrUrVr9 zBConditionalBlock.append_conditional_block_grad..N)'rxrTrrrrrnrrrErrrrrcptZto_textrwr Zget_grad_op_descdescZop_proto_and_checker_makerZkOpRoleAttrNameZOpRoleZBackwardrSZ copy_fromZ _set_attrZ set_inputZ set_outputZoutput_arg_namesZhas_var_recursiveto_bytesZempty_var_namerZinfer_var_typeZ infer_shaper)Z_sync_with_cpp)rrrtrwrzZgrad_sub_blockrurZeach_oprrrrrvZinner_input_namer-Z grad_op_descZop_grad_to_varZop_role_attr_namebackwardZ new_op_descZnew_varsZ grad_var_nameargrUrUrVrs sn                  z.ConditionalBlock.append_conditional_block_gradr.) rrrrrrrnrrrsrUrUrUrVrm s , rmcCst|ts|S|j}|j}|dksJd||}|jtjj j kr.| |j r.|}|S|j |j|j|jd}t|||S)NrzOGot wrong parent block index when assigning var to parent scope in control_flowrd)rnr rrrrrNr r r rrrwrrerfr)r layer_helperrrrrrUrUrVcopy_var_to_parent_blockU s$       rc sXtrKt|ts Jd|jdksJd|d}|r4|dur2t|s/tdt|j |SdS|durIt|sFtdt|j |SdSt |dd gd t |d t tdfd t ditd}d}fd d}|durt|stdt|j t|gdd}||} | durt|| }Wdn1swY|durt|stdt|j tt|gdd} | |} | durt|| }Wdn1swY|dur|durdS|durtd|durtd|durd} dgtt|}n d} t|||\}}tt|tt|kr7tdtt|tt|tt|t|t|D]$\} }}z t| |ddWqCtyg}ztd||d}~wwdd}|t|t|t|| rt||\}}t|ddfddfdd}tt|t|t|t|}t|t|}|S) a This API returns ``true_fn()`` if the predicate ``pred`` is true else ``false_fn()`` . Users could also set ``true_fn`` or ``false_fn`` to ``None`` if do nothing and this API will treat the callable simply returns ``None`` in this case. ``true_fn`` and ``false_fn`` should return same nest structure of tensors or both return ``None`` if user doens't like to return anything. A nest structure of tensors in PaddlePaddle is tensor(s), or tuple of tensors, or list of tensors. Note: 1. The tuples or lists returned by ``true_fn`` and ``false_fn`` must have the same shape because of dataflow model of PaddlePaddle while the tensors in the tuples or the lists can have different shapes. 2. This API could be used under both static mode or dygraph mode. If it is in dygraph mode, the API only runs one branch based on condition. 3. If it is in static mode, any tensors or operations created outside or inside of ``true_fn`` and ``false_fn`` will be in net building regardless of which branch is selected at runtime. This has frequently surprised users who expected a lazy semantics. For example: .. code-block:: python import paddle a = paddle.zeros((1, 1)) b = paddle.zeros((1, 1)) c = a * b out = paddle.static.nn.cond(a < b, lambda: a + c, lambda: b * b) No matter whether ``a < b`` , ``c = a * b`` will be in net building and run. ``a + c`` and ``b * b`` will be in net building, but only one branch will be executed during runtime. Args: pred(Tensor): A boolean tensor whose numel should be 1. The boolean value determines whether to return the result of ``true_fn`` or ``false_fn`` . true_fn(callable, optional): A callable to be performed if ``pred`` is true. The default value is ``None`` . false_fn(callable, optional): A callable to be performed if ``pred`` is false. The default value is ``None`` . name(str, optional): The default value is ``None`` . Normally users don't have to set this parameter. For more information, please refer to :ref:`api_guide_Name` . return_names(sequence of string, optional): The default value is ``None`` . Normally users don't have to set this parameters. A sequence of strings to represents the name of returned vars. The structure of sequence must be same with return values of true_fn and false_fn. Returns: Tensor|list(Tensor)|tuple(Tensor): returns ``true_fn()`` if the predicate ``pred`` is true else ``false_fn()`` . Raises: TypeError: if ``true_fn`` or ``false_fn`` is not callable. ValueError: if ``true_fn`` and ``false_fn`` don't return the same nest structure of tensors. Examples: .. code-block:: python import paddle # # pseudocode: # if 0.1 < 0.23: # return 1, True # else: # return 3, 2 # def true_func(): return paddle.full(shape=[1, 2], dtype='int32', fill_value=1), paddle.full(shape=[2, 3], dtype='bool', fill_value=True) def false_func(): return paddle.full(shape=[3, 4], dtype='float32', fill_value=3), paddle.full(shape=[4, 5], dtype='int64', fill_value=2) x = paddle.full(shape=[1], dtype='float32', fill_value=0.1) y = paddle.full(shape=[1], dtype='float32', fill_value=0.23) pred = paddle.less_than(x=x, y=y, name=None) ret = paddle.static.nn.cond(pred, true_func, false_func) # ret is a tuple containing 2 tensors # ret[0] = [[1 1]] # ret[1] = [[ True True True] # [ True True True]] z!The pred in cond must be Variablerz#condition input's numel should be 1rNz5The true_fn in cond must be callable, but received {}z6The false_fn in cond must be callable, but received {}predrzfluid.layers.condrwr9cs t|Srm)r)rrqrUrVr\ s zcond..TrpzpIncompatible return values of true_fn and false_fn in cond: true_fn returns None while false_fn returns non-NonezpIncompatible return values of true_fn and false_fn in cond: true_fn returns non-None while false_fn returns NoneFzno namezJtrue fn returns {} vars, but false fn returns {} vars, which is not equalsr4zFIncompatible return values of `{}` in true_fn and false_fn in cond: {}c Sst|||D]F\}}}t|}t|}tt|D]2}||dur'||dus3||durK||durKtd|t||||t||||qqdS)NIn cond : Var '{}' or part of it is set differently in ifelse branchs, <{}, {}> in true branch and <{}, {}> in false branch. Set var to 'None' in ifelse block might lead to error.)r/rranger^r_r`rurN)Zseq_trueZ seq_falseZ seq_namesZf_trueZf_falsef_nameryrUrUrVcheck_ret_noneE s*      zcond..check_ret_nonerGr~cst||g|Srm)r{)rwrxry)rFrUrVr\i s cstt|||Srm)rr")Z false_varsZ true_varsrw) merge_funcrUrVmerge_every_var_listn sz"cond..merge_every_var_list)r9)rrnr sizer6r5rvrurNrr$r%rrrPrmrrrrr^_to_sequence_except_dictexpand_undefined_varr/rchange_none_to_undefinedvarr rQrarr)rtrue_fnfalse_fnrwZ return_namesZ true_outputZ false_outputZcopy_to_parent_funcZtrue_cond_blockZorigin_true_outputZfalse_cond_blockZorigin_false_outputZ is_dy2staicZtrue_outZ false_outZ return_namerzrrZ merged_outputrU)rTrFrrVr9l sd             r9csPddlmfdd}t|tt|t|}t|tt|t|}||fS)Nrrkcs|durdS|S)NpaddingrUr(rkrUrVmap_fn sz+change_none_to_undefinedvar..map_fn)rqrlrrQrar)nest1nest2r nest1_out nest2_outrUrkrVr} s  rcCst|tr|gSt|S); In this function, dict is not viewed as sequence. )rnrfr r(rUrUrVr s rcCst|trdSt|S)rF)rnrfrr(rUrUrV_is_sequence_except_dict s rc sddlmddlmfddfdd}tt|t|t|t|dd t|D}tt|t|t|t|d d t|D}t|sP|d}t|sX|d}||fS) zTODO: make this function recursively. nest1: Var1, (UndefinedVar, [1,2,3]) nest2: Var2, ([1,2,3,4], UndefinedVar) In this case, we should not expand recursively. rrk)RETURN_VALUE_PREFIXcst|fddt|DS)Ncsg|]}dqS)rrUrrkrUrVr r|zGexpand_undefined_var..pack_undefined_var_as..)rr)seqrkrUrVpack_undefined_var_as sz3expand_undefined_var..pack_undefined_var_asc s|sBt|s|durB|dur>|dur>|dkr.td|t||t|||Std|t||t|||S|S)Nrr) startswithrnr_r`rurN)Zn1Zn2rworderrrlrrUrVr s* z$expand_undefined_var..map_fncSg|]}dqSrrUrrUrUrVr r]z(expand_undefined_var..cSr)rrUrrUrUrVr r])rqrlZ9paddle.fluid.dygraph.dygraph_to_static.return_transformerrrQrarr)rrnamesrrrrUrrVr s6     rcCsdj|||||d}|S)NzW{what} of '{arg_name}' in {op_name} must be {right_value}, but received: {error_value}.)whatarg_nameop_name right_value error_value)ru)rrrrr error_messagerUrUrV_error_message s rc CsVtdit}dd}|||\}}|}t|D] \}}tt|||d}q|}|S)aB :api_attr: Static Graph This operator works like an if-elif-elif-else chain. Args: pred_fn_pairs(list|tuple): A list or tuple of (pred, fn) pairs. ``pred`` is a boolean Tensor with shape [1], ``fn`` is a callable. All callables return the same structure of Tensors. default(callable, optional): Callable that returns a structure of Tensors. name(str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor|list(Tensor): Tensors returned by the callable from the first pair whose pred is True, or Tensors returned by ``default`` if no pred in ``pred_fn_pairs`` is True and ``default`` is not None, or Tensors returned by the last callable in ``pred_fn_pairs`` if no pred in ``pred_fn_pairs`` is True and ``default`` is None. Raises: TypeError: If the type of ``pred_fn_pairs`` is not list or tuple. TypeError: If the type of elements in ``pred_fn_pairs`` is not tuple. TypeError: If the size of tuples in ``pred_fn_pairs`` is not 2. TypeError: If the first element of 2-tuple in ``pred_fn_pairs`` is not a Tensor. TypeError: If the second element of 2-tuple in ``pred_fn_pairs`` is not callable. TypeError: If ``default`` is not None but it is not callable. Examples: .. code-block:: python import paddle paddle.enable_static() def fn_1(): return paddle.full(shape=[1, 2], dtype='float32', fill_value=1) def fn_2(): return paddle.full(shape=[2, 2], dtype='int32', fill_value=2) def fn_3(): return paddle.full(shape=[3], dtype='int32', fill_value=3) main_program = paddle.static.default_startup_program() startup_program = paddle.static.default_main_program() with paddle.static.program_guard(main_program, startup_program): x = paddle.full(shape=[1], dtype='float32', fill_value=0.3) y = paddle.full(shape=[1], dtype='float32', fill_value=0.1) z = paddle.full(shape=[1], dtype='float32', fill_value=0.2) pred_1 = paddle.less_than(z, x) # true: 0.2 < 0.3 pred_2 = paddle.less_than(x, y) # false: 0.3 < 0.1 pred_3 = paddle.equal(x, y) # false: 0.3 == 0.1 # Call fn_1 because pred_1 is True out_1 = paddle.static.nn.case( pred_fn_pairs=[(pred_1, fn_1), (pred_2, fn_2)], default=fn_3) # Argument default is None and no pred in pred_fn_pairs is True. fn_3 will be called. # because fn_3 is the last callable in pred_fn_pairs. out_2 = paddle.static.nn.case(pred_fn_pairs=[(pred_2, fn_2), (pred_3, fn_3)]) exe = paddle.static.Executor(paddle.CPUPlace()) res_1, res_2 = exe.run(main_program, fetch_list=[out_1, out_2]) print(res_1) # [[1. 1.]] print(res_2) # [3 3 3] rAc Sst|dttfd|D]J}t|tsttdddtt|t|dkr4ttddddtt|d|\}}t|t sIttdddd t|t |sUtd |j q |d urpt|d }||d }|d |}||fSt |sxtd ||fS)zg Check arguments pred_fn_pairs and default. Return canonical pre_fn_pairs and default. pred_fn_pairsrAThe elements' typerThe tuple's size2-tuplezThe pred's typezboolean Variablez._case_check_argsrrrN)rA)rrPreversedr"r9) rrrwrTrrrrfinal_fnrUrUrVrA sA7rAc@s:eZdZdZd ddZddZddZd d Zd d ZdS)r-a :api_attr: Static Graph This class is used to implement Switch branch control function. Switch branch contains several case branches and one default branch. Switch control flow checks whether the case branch conditions are satisfied in turn, and only executes the statement after the first case branch that satisfies the conditions. If there is no case branch that satisfies the condition, only the statement following the default branch is executed. Note: A new OP :ref:`api_fluid_layers_case` is highly recommended instead of ``Switch`` if the shape of parameter ``cond`` is [1]. OP :ref:`api_fluid_layers_case` is easier to use and is called with less code but does the same thing as ``Switch`` . Member Functions: case(condition): The case branch of Switch whose parameter cond is a scalar Variable of bool type. Only if the cond of the current case branch is True and the cond of the previous case branch is False, the statement after the case branch will be executed, and the statement after the case branch will not be executed. default(): The default branch of Switch. When cond of all case branches is False, the statement after default branch is executed. Case and default functions can only be used inside the scope of Switch, as shown below: .. code-block:: python ''' with fluid.layers.Switch() as switch: with switch.case(cond1): i = fluid.layers.fill_constant(shape=[1], dtype='int64', value=1) with switch.case(cond2): i = fluid.layers.fill_constant(shape=[1], dtype='int64', value=2) with switch.default(): i = fluid.layers.fill_constant(shape=[1], dtype='int64', value=0) ''' Args: name(str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name` . Examples: .. code-block:: python import paddle.fluid as fluid lr = fluid.layers.create_global_var( shape=[1], value=0.0, dtype='float32', persistable=True, name="learning_rate") zero_var = fluid.layers.fill_constant( shape=[1], dtype='float32', value=0.0) one_var = fluid.layers.fill_constant( shape=[1], dtype='float32', value=1.0) two_var = fluid.layers.fill_constant( shape=[1], dtype='float32', value=2.0) global_step = fluid.layers.autoincreased_step_counter(counter_name='@LR_DECAY_COUNTER@', begin=0, step=1) with fluid.layers.control_flow.Switch() as switch: with switch.case(global_step == zero_var): fluid.layers.assign(input=one_var, output=lr) with switch.default(): fluid.layers.assign(input=two_var, output=lr) exe = fluid.Executor(fluid.CPUPlace()) exe.run(fluid.default_startup_program()) res = exe.run(fluid.default_main_program(), feed={}, fetch_list=[lr]) print(res) # [array([1.], dtype=float32)] NcCstd|d|_d|_g|_dS)NswitchrF)rrT inside_scopepre_not_conditionsrrUrUrVr s zSwitch.__init__cCs|jstdt|ddgdt|jdkr,t|gdd}t|d}|j|t |St|j}|j|d }t|t|dd }|j|tt||d gdd}t |S) Nz!case should be called inside with conditionrz/the member function case of fluid.layers.SwitchrTrr(r)rra) rrr$r^rrmrrrrl)rr cond_blockZnot_cond pre_cond_numZ pre_not_condZ new_not_condrUrUrVrA s0      z Switch.casecCs:t|j}|dkr tdt|j|dgdd}t|S)Nrz&there should be at least one conditionrTr)r^rrrmrl)rrrrUrUrVr s zSwitch.defaultcCs d|_|S)zN set flag that now is inside switch.block {} :return: TrrrUrUrVr szSwitch.__enter__cCsd|_|dur dSdSrrrrUrUrVr szSwitch.__exit__rm) rrrrrrArrrrUrUrUrVr-q s E r-c@s$eZdZddZddZddZdS)IfElseBlockGuardcCslt|ts td|jtjkrtd||_||_|r |j|_ n|j |_ t|j t s.td|j |_ dS)Nz*ifelse must be an instance of IfElse classz/You cannot invoke IfElse.block() inside a blockzUnexpected situation) rnr:rvrOUT_IF_ELSE_BLOCKSris_trueieconditional_true_blockrconditional_false_blockrmr)rrifelserUrUrVr s    zIfElseBlockGuard.__init__cCs$|jrtjntj|j_|jdSrm)rr:IN_IF_ELSE_TRUE_BLOCKSIN_IF_ELSE_FALSE_BLOCKSrrrrrrUrUrVr s zIfElseBlockGuard.__enter__cCsH|j|||s dSt|jj|jrdnddkrtdtj|j_ dS)NFrrzMust set output inside block) rrr^r output_tablerrr:rrrrUrUrVr s zIfElseBlockGuard.__exit__N)rrrrrrrUrUrUrVr s rc@sVeZdZdZdZdZdZdddZdd Zd d Z d d Z ddZ ddZ ddZ dS)r:a :api_attr: Static Graph This class is used to implement IfElse branch control function. IfElse contains two blocks, true_block and false_block. IfElse will put data satisfying True or False conditions into different blocks to run. Cond is a 2-D Tensor with shape [N, 1] and data type bool, representing the execution conditions of the corresponding part of the input data. Note: A new OP :ref:`api_fluid_layers_cond` is highly recommended instead of ``IfElse``. if the shape of parameter ``cond`` is [1]. OP :ref:`api_fluid_layers_cond` is easier to use and is called with less code but does the same thing as ``IfElse`` . IfElse OP is different from other OPs in usage, which may cause some users confusion. Here is a simple example to illustrate this OP. .. code-block:: python # The following code completes the function: subtract 10 from the data greater than 0 in x, add 10 to the data less than 0 in x, and sum all the data. import numpy as np import paddle.fluid as fluid x = fluid.layers.data(name='x', shape=[4, 1], dtype='float32', append_batch_size=False) y = fluid.layers.data(name='y', shape=[4, 1], dtype='float32', append_batch_size=False) x_d = np.array([[3], [1], [-2], [-3]]).astype(np.float32) y_d = np.zeros((4, 1)).astype(np.float32) # Compare the size of x, y pairs of elements, output cond, cond is shape [4, 1], data type bool 2-D tensor. # Based on the input data x_d, y_d, it can be inferred that the data in cond are [[true], [true], [false], [false]]. cond = fluid.layers.greater_than(x, y) # Unlike other common OPs, ie below returned by the OP is an IfElse OP object ie = fluid.layers.IfElse(cond) with ie.true_block(): # In this block, according to cond condition, the data corresponding to true dimension in X is obtained and subtracted by 10. out_1 = ie.input(x) out_1 = out_1 - 10 ie.output(out_1) with ie.false_block(): # In this block, according to cond condition, get the data of the corresponding condition in X as false dimension, and add 10 out_1 = ie.input(x) out_1 = out_1 + 10 ie.output(out_1) # According to cond condition, the data processed in the two blocks are merged. The output here is output, the type is List, and the element type in List is Variable. output = ie() # [array([[-7.], [-9.], [ 8.], [ 7.]], dtype=float32)] # Get the first Variable in the output List and add all elements. out = fluid.layers.reduce_sum(output[0]) exe = fluid.Executor(fluid.CPUPlace()) exe.run(fluid.default_startup_program()) res = exe.run(fluid.default_main_program(), feed={"x":x_d, "y":y_d}, fetch_list=[out]) print(res) # [array([-1.], dtype=float32)] Args: cond (Variable): cond is a 2-D Tensor with shape [N, 1] and data type bool, representing the corresponding execution conditions of N input data. The data type is bool. name(str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name` . Returns: Unlike other common OPs, the OP call returns an IfElse OP object (e.g. ie in the example), which branches the input data by calling the internal functions of the object ``true_block ()``, ``false_block ()``, ``input ()``, ``output ()``, and integrates the data processed by different branches as the overall output by calling the internal ``call ()`` function. The output type is a list, and the type of each element in the list is Variable. Internal Functions: The block is constructed by calling the ``with ie. true_block()`` function in the object, and the computational logic under condition true is put into the block. If no corresponding block is constructed, the input data in the corresponding conditional dimension is unchanged. The block is constructed by calling the ``with ie. false_block()`` function in the object, and the computational logic under condition false is put into the block. If no corresponding block is constructed, the input data in the corresponding conditional dimension is unchanged. ``Out = ie. input (x)`` will take out the data of the corresponding conditional dimension in X and put it into out, supporting the internal processing of multiple inputs in block. ``ie. output (out)`` writes the result to the output of the corresponding condition. There is a ``call ()`` function inside the object, that is, by calling ``output = ie ()``, all the outputs inside the block of False are fused as the whole output, the output type is a list, and the type of each element in the list is Variable. rrrNcCstt|dtdt|dttdfdtd|d|_||_i|_tj |_ t |jgd|_ t |jgd|_ ggf|_dS)Nr9zfluid.layers.IfElserwrr)rO)r%r rrNrrTr9 input_tabler:rrrmrrr)rr9rwrUrUrVrh szIfElse.__init__cCs|jtjkr tdt||jvrO|}|jt d|j j |j d}|jt d|j j |j d}|j d||jd||dddid ||f|jt|<n |jt|\}}|jtjkr`|S|S) Nzinput must in true/false blocksZ ifelse_inputrwrer}rIrr|rr)rr:rridrrrrrrTrwrerSr9r)rrrrrrUrUrVrEs s:     z IfElse.inputcCs|jj}|jj|jSrm)rTrrrr)rrrUrUrVr s zIfElse._parent_blockcC td|S)NTrrrUrUrV true_block  zIfElse.true_blockcCrrrrrUrUrV false_block rzIfElse.false_blockcGs|j|jkr td|j|j|jkrdnd}|}|D]&}t|dtd|jt d |j j dg|jd}||t||d qdS) Nz+output can only be invoked in the sub-blockrrz each outputzfluid.layers.IfElse.outputrrr)rEr)rrrrrrr%r rrrrrTrwrerr)rZoutsZ out_tablerZeach_outZ outside_outrUrUrVr s&  z IfElse.outputc Cs|j|jkr tdttt|j\}}|dkr |dkr td||kr0|dkr0|dkr0td|dks8|dkrD|j|dkrAdSdSg}t|jD]\}}|t |||j |j ddqK|S)Nz)IfElse::__call__ must be out of sub-blockrz2Must invoke true_block/false_block before __call__zThe output side must be samer)rrrFrr|) rrrrQrar^rr/rrr9)rZ false_lenZtrue_lenZrlistrxryrUrUrVr s.  zIfElse.__call__rm)rrrrrrrrrErrrrrrUrUrUrVr: sK  $ r:c@seZdZdZdZdZdZdddZd dd Zd d Z e d d Z ddZ     d!ddZ ddZddZddZddZddZdS)"r;a :api_attr: Static Graph **Note: the input of this class should be LoDTensor which holds the information of variable-length sequences. If the input is fixed-length Tensor, please use StaticRNN (fluid.layers.** :ref:`api_fluid_layers_StaticRNN` **) for better performance.** DynamicRNN can process a minibatch of variable-length sequences. The length of each sample can be different and is recorded in LoD. In DynamicRNN, an input sequence will be unfolded into time steps and users can define how to process each time step in :code:`block()` . The total number of time steps is determined by the longest sequence. DynamicRNN will not pad all sequences to the same length, instead it will sort the sequences internally by the sequence length in descending order. The input sequences will be shrank because only sequences of which the length is larger than the time step will participate the remaining calculation. If defined :code:`drnn = DynamicRNN()`, then users can call :code:`drnn()` to obtain the result sequences. It is a LoDTensor gained by merging all time steps's output. When RNN's input sequence x meets :code:`x.lod_level == 1`, the output LoDTensor will have the same LoD with x. The result of :code:`drnn()` includes RNN's outputs of all time steps, users can call :ref:`api_fluid_layers_sequence_last_step` to extract the data of the last time step. Warning: Currently it is not supported to set :code:`is_sparse = True` of any layers defined within DynamicRNN's :code:`block` function. Args: name (str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name` . Examples: .. code-block:: python import paddle.fluid as fluid sentence = fluid.data(name='sentence', shape=[None, 32], dtype='float32', lod_level=1) encoder_proj = fluid.data(name='encoder_proj', shape=[None, 32], dtype='float32', lod_level=1) decoder_boot = fluid.data(name='boot', shape=[None, 10], dtype='float32') drnn = fluid.layers.DynamicRNN() with drnn.block(): # Set sentence as RNN's input, each time step processes a word from the sentence current_word = drnn.step_input(sentence) # Set encode_proj as RNN's static input encoder_word = drnn.static_input(encoder_proj) # Initialize memory with boot_memory, which need reorder according to RNN's input sequences memory = drnn.memory(init=decoder_boot, need_reorder=True) fc_1 = fluid.layers.fc(input=encoder_word, size=30) fc_2 = fluid.layers.fc(input=current_word, size=30) decoder_inputs = fc_1 + fc_2 hidden, _, _ = fluid.layers.gru_unit(input=decoder_inputs, hidden=memory, size=30) # Update memory with hidden drnn.update_memory(ex_mem=memory, new_mem=hidden) out = fluid.layers.fc(input=hidden, size=10, bias_attr=True, act='softmax') # Set hidden and out as RNN's outputs drnn.output(hidden, out) # Get RNN's result hidden, out = drnn() # Get RNN's result of the last time step last = fluid.layers.sequence_last_step(out) rrrNcCsvtd|d|_tj|_d|_d|_d|_d|_t |_ g|_ g|_ |jj dd|_d|j_t|j|_g|_g|_dS)NZ dynamic_rnnrrr~F)rrTr; BEFORE_RNNrr? max_seq_lenstep_idxzero_idxrfmem_dict output_arrayrHrr9rer,r input_arraymem_linkrrUrUrVrs  zDynamicRNN.__init__cCs0|dt|dtd|}|jdurk|jtdtj j j d|_d|j_ |j dd|id |jid |id |jtd d d|_d|j_ |j dd|jid |jidd|j_ |j d|j|jdd |jiddid |jtdtj j j|jd}|j||jf|j d||jdd |idt||jdS)a This function is used to set sequence x as DynamicRNN's input. The maximum sequence length in x determines the number of time steps the RNN unit will be executed. DynamicRNN can take multiple inputs. When all inputs' :code:`lod_level` are 1, all inputs should hold the same LoD. When :code:`x.lod_level >= 2` , the input sequence will be unfold along specified level, and the slice of each time step is a LoDTensor whose lod_level is :code:`x.lod_level - level - 1` . In this case, the specified LoD level of multiple inputs should be the same. - Case 1: .. code-block:: text # input, where Si is slice data of shape [1, N] level = 0 x.lod = [[2, 1, 3]] x.shape = [6, N] x.data = [[S0], [S0], [S1], [S2], [S2], [S2]] # output # step 0, time step data of 3 sequences out.lod = [[]] out.shape = [3, N] out.data = [[S2], [S0], [S1]] # step 1, time step data of 2 sequences out.lod = [[]] out.shape = [2, N] out.data = [[S2], [S0]] # step 2, time step data of 1 sequences out.lod = [[]] out.shape = [1, N] out.data = [[S2]] Args: x (Variable): The input LoDTensor which holds information of a minibatch of variable-length sequences and should meet :code:`x.lod_level >= 1` . When RNN has multiple inputs, the first dimension should match across all inputs, but other shape components may differ. Optional data types are: bool, float16, float32, float64, int8, int16, int32, int64, uint8. level (int, optional): The level of lod used to split steps. It should be in range :math:`[0, x.lod\_level)` . The default value is 0. Returns: Variable: The current time step in the input sequence. If there are :code:`num_sequences` \ sequences in x whose length is larger than :code:`step_idx` , the returned Variable \ will only hold the :code:`step_idx` -th time step of those `num_sequences` sequences. \ The data type is the same as input. If :code:`x.lod_level == 1` , the return value is \ a Tensor of shape :math:`\{num\_sequences, x.shape[1], ...\}` , or it will \ be a variable-length LoDTensor. Raises: ValueError: When :code:`step_input()` is called outside :code:`block()` . TypeError: When x is not a Variable. Examples: .. code-block:: python import paddle.fluid as fluid sentence = fluid.data(name='sentence', shape=[None, 1], dtype='int64', lod_level=1) embedding = fluid.layers.embedding(input=sentence, size=[65536, 32], is_sparse=True) drnn = fluid.layers.DynamicRNN() with drnn.block(): # Set embedding as RNN's input, each time step processes a word from the sentence word = drnn.step_input(embedding) # Initialize memory to a Tensor whose value is 0, shape=[batch_size, 200], # where batch_size is the number of sequences in embedding. memory = drnn.memory(shape=[200]) hidden = fluid.layers.fc(input=[word, memory], size=200, act='relu') # Update memory to hidden drnn.update_memory(ex_mem=memory, new_mem=hidden) # Set hidden as RNN's output drnn.output(hidden) # Get RNN's result rnn_output = drnn() rrz$fluid.layers.DynamicRNN.step_input()Nr?)rwrNTrJrLr|rZdynamic_rnn_max_seq_lenrrFrHrIrMr1rcrbZdynamic_rnn_input_arrayrNrLrOrQr)rr%r _parent_block_r?rrrDr r r rCrerSrr9rrrerrr7)rrr|rrrUrUrVr.sX [   zDynamicRNN.step_inputcCs|dt|dtd|jdurtd|}|jtdt j j j |j d}|jd|g|jgd d |gid t||j|jS) ao This function is used to set x as DynamicRNN's static input. It is optional. - Case 1, set static input with LoD .. code-block:: text # RNN's input is the same as the case listed in step_input # static input, where Si is slice data of shape [1, M] x.lod = [[3, 1, 2]] x.shape = [6, M] x.data = [[S0], [S0], [S0], [S1], [S2], [S2]] # step 0, batch data corresponding to the 3 input sequences out.lod = [[2, 3, 1]] out.shape = [6, M] out.data = [[S2], [S2], [S0], [S0], [S0], [S1]] # step 1, batch data corresponding to the 2 input sequences out.lod = [[2, 3]] out.shape = [5, M] out.data = [[S2], [S2], [S0], [S0], [S0]] # step 2, batch data corresponding to the 1 input sequences out.lod = [[2]] out.shape = [2, M] out.data = [[S2], [S2]] - Case 2, set static input without LoD .. code-block:: text # RNN's input is the same as the case listed in step_input # static input, where Si is slice data of shape [1, M] x.lod = [[]] x.shape = [3, M] x.data = [[S0], [S1], [S2]] # step 0, batch data corresponding to the 3 input sequences out.lod = [[]] out.shape = [3, M] out.data = [[S2], [S0], [S1]] # step 1, batch data corresponding to the 2 input sequences out.lod = [[]] out.shape = [2, M] out.data = [[S2], [S0]] # step 2, batch data corresponding to the 1 input sequences out.lod = [[]] out.shape = [1, M] out.data = [[S2]] Args: x (Variable): The static input LoDTensor which should hold the same number of sequences as RNN's input (the input LoDTensor set by :code:`step_input()` ). If the LoD is None, the input x will be treated as a minibatch with :code:`x.shape[0]` sequences of length 1. Optional data types are: bool, float16, float32, float64, int8, int16, int32, int64, uint8. Returns: Variable: The input LoDTensor after sorted and shrank. If there are :code:`num_sequences` \ sequences in RNN's input LoDTensor whose length is larger than :code:`step_idx` , \ the static input Tensor will be sorted to the same order as RNN's input and \ will only retain data corresponding to those :code:`num_sequences` sequences. \ The data type is the same as input. If :code:`x.lod == None` , the return value is \ a Tensor of shape :math:`\{num\_sequences, x.shape[1], ...\}` , or it will \ be a variable-length LoDTensor. Raises: ValueError: When :code:`static_input()` is called outside :code:`block()` . TypeError: When x is not a Variable. RuntimeError: When :code:`static_input()` is called before :code:`step_input()` . Examples: .. code-block:: python import paddle.fluid as fluid sentence = fluid.data(name='sentence', shape=[None, 32], dtype='float32', lod_level=1) encoder_proj = fluid.data(name='encoder_proj', shape=[None, 32], dtype='float32', lod_level=1) decoder_boot = fluid.data(name='boot', shape=[None, 10], dtype='float32') drnn = fluid.layers.DynamicRNN() with drnn.block(): # Set sentence as RNN's input, each time step processes a word from the sentence current_word = drnn.step_input(sentence) # Set encode_proj as RNN's static input encoder_word = drnn.static_input(encoder_proj) # Initialize memory with boot_memory, which need reorder according to RNN's input sequences memory = drnn.memory(init=decoder_boot, need_reorder=True) fc_1 = fluid.layers.fc(input=encoder_word, size=30) fc_2 = fluid.layers.fc(input=current_word, size=30) decoder_inputs = fc_1 + fc_2 hidden, _, _ = fluid.layers.gru_unit(input=decoder_inputs, hidden=memory, size=30) # Update memory with hidden drnn.update_memory(ex_mem=memory, new_mem=hidden) out = fluid.layers.fc(input=hidden, size=10, bias_attr=True, act='softmax') # Set out as RNN's output drnn.output(out) # Get RNN's result rnn_output = drnn() static_inputrz&fluid.layers.DynamicRNN.static_input()Nz1static_input() must be called after step_input().Z"dynamic_rnn_static_input_reorderedrNr=rOrLrM)rr%r r?rsrrrrDr r r  LOD_TENSORrerSrkr)rrrZ x_reorderedrUrUrVrs$ ~ zDynamicRNN.static_inputccs|jtjkr tdtdgdddd|_d|j_tj|_|j .dVt |jd dd |j D] \}}t ||j|d q1t |j|jd|jd Wdn1sSwYtj|_|jD] }|jt||jd q_dS)a] The function is used to list the operations executed during each time step in RNN. The operation list will be executed :code:`max_sequence_len` times (where :code:`max_sequence_len` is the maximum length of RNN's input sequences). Raises: ValueError: When :code:`block()` is called multi-times. z#rnn.block() can only be invoke oncerrrTrfrerrbFNrT)rrrWr_)rrarbr9)rrF)rr;rrr rreIN_RNNrrr.rr/r1rr9 AFTER_RNNrrHrrRr?)rr mem_arrayZ each_arrayrUrUrVrHs4     zDynamicRNN.blockcOs2|jtjkr tdt|jdkr|jdS|jS)a( This function is used to get the output sequences of DynamicRNN. Args: None Returns: Variable or Variable list: RNN's output sequences. Raises: ValueError: When :code:`__call__()` is called before :code:`block()` . zDOutput of the dynamic RNN can only be visited outside the rnn block.rr)rr;rrr^rHrrUrUrVrms  zDynamicRNN.__call__rFrc Cs|d||durt|dttfd|durt|dtd|}|}|dkrV|jdur4td|j t dt j jj|jd }|jd |g|jgd d |gid |}|j t dt j jj|jd } |jd||jdd | id t| |jd} t| |j|jd} | |j| j<| St|jdkrtd|}|j t d|d}|jd\} }|j t d|d} |jd| g|jgdd | gid |jdd| gid |gidg|t||jdd|j|dS)a Create a memory Variable for DynamicRNN to deliver data cross time steps. It can be initialized by an existing Tensor or a constant Tensor of given dtype and shape. Args: init (Variable, optional): LoDTensor used to initialize the memory. If init is not None, it should hold the same number of sequences as RNN's input (the input LoDTensor set by :code:`step_input()` ) and the memory will be initialized to it. If init's LoD is None, it will be treated as a minibatch with :code:`init.shape[0]` sequences of length 1. The default value is None. shape (list|tuple, optional): When init is None, it is used to specify the memory's shape. Note that the shape does not include the batch_size. If setting shape to :math:`\{D_1, D_2, ...\}` , the shape of memory Tensor will be :math:`\{batch\_size, D_1, D_2, ...\}` , where batch_size is determined by RNN's input sequences. The default value is None. value (float, optional): When init is None, it is used as initialized value of memory. The default value is 0.0. need_reorder (bool, optional): When init is not None, it determines whether the memory needs to reorder like the RNN's input sequences. It should be set to True when the initialized memory depends on the order of input samples. The default value is False. dtype (str|numpy.dtype, optional): When init is None, it is used to set the data type of memory. The default value is "float32". Optional data types are: "float32", "float64", "int32", "int64". Returns: Variable: The memory LoDTensor after shrank. If there are :code:`num_sequences` \ sequences in RNN's input LoDTensor whose length is larger than :code:`step_idx` , \ the memory Tensor also need to be shrank and will only retain data \ corresponding to those :code:`num_sequences` sequences. Raises: ValueError: When :code:`memory()` is called outside :code:`block()` . TypeError: When init is set and is not a Variable. ValueError: When :code:`memory()` is called before :code:`step_input()` . Examples: .. code-block:: python import paddle.fluid as fluid sentence = fluid.data(name='sentence', shape=[None, 32], dtype='float32', lod_level=1) boot_memory = fluid.data(name='boot', shape=[None, 10], dtype='float32') drnn = fluid.layers.DynamicRNN() with drnn.block(): # Set sentence as RNN's input, each time step processes a word from the sentence word = drnn.step_input(sentence) # Initialize memory with boot_memory, which need reorder according to RNN's input sequences memory = drnn.memory(init=boot_memory, need_reorder=True) hidden = fluid.layers.fc(input=[word, memory], size=10, act='tanh') # Update memory with hidden drnn.update_memory(ex_mem=memory, new_mem=hidden) # Set hidden as RNN's output drnn.output(hidden) # Get RNN's result rnn_output = drnn() Examples: .. code-block:: python import paddle.fluid as fluid sentence = fluid.data(name='sentence', shape=[None, 32], dtype='float32', lod_level=1) drnn = fluid.layers.DynamicRNN() with drnn.block(): # Set sentence as RNN's input, each time step processes a word from the sentence word = drnn.step_input(sentence) # Initialize memory to a Tensor whose value is 0, shape=[batch_size, 10], # where batch_size is the number of sequences in sentence. memory = drnn.memory(shape=[10], dtype='float32', value=0) hidden = fluid.layers.fc(input=[word, memory], size=10, act='tanh') # Update memory with hidden drnn.update_memory(ex_mem=memory, new_mem=hidden) # Set hidden as RNN's output drnn.output(hidden) # Get RNN's result rnn_output = drnn() rNrfz fluid.layers.DynamicRNN.memory()rTzpIf set need_reorder to True, make sure step_input be invoked before memory(init=init, need_reordered=True, ...).Zdynamic_rnn_mem_init_reorderedrNr=rOrLrMZdynamic_rnn_mem_arrayr[r\r)rrrFrz@step_input should be invoked before memory(shape=..., value=...)Zmem_initrin0rjrrrX)rfrrerr)r_init_zero_idx_r%rQrRr rr?rrrrDr r r rrerSrrr7rrkrrwr^rrVr) rrrfrZ need_reorderrerZ init_tensorZinit_reorderedrZretvZarrrrUrUrVrs ]       zDynamicRNN.memorycCsl|dt|dtdt|dtd|j|jd}|dur#td|jdur,td|j ||fdS)a Update the memory which need to be delivered across time steps. Args: ex_mem (Variable): The memory data of previous time step. new_mem (Variable): The new memory data produced in current time step. The shape and data type of ex_mem and new_mem should be the same. Returns: None Raises: ValueError: When :code:`update_memory()` is called outside :code:`block()` . TypeError: When :code:`ex_mem` or :code:`new_mem` is not a Variable. ValueError: When :code:`ex_mem` is defined by :code:`memory()` . ValueError: When :code:`update_memory()` is called before :code:`step_input()` . rex_memz'fluid.layers.DynamicRNN.update_memory()rNz)Please invoke memory before update_memoryz-Please invoke step_input before update_memory) rr%r rgetrwrr?rr)rrrrrUrUrVr5s&  zDynamicRNN.update_memoryc Gsz|d|}|D]/}t|dtd|jtd|jj d|j gt j j j |jd}t||j|d|j|q dS) ab This function is used to set :code:`outputs` as RNN's output. Args: *outputs (Variable ...): The output Tensor. DynamicRNN can mark multiple Variables as its output. Returns: None Raises: ValueError: When :code:`output()` is called outside :code:`block()` . rrHzfluid.layers.DynamicRNN.outputrrrNr_N)rrr%r rrrrrTrwr r r rrer/rrr)rrHrrZ outside_arrayrUrUrVr]s zDynamicRNN.outputc Cs^|jdur-|}|jtddd|_|jdid|jgidg|jjtddd d dSdS) Nrrrr rLrrTrr)rrrrrDrSrerV)rrrUrUrVr{s    zDynamicRNN._init_zero_idx_cCrrrrrUrUrVrs    zDynamicRNN._parent_block_cCr)Nz){0} can only be invoked inside rnn block.)rr;rrrurrUrUrVrs z DynamicRNN._assert_in_rnn_block_rmr)NNrFr)rrrrrrrrrrrrrrrrrrrrUrUrUrVr; s2C    $ 0( r;c CsTtdit}dd}||||\}}|}|D] \}} tt|| |d}q|} | S)a :api_attr: Static Graph This operator is like a C++ switch/case statement. Args: branch_index(Tensor): A Tensor with shape [1] to specify which branch to execute. The data type is ``int32``, ``int64`` or ``uint8``. branch_fns(dict|list|tuple): If it's a list or tuple, the elements in it could be pairs of (int, callable) or simple callables whose actual index will be used as the index of callable. If it's a dict, its key is a python integer and the value is a callable. All callables return the same structure of Tensors. default(callable, optional): Callable that returns a structure of Tensors. name(str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`. Returns: Tensor|list(Tensor): Tensors returned by the callable specified by ``branch_index`` in ``branch_fns``, or Tensors returned by ``default`` if ``default`` is not None and no index matches in ``branch_fns``, or Tensors returned by the callable with the max index in ``branch_fns`` if ``default`` is None and no index matches in ``branch_fns``. Raises: TypeError: If the type of ``branch_index`` is not Tensor. TypeError: If the data type of ``branch_index`` is not ``int32``, ``int64`` or ``uint8``. TypeError: If the type of ``branch_fns`` is not dict, list or tuple. TypeError: If the elements of ``branch_fns`` is not 2-tuple. TypeError: If the first element of 2-tuple in ``branch_fns`` is not integer. ValueError: If the first element of 2-tuple in ``branch_fns`` is not unique. TypeError: If the second element of 2-tuple in ``branch_fns`` is not callable. TypeError: If ``default`` is not None but it is not callable. Examples: .. code-block:: python import paddle paddle.enable_static() def fn_1(): return paddle.full(shape=[1, 2], dtype='float32', fill_value=1) def fn_2(): return paddle.full(shape=[2, 2], dtype='int32', fill_value=2) def fn_3(): return paddle.full(shape=[3], dtype='int32', fill_value=3) main_program = paddle.static.default_startup_program() startup_program = paddle.static.default_main_program() with paddle.static.program_guard(main_program, startup_program): index_1 = paddle.full(shape=[1], dtype='int32', fill_value=1) index_2 = paddle.full(shape=[1], dtype='int32', fill_value=2) out_1 = paddle.static.nn.switch_case( branch_index=index_1, branch_fns={1: fn_1, 2: fn_2}, default=fn_3) out_2 = paddle.static.nn.switch_case( branch_index=index_2, branch_fns=[(1, fn_1), (2, fn_2)], default=fn_3) # Argument default is None and no index matches. fn_3 will be called because of the max index 7. out_3 = paddle.static.nn.switch_case( branch_index=index_2, branch_fns=[(0, fn_1), (4, fn_2), (7, fn_3)]) exe = paddle.static.Executor(paddle.CPUPlace()) res_1, res_2, res_3 = exe.run(main_program, fetch_list=[out_1, out_2, out_3]) print(res_1) # [[1. 1.]] print(res_2) # [[2 2] [2 2]] print(res_3) # [3 3 3] rBc Sst|dgddt|jdkrt|d}t|dtttfdt|tr(| n|}t dd|Dr9tt |n|}g}|D]a}t|tsRt t dddtt|t|d krht t d ddd tt|d |\}}t|ts}t t d ddtt|||vrtd|||t|st t d|dddt|q?|durt|dd}t|dd}nt|st dg}|D]\}}tdgd|d} t|| } || |fq||fS)N branch_index)Zuint8rGrrBr branch_fnscss|]}t|VqdSrm)r5)rrrUrUrV sz3switch_case.._check_args..rrrrrzThe key's typezHThe key in 'branch_fns' must be unique, but '{}' appears more than once.zThe type of function for key {}r5rXrr)rfrer)r$r#rer r%rQrRrfrnitemsallrBrvrrNr^rrrrurr5sortedr r5) rrrZ keys_of_fnsZ index_fn_pairkeyrrindexZ new_indexrrUrUrV _check_argss         z switch_case.._check_argsrN)rB)rrPr"r9) rrrrwrTrrrrrrrUrUrVrBsF_ rBcCsvt|dtdt|dtd|jtjjjkrtdtd it }|j |j d}|j d|g|gdd|gid|S) a ${comment} Args: x(${x_type}): ${x_comment}. rank_table(${rank_table_type}): ${rank_table_comment}. Returns: out(${out_type}): ${out_comment}. Examples: .. code-block:: python import paddle.fluid as fluid data_desc = (['input', [9], 0], ['ref', [5], 1]) data = fluid.layers.data(name=data_desc[0][0], shape=data_desc[0][1]) rank_data = fluid.layers.data(name=data_desc[1][0], shape=data_desc[1][1]) table = fluid.layers.control_flow.lod_rank_table(rank_data) new_data = fluid.layers.reorder_lod_tensor_by_rank( x=data, rank_table=table) rr=rJz0The type of rank_table should be LOD_RANK_TABLE.r~rOrLrMN)r=) r%r rNr r r rCrvrrPrrerS)rrJrTrirUrUrVr=Ls r=cCstrt|Strt|St|dgddt|dttdfdt d it }|j dd}d|_ |j dd |gid |gid |S) a= Test whether a Tensor is empty. Args: x (Tensor): The Tensor to be tested. name (str, optional): The default value is ``None`` . Normally users don't have to set this parameter. For more information, please refer to :ref:`api_guide_Name` . Returns: Tensor: A bool scalar Tensor. True if 'x' is an empty Tensor. Examples: .. code-block:: python import paddle input = paddle.rand(shape=[4, 32, 32], dtype='float32') res = paddle.is_empty(x=input) print("res:", res) # ('res:', Tensor: eager_tmp_1 # - place: CPUPlace # - shape: [1] # - layout: NCHW # - dtype: bool # - data: [0]) rrUr@rwNrr~TrJrLrM)r@)rr*r@rr+r$r%rrNrrPrrerS)rrwrTr9rUrUrVr@ws    r@r) rXNrTTTTTr)NrNr.)rTTrm)NNN)NN)NNNN)q __future__rwrapped_decoratorrZlayer_function_generatorrrZtensorrr r rr Z frameworkr r rrrrrrrrnnrrrutilsrrrrrrrrr r6r_r  functoolsr!r"Z data_feederr#r$r%r&r(r}rr)Zpaddler*r+__all__rDrbrcr{r}rr>r?objectrrrr<rr r,rrV integer_typesrtr2rCr7r?rHrLrRr.r/r0r1r2r3r4r5r6r7rkr8rlrmrr9rrrrrrAr-rr:r;rBr=r@rUrUrUrVs   $ ,   $ N 9C aHn>  +n &E = 3 ) d: 9 7 9  8 50Z'E-    A %? K1 *