o + ic@sbddlmZddlZddlmZmZmZddlmZddl Z ddl m Z ddl m Z ddl mZddlmZmZmZmZmZdd lmZmZmZmZdd lmZmZmZmZmZdd l m!Z!dd l"m#Z#dd l$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,dUddZ-GdddZ.Gddde.Z/GdddZ0GdddZ1Gddde.Z2ddZ3GdddZ4e5e6e7fZ8dd Z9d!d"Z:Gd#d$d$Z;dVd&d'ZdWd,d-Z?dWd.d/Z@d0d1ZAd2d3ZBd4d5ZCd6d7ZDGd8d9d9ZEdXd:d;ZFdd?ZHd@dAZIdBdCZJdDdEZKdFdGZLdHdIZMdJdKZNdLdMZOe N   O O O O O PdYdQdRZPGdSdTdTZQdS)Z) annotationsN)cached_propertypartialreduce)Any)_C_ops)core)_infer_var_data_type_shape_)OperatorProgramVariable in_pir_mode static_only)build_assert_op build_if_opbuild_while_opcf_yield) LayerHelper check_typecheck_variable_and_dtype convert_dtypein_dygraph_mode) use_pir_api)_PADDLE_PIR_DTYPE_2_NUMPY_DTYPE)assert_same_structurecopy_mutable_varsflattenhold_mutable_vars is_sequence map_structurepack_sequence_as to_sequencec Cst|ddgdt|dtttdfdt|dtdt|dttdfdtr;|dur/gnt|}t|||}dS|r?|nd|j }t |fit }|j d ||durWgnt|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 (Tensor): 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. Examples: .. code-block:: python >>> import paddle >>> from paddle.static.nn.control_flow import Assert >>> paddle.enable_static() >>> x = paddle.full([2, 3], 2.0, 'float32') >>> condition = paddle.max(x) < 1.0 # False >>> Assert(condition, [x], 10, "example_assert_layer") >>> exe = paddle.static.Executor() >>> try: ... exe.run(paddle.static.default_main_program()) ... # Print x and throws ValueError ... # 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 ValueError as e: ... print("Assert Exception Example") condboolzstatic.nn.control_flow.AssertdataN summarizenameZassert_assert)CondZData)typeinputsattrs) rrlisttupler*intstrr rr'rlocals append_op) r#r%r&r'Z input_dataZ assert_opZ layer_namehelperopr5i/home/app/PaddleOCR-VL-test/.venv_paddleocr/lib/python3.10/site-packages/paddle/static/nn/control_flow.pyAssert;s(1  r7c@(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) isinstancer TypeError main_program)selfr<r5r5r6__init__s  zBlockGuard.__init__cCs|jdSN)r<Z _create_blockr=r5r5r6 __enter__szBlockGuard.__enter__cCs|j|dur dSdSNFT)r<Z _rollbackr=exc_typeexc_valexc_tbr5r5r6__exit__s zBlockGuard.__exit__N)__name__ __module__ __qualname____doc__r>rArGr5r5r5r6r9s  r9cs4eZdZfddZfddZfddZZS) WhileGuardcs2t|ts tdtst|jj||_dS)NzWhileGuard takes a while op) r:Whiler;r superr>r3r<while_opr=rO __class__r5r6r>s  zWhileGuard.__init__cs8trt|jjg|_|jStj|j_ t Sr?) r rrOcond_varbodyblockrArMIN_WHILE_BLOCKstatusrNr@rQr5r6rAs    zWhileGuard.__enter__csTtrt|jjg|j|||S|durdStj|j_|j t |||SNF) r rrOrSrUrGrMAFTER_WHILE_BLOCKrW _completerNrCrQr5r6rGs  zWhileGuard.__exit__)rHrIrJr>rArG __classcell__r5r5rQr6rLs  rLc@r8) Ifa **If** If is an operator that bind two blocks (true_block and false_block) to a specific condition, According to the condition, the corresponding block will be executed. Args: cond (Value): A value whose data type is bool controlling which block is executed. Examples: .. code-block:: python >>> import paddle >>> from paddle.static.nn.control_flow import ConditionalBlock >>> label = paddle.rand([1]) >>> limit = paddle.ones([1]) * 0.5 >>> cond = paddle.less_than(x=label, y=limit) >>> if_op = If(cond) >>> with if_op.true_block(): ... pass >>> with if_op.false_block(): ... pass cCs`t|ts#t|ddgdtdd|jddkr#tdt|jdt||_|j|_ dS) Nr#r$z static.nn.IfcS||Sr?r5abr5r5r6zIf.__init__..4condition expected shape as [1], but given shape as .) r:r-rrshaper;rif_opr#rS)r=r#r5r5r6r>s  z If.__init__cC |jSr?)rg true_blockr@r5r5r6ri z If.true_blockcCrhr?)rg false_blockr@r5r5r6rkrjzIf.false_blockN)rHrIrJrKr>rirkr5r5r5r6r\s  r\c@s:eZdZdZdddZddZdd Zd d Zd d ZdS)ConditionalBlocka **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 >>> from paddle.static.nn.control_flow import ConditionalBlock >>> label = paddle.rand([1]) >>> limit = paddle.ones([1]) * 0.5 >>> cond = paddle.less_than(x=label, y=limit) >>> image = paddle.ones([1]) >>> true_image = image[cond] >>> true_cond = ConditionalBlock([true_image]) >>> with true_cond.block(): ... pass >>> with false_cond.block(): ... pass FNcCsX||_tr|rt|dkrtddS|D] }t|dtdq||_td|d|_dS)NrczSFor ConditionalBlock Api, Only support one input while is_scalar_condition is Trueinputrlconditional_blockr') r+r lenr;rr is_scalar_conditionrr3)r=r+rqr'Z each_inputr5r5r6r>szConditionalBlock.__init__cCstr t|jSt|Sr?)r r\r+riConditionalBlockGuardr@r5r5r6rUszConditionalBlock.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) Nr3cg|]}|qSr5Z_var_recursive).0Z each_name parent_blockr5r6 #s z-ConditionalBlock.complete..r*rn)r)Input)OutZScope) sub_blockrqr*r+outputsr,)r3r< current_blockrU parent_idxsetget_inputs_outputs_in_block_find_var_recursiveappend create_varrVarDescVarType STEP_SCOPESr2r+rq"need_append_conditional_block_gradappend_conditional_block_grad) r= inside_block intermediateparams param_listZout_listinner_out_name inner_var step_scopeconditional_block_opr5rwr6completesD       zConditionalBlock.completecCs|j}|j}|dko ||kS)N)backward_block_idxidx)r=rgrad_sub_block_idxZinside_block_idxr5r5r6rBsz3ConditionalBlock.need_append_conditional_block_gradcCs|j}|jj|}t}t}|jD]3}t|tsJ|jD]} | | D] } | |vr1| | q&q|j D]} | | D]} | | q=q6qg} |D]}| |}|rZ| |jqKt|jt|jg\}}tj}tjjj}|j}||d||||d| |ddd| Dt}|D]#}|j|s|tkrq|j || |||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` belongs to. inside_block (Block): The sub block of `conditional_block_op`. conditional_block_op (Operator): The forward op conditional_block. rr{z Input@GRADcSsg|]}|dqS)z@GRADr5)rvparamr5r5r6ryzBConditionalBlock.append_conditional_block_grad..N)%rr3r<rUropsr:r input_namesrmadd output_namesoutputrrr'rZget_grad_op_descZdescZop_proto_and_checker_makerZkOpRoleAttrNameZOpRoleZBackwardr2Z copy_fromZ _set_attrZ set_inputZ set_outputZoutput_arg_namesZhas_var_recursiveencodeZempty_var_namevarZinfer_var_typeZ infer_shaper Z_sync_with_cpp)r=rxrrrZgrad_sub_blockrrZeach_opiname in_var_nameoname out_var_namerZinner_input_namerZ grad_op_descZop_grad_to_varZop_role_attr_nameZbackwardZ new_op_descZnew_varsZ grad_var_nameargr5r5r6rLsj                   z.ConditionalBlock.append_conditional_block_gradFN) rHrIrJrKr>rUrrrr5r5r5r6rls , rlcs8eZdZdZfddZfddZfddZZS)rra? 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|dtdt|jj||_dS)NrUrr)rrlrNr>r3r<rU)r=rUrQr5r6r>s zConditionalBlockGuard.__init__cs tSr?)rNrAr@rQr5r6rArjzConditionalBlockGuard.__enter__cs|jt|||Sr?)rUrrNrGrCrQr5r6rGs zConditionalBlockGuard.__exit__)rHrIrJrKr>rArGr[r5r5rQr6rrs   rrcCsdd}|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_seedTFrz)r4var_nameZIGNORE_VAR_NAMESZ var_namesr'r5r5r6is_ignore_varss   z3get_inputs_outputs_in_block..is_ignore_varsN)rr:r rrmrrrrr<rUrrZhas_varrr*rrrDENSE_TENSOR_ARRAY)rZ inner_inputs inner_outputsr3rr4rrrrZremove_inner_inputsrxparent_block_varZcurrent_block_varr5r5r6rsD          rc@s6eZdZdZdZdZdZd ddZd d Zd d Z dS)rMa :api_attr: Static Graph while loop control flow. Repeat while body until cond is False. Note: A new OP :ref:`api_paddle_static_nn_while_loop` is highly recommended instead of ``While`` if the shape of parameter ``cond`` is [1]. OP :ref:`api_paddle_static_nn_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: .. code-block:: python :name: example-1 >>> import paddle >>> import numpy as np >>> paddle.enable_static() >>> i = paddle.full(shape=[1], dtype='int64', fill_value=0) # loop counter >>> loop_len = paddle.full(shape=[1],dtype='int64', fill_value=10) # loop length >>> cond = paddle.less_than(x=i, y=loop_len) >>> while_op = paddle.static.nn.control_flow.While(cond=cond) >>> with while_op.block(): ... i = paddle.increment(x=i, value=1) ... paddle.assign(paddle.less_than(x=i, y=loop_len), output=cond) >>> exe = paddle.static.Executor(paddle.CPUPlace()) >>> exe.run(paddle.static.default_startup_program()) >>> res = exe.run(paddle.static.default_main_program(), feed={}, fetch_list=[i]) >>> print(res) [array([10], dtype=int64)] .. code-block:: python :name: example-2 >>> import paddle >>> import numpy as np >>> paddle.enable_static() >>> i = paddle.full(shape=[1], dtype='int64', fill_value=0) >>> loop_len = paddle.full(shape=[1], dtype='int64', fill_value=10) >>> one = paddle.full(shape=[1], dtype='float32', fill_value=1) >>> data = paddle.static.data(name='data', shape=[1], dtype='float32') >>> sums = paddle.full(shape=[1], dtype='float32', fill_value=0) # Define the variable to be obtained outside of While, which name should be different from the variable inside the While to be obtained >>> cond = paddle.less_than(x=i, y=loop_len) >>> while_op = paddle.static.nn.control_flow.While(cond=cond) >>> with while_op.block(): ... sums_tensor = paddle.add(x=data, y=data) ... paddle.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 = paddle.increment(x=i, value=1) ... data = paddle.add(x=data, y=one) ... paddle.assign(paddle.less_than(x=i, y=loop_len), output=cond) >>> feed_data = np.ones(1).astype('float32') >>> exe = paddle.static.Executor(paddle.CPUPlace()) >>> exe.run(paddle.static.default_startup_program()) >>> res = exe.run(paddle.static.default_main_program(), feed={'data': feed_data}, fetch_list=sums) >>> print(res[0]) # Because the data in While does not update the value outside the While, the value of sums is [2.] after the loop [2.] rrcFNcCsl||_t|ddgdtdd|jddkr!tdt|jdtr&dStj|_ t d |d |_ ||_ dS) Nr#r$zstatic.nn.WhilecSr]r?r5r^r5r5r6raDrbz While.__init__..rcrdrewhilero) rSrrrfr;r-r rMBEFORE_WHILE_BLOCKrWrr3is_test)r=r#rr'r5r5r6r>As zWhile.__init__cCst|Sr?)rLr@r5r5r6rUNsz While.blockc s|jj}|}||j|jjh}t}t||||j\}}g}|D]} |}|r4| |q&|dd|DO}||jjh8}j t j jjd}jdfdd|D|jgd||gd||jd d dS) NcSsh|]}|jqSr5ro)rvxr5r5r6 dz"While._complete..rzrcrtr5ru)rvZx_namerwr5r6rypsz#While._complete..)X Condition)r|Z StepScopes)r}rr~)r3r<rrUrrSr'rrrrrrrrrr2r) r=r<Z while_blockrZ x_name_listZout_varsrrrr5rwr6rZQs>        zWhile._completer) rHrIrJrKrrVrYr>rUrZr5r5r5r6rMsM  rMcCsdd}t|ttjjfs#t|trt|trt||dS|}dS|jtj j j krK|j j }| |j}|rG||jsIt||dSdSdSt|trht|trh|||rhtd|jd|jdtjjt||WddS1swYdS)zv Assign input to output, but skip the process of copying DenseTensorArray unless it's created in while_block. cSsNt|jt|jkr dSt|j|jD]\}}||kr$d||fvr$dSqdS)NTrF)rprfzip)Zx_varZy_varZx_dimZy_dimr5r5r6has_shape_diffsz4assign_skip_lod_tensor_array..has_shape_diffNz>In dy2static mode, we attempt to assign a variable with shape z into a variable with shapez, which is not always right.)r:r reagerZTensorsupport_ret_buildin_typepaddleassignr*rrrrUprogramrrrr'warningswarnrfbaseZ frameworkZ_stride_in_no_check_dy2st_diff)rmrrr<rxr5r5r6assign_skip_lod_tensor_array~s:  "rcCsl|j}tjg|jdd}|}||||||_| || |}||_||fS)NrrfdtypeZ fill_value) stop_gradientrfullrget_defining_opZ move_beforeZ as_operationset_typer*Zadd_extra_inputrTZadd_arg)rOvaluer fake_valueZ fake_value_op block_argr5r5r6#create_fake_value_for_undefined_vars rc@sfeZdZdddZeddZeddZedd Zed d Zd d Z ddZ ddZ ddZ dS)LoopVarNcCs||_||_||_d|_dSrX)curr_varnext_varr_is_fake)r=rrrr5r5r6r>s zLoopVar.__init__cCt|jtjjSr?)r:rrpirValuer@r5r5r6is_variable_curr_varzLoopVar.is_variable_curr_varcCst|jtjjjjSr?)r:rrjit dy2staticutils UndefinedVarr@r5r5r6is_undefined_curr_varszLoopVar.is_undefined_curr_varcCrr?)r:rrrrr@r5r5r6is_variable_next_varrzLoopVar.is_variable_next_varcC|jSr?)rr@r5r5r6is_fakeszLoopVar.is_fakecC ||_dSr?)r)r=rr5r5r6bind_block_argrjzLoopVar.bind_block_argcCrr?r)r=rr5r5r6 bind_next_varrjzLoopVar.bind_next_varcsVjsJdd}t|tjjr||St|r#tfdd|Stj|j S)NcSs$t||\}}t|||}d|_|S)NT)rrr)rOrrrloop_varr5r5r6create_loop_var_likes  z>LoopVar.infer_type_with_next_var..create_loop_var_likecs |Sr?)infer_type_with_next_varrrPr5r6ra z2LoopVar.infer_type_with_next_var..) rr:rrrrrrrr)r=rrOrr5rPr6rs   z LoopVar.infer_type_with_next_varcCsd|jd|jd|jdS)NzLoopVar(curr_var=z , next_var=z , block_arg=))rrrr@r5r5r6__repr__szLoopVar.__repr__NN) rHrIrJr>propertyrrrrrrrrr5r5r5r6rs      rFc st|stdt|stdt|dttfdt|dkr#td||}t|ddgdtd d |j d d krEtd t|j d t radd}t t |}ddt |D}t|dd|D}t|t|ksvJt||D] \} } | | q}t dd |} || } t| ttfs| g} fdd} z t|| ddd dWnty}ztd|d}~ww| || }ddlmfdd}tj |||t dd |}d|_t ||ttd d t |ttd!d t |}t|gd"d#|DWdn 1swY}t|t|ks.Jt||D]\} }|| _q3t |D]} | jrX| j !rX| j "}|#$|q@t d$d |St%r|&}|r||}t|ttfs{|g}t|t|krtd%||&}t t'|||sl|St(|||}t)|}|*W|rt+|}||}n||}t|ttfs|g}zt,||}t||dd&Wnty}ztd|d}~ww||}t t'||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 DenseTensorArrays 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 DenseTensorArrays 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 DenseTensorArrays 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], dtype=int64)] z%cond in while_loop should be callablez%body in while_loop should be callable loop_varszstatic.nn.while_looprz+loop_vars in while_loop should not be emptyzvar of cond returnedr$cSr]r?r5r^r5r5r6ra0rbzwhile_loop..rczLthe shape of the variable returned by cond should be [1],but given shape as recSsdt}|j}tjjtjjg}||vrdS|jsdS|jj|j jkr0t |j |jj}||_ dSdSr?) r_get_amp_attrs _amp_levelAmpLevelO1O2rrrrrcast)r amp_attrs amp_levelapply_amp_level_listZ cast_out_varr5r5r6cast_value_in_amp8s  z%while_loop..cast_value_in_ampcSsg|]}|jr|qSr5)r)rvrr5r5r6ryJs zwhile_loop..cSsg|]}|jqSr5)rrvrr5r5r6ryPrcSs|jr|jS|jSr?)rrrrr5r5r6raYcs:fddg}t||D] \}}|||q|S)Ncs<t|r t||S|jr||}|S|||}|Sr?)rrrrr)rrZ new_loop_var)!infer_loop_var_type_with_next_varrOr5r6rds zbwhile_loop..infer_loop_vars_type_with_next_vars..infer_loop_var_type_with_next_var)rr)r next_vars new_loop_varsrr)rO)rr6#infer_loop_vars_type_with_next_varscsz7while_loop..infer_loop_vars_type_with_next_varsFcSs0t|tot|jtjjjjpt|tjjjjSr?)r:rrrrrrrrr5r5r6ras ) check_typesZskip_ifzUbody in while_loop should return the same arity (length and structure) as loop_vars: Nto_static_variablecsD|jsdSt|jtjjst|jtttfst d|j|_dS)NzThe loop var in the while op is variable, but the corresponding yielded var is not variable, and it is not a constant of type bool, int, or float.) rr:rrrrr$floatr/ ValueError)rrr5r6check_next_vars z"while_loop..check_next_varcSrr?rrr5r5r6raTcSs|jo|j Sr?rrrr5r5r6racSs |jo|jSr?rrr5r5r6rarcss|]}|jVqdSr?rrr5r5r6 szwhile_loop..cSrr?rrr5r5r6rarz]body in while_loop should return the same arity (length and structure) and types as loop_varsr).callabler;rr-r.rprrrrfr rrrrrTargsrrZ_cloner:r&paddle.jit.dy2static.convert_operatorsrrrrfilterrZoptimize_updaterrrZ use_emptyrZget_parent_blockZ remove_opritemrrMrrUr_deal_with_undefined_varr)r#rTrrr'Zpre_condrZvariable_loop_varsZ cur_blockrrrrrerZ next_condZoptimized_resultsresultZfake_value_def_opZnow_cond output_varsZwhile_loop_blockZhas_mutable_vars_in_looprr5)rrOr6 while_loops0             h           rcs|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)rcreate_undefined_variablecs@t|tgtRs |durSt|r tfdd|SdS)NcsSr?r5rrr5r6rarzC_deal_with_undefined_var..create_var_like..)r:r rrr)o_varrr5r6create_var_likesz1_deal_with_undefined_var..create_var_likez+The length of loop_vars should be the same.N)paddle.jit.dy2static.utilsrrrprrr:r)rrrrresultsrZl_varr5rr6r s   r c Cs&|d|d|d|d|d }|S)Nz of 'z' in z must be z, but received: rer5)whatZarg_nameZop_nameZ right_valueZ error_value error_messager5r5r6_error_messagesrcCsFdd}|||\}}|}t|D] \}}tt|||d}q|}|S)a :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 whose numel should be 1 (shape [] or 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, res_2) [[1. 1.]] [3 3 3] c Sst|dttfd|D]=}t|tsttdddtt|t|dkr4ttddddtt|d|\}}t |dd gd t |sHtd q |d urct|d }||d }|d |}||fSt |sktd||fS)zg Check arguments pred_fn_pairs and default. Return canonical pre_fn_pairs and default. pred_fn_pairscaseThe elements' typerThe tuple's size2-tuplepredr$zpaddle.static.nn.casez5The fn of pred_fn_pairs in Op(case) must be callable.Nrc)The default in Op(case) must be callable.) rr-r.r:r;rr*rpr0rr)rdefaultZpred_fnrfnZ default_indexr5r5r6_case_check_argsgsN       zcase.._case_check_argsrtrue_fnfalse_fn)reversedrr#)rr!r'r#r&rr%final_fnr5r5r6r&sA/rc 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 whose numel should be 1 (shape [] or 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) >>> startup_program = paddle.static.default_startup_program() >>> main_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]) ... # Variable: fill_constant_1.tmp_0 ... # - message: The content of input layer: ... # - lod: {} ... # - place: Place(cpu) ... # - shape: [2, 3] ... # - layout: NCHW ... # - dtype: int64 ... # - data: [3 3 3 3 3 3] >>> print(res_1) [[1. 1.]] >>> print(res_2) [[2 2] [2 2]] >>> print(res_3) [3 3 3] switch_casec Sst|dgddt|jdkrt|d}t|dtttfdt |tr)| n|}t dd|Dr:tt |n|}g}|D]b}t |tsSt td ddtt|t|d krit td ddd tt|d |\}}t |ts~t tdddtt|||vrtd|d||t|st td|dddt|q@|durt|dd}t|dd}nt|st dg}|D]\}}tjdgd|d} t|| } || |fq||fS)N branch_index)Zuint8int32int64zstatic.nn.switch_caser, branch_fnsr)css|]}t|VqdSr?)r)rvr"r5r5r6r z3switch_case.._check_args..rrrrrzThe key's typez-The key in 'branch_fns' must be unique, but 'z' appears more than once.zThe type of function for key rrrcr r)rrrrrrr-r.dictr:itemsall enumerater;rr*rpr0r/rrrsortedrequal) r*r-r!Z keys_of_fnsZ index_fn_pairkeyr"rindexZ new_indexrr5r5r6 _check_argss          z switch_case.._check_argsr$N)r))rr1rr#) r*r-r!r'r3r7rr&rr%r(r5r5r6r)sT\ r)cGsjddtt|dD}t|D]!\}}t|D]\}}||r*|||nq|d|q|S)NcSg|]}gqSr5r5rv_r5r5r6ry]z0get_indices_by_discriminator..rcrrangerpr2r) containerZdiscriminatorsbucketsrr ir#r5r5r6get_indices_by_discriminator\srAcGsXddtt|D}t|D]\}}t|D]\}}||vr(|||nqq|S)NcSr8r5r5r9r5r5r6ryir;z%select_by_indices..r<)r>Z index_groupsr?rr r@indicesr5r5r6select_by_indiceshsrCcGsdtdd|d}ddt|D}|D]\}}t|t|ks!Jt||D]\}}|||<q&q|S)NcSs|t|dSNr)rp)accpairr5r5r6ratr;z7create_container_by_items_and_indices..rcSg|]}dqSr?r5r9r5r5r6ryvr;z9create_container_by_items_and_indices..)rr=rpr)Zitems_indices_pairs total_lengthr>Zpartial_containerrBrr r5r5r6%create_container_by_items_and_indicesrs   rIcsfdd}|S)Ncs8|i|WdS1swYdSr?r5)rkwargsrUr"r5r6new_fns $zrun_with_block..new_fnr5)r"rUrLr5rKr6run_with_block~srMc@sxeZdZddZeddZeddZeddZed d Z ed d Z d dZ ddZ e ddZe ddZdS)OutputSelectorcCsJ||_||_||_||_t||_t||jksJt||jks#JdSr?)rg true_output false_outputnamesrpZ num_output)r=rgflattened_true_outputflattened_false_outputrQr5r5r6r>s zOutputSelector.__init__cCsg}g}t|j|j|jD]3\}}}t||jjf||jjfg|\}}t ||jjf||jjfg|\}}| || |q ||fSr?) rrOrPrQrNconstant_to_variable_promotionrgrirkprecision_promotionr)r=unified_true_outputunified_false_outputtrue_out false_outr'r5r5r6unified_outputs.       zOutputSelector.unified_outputcC |jdSrDrZr@r5r5r6rV z"OutputSelector.unified_true_outputcCr[)Nrcr\r@r5r5r6rWr]z#OutputSelector.unified_false_outputcCs<t|jdd\}}t|jdd\}}||ksJd|S)NcSt|tjjSr?r:rrrrr5r5r6rarz1OutputSelector.variable_indices..cSr^r?r_rr5r5r6rarz?true_variable_indices and false_variable_indices should be same)rArVrW)r=Ztrue_variable_indicesr:Zfalse_variable_indicesr5r5r6variable_indicess zOutputSelector.variable_indicescsfddttjDS)Ncsg|] }|jvr|qSr5)r`rvr@r@r5r6rys  z3OutputSelector.constant_indices..)r=rprOr@r5r@r6constant_indicess  zOutputSelector.constant_indicescCs(t|j|j\}t|j|j\}||fSr?)rCrVr`rW)r=variable_true_outputvariable_false_outputr5r5r6get_variable_outputssz#OutputSelector.get_variable_outputscCs*t|j|j\}t||jf||jf}|Sr?)rCrVrbrIr`)r=variable_resultsZconstant_outputrestored_outputr5r5r6#restore_outputs_by_variable_resultssz2OutputSelector.restore_outputs_by_variable_resultsc sddlmddlmtttft|\}dd}dd}dd td d Dr.Std d Dr9Stfd d Drn|rn|rNSt dt ddddddfdd|DSt dd Drtfdd Drt ddt dddt ddfdd|DSt fdd Drt dddd fd!d|DSt d"d#dd$dd)%Nrrrc.tdkrdStfddddDS)NrcTc3s|] }|dkVqdSrNr5rvoutoutsr5r6rsz\OutputSelector.constant_to_variable_promotion..all_has_same_value..rpr1rnr5rnr6all_has_same_value zIOutputSelector.constant_to_variable_promotion..all_has_same_valuecrj)NrcTc3s$|] }t|tduVqdSrkrzrlrnr5r6rs"z[OutputSelector.constant_to_variable_promotion..all_has_same_type..rprnr5rnr6all_has_same_typerrzHOutputSelector.constant_to_variable_promotion..all_has_same_typecSs&|D]}t|tjjr|jSqdSr?)r:rrrr)rormr5r5r6get_first_value_dtypes  zLOutputSelector.constant_to_variable_promotion..get_first_value_dtypecs|] }t|tjjVqdSr?r_rlr5r5r6rz@OutputSelector.constant_to_variable_promotion..css|]}|duVqdSr?r5rlr5r5r6rr.c3|]}t|VqdSr?r:rlpromotion_builtin_typesr5r6rs  z>Return results from different branches in cond has same type: z*, but has different value: true value is 'z' and false value is 'rcz/', so we will promote the constant to variable.cs"g|] \}}t||ddqS)NrrMrvrmrUrr5r6ry szAOutputSelector.constant_to_variable_promotion..csrur?r_rlr5r5r6rrvc3s&|]}t|tjjgRVqdSr?r_rlryr5r6rs  zBReturn results from different branches in cond are not same type: z#false_var returned by false_fn is 'z' and true_var of true_fn is 'cs&g|]\}}t||dqS)r{r|r})rtrorr5r6rys c3rwr?rxrlrir5r6r$sz1Return results has maybe unbound local variable `z`, please ensure do not use ``z after cond.csg|]}qSr5r5r9)rr'r5r6ry)rzMUnsupported return type of true_fn and false_fn in cond: false_var returned `z` by false_fn is `z` and true_var of true_fn is `)rrrrr$r/rrr1rrr*anyr;)out_with_blocksr'r:rqrsr5)rrtr'rorzrr6rTsr      z-OutputSelector.constant_to_variable_promotioncst|\}t}|j}tjjtjjg}||vrSdd}fdd}tddDrJ|sJt ddj d d j d ||SS) Ncrj)NrcTc3s |] }|jdjkVqdSrkr{rlrnr5r6rAszQOutputSelector.precision_promotion..all_has_same_dtype..rprnr5rnr6all_has_same_dtype>rrz>OutputSelector.precision_promotion..all_has_same_dtypecsTfdd}g}||}|D]\}}||jkr"ttj||t|}||q|S)NcsNtdkr djStdd|Dr tdd|Dr tjS|ddjS)Nrcrcs |] \}}|jtjkVqdSr?)rrfloat16rvrmr:r5r5r6rH zpOutputSelector.precision_promotion..promote_precision..get_expected_precision..csrr?)rrfloat32rr5r5r6rJr)rprrrr)rrnr5r6get_expected_precisionDs  z]OutputSelector.precision_promotion..promote_precision..get_expected_precision)rrMrrrr)rrZnew_outsZexpected_dtypermrUrnr5r6promote_precisionCs      z=OutputSelector.precision_promotion..promote_precisioncsrur?r_rlr5r5r6r[s z5OutputSelector.precision_promotion..zYReturn results from different branches in cond has different dtype: true value dtype is 'rz' and false value dtype is 'rcz<', so we will promote the lower precision to the higher one.) rrrrrrrr1rrr)rr'r:rrrrrr5rnr6rU0s*  z"OutputSelector.precision_promotionN)rHrIrJr>rrZrrVrWr`rbrerh staticmethodrTrUr5r5r5r6rNs$       KrNc strIt|ts Jd|jdksJd|}|r2|dur0t|s-tdt|j|SdS|durGt|sDtdt|j|SdSd}d}t |ddgd t |d t tdfd t rt |}|durt|sytdt|j| |}Wdn1swY|durt|stdt|j| |}Wdn1swYntd%itfd d }|durt|stdt|jt|gdd} | |} | durt|| }Wdn1swY|durBt|stdt|jtt|gdd} | |} | dur2t|| }Wdn 1s=wY|durN|durNdS|durWtd|dur`td|durqd} dgtt|}n d} t|||\}}tt|tt|krtdtt|dtt|dtt|t|t|D]&\}}}z t||ddWqty}z td|d|d}~wwdd}|t|t|t|| rtst||\}}t r\t|t|}}ddtt|t|D}t ||||d}|!\}}| t"|Wdn 1s*wY| t"|Wdn 1sCwY|#t|$}|%|}t&||Stj'|dd fd!d fd"d#}t(t)|t|t|t|}td$d |}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 doesn'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 graph 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 graph 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. Examples: .. code-block:: python :name: code-example-1 >>> 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 (shape [] or shape [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()`` . Examples: .. code-block:: python :name: code-example-2 >>> 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) >>> a, b = paddle.static.nn.cond(pred, true_func, false_func) >>> print(a) Tensor(shape=[1, 2], dtype=int32, place=Place(cpu), stop_gradient=True, [[1, 1]]) >>> print(b) Tensor(shape=[2, 3], dtype=bool, place=Place(cpu), stop_gradient=True, [[True, True, True], [True, True, True]]) z!The pred in cond must be Variablercz#condition input's numel should be 1Nz3The true_fn in cond must be callable, but received z4The false_fn in cond must be callable, but received rr$zpaddle.static.nn.condr'r#cs t|Sr?)copy_var_to_parent_blockrrsr5r6ras zcond..TrqzpIncompatible 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 nameztrue fn returns z vars, but false fn returns z vars, which is not equalsrzIncompatible return values of `z#` in true_fn and false_fn in cond: cSst|||D]O\}}}t|}t|}tt|D];}||dur'||dus3||durT||durTtd|dt||d||dt||d||d qqdS)NIn cond : Var '8' or part of it is set differently in ifelse branches, <, > in true branch and in false branch. Set var to 'None' in ifelse block might lead to error.)rrr=rprrr*)Zseq_trueZ seq_falseZ seq_namesZf_trueZf_falsef_namerr5r5r6check_ret_noneIs,      zcond..check_ret_nonecSs"g|] \}}t|D]}|q qSr5)r)rvZseq_outr'r:r5r5r6ryjszcond..)rQr+r{cst||g|Sr?)select_input_with_buildin_type)r' false_vartrue_var)maskr5r6ras cstt|||Sr?)rr)Z false_varsZ true_varsr') merge_funcr5r6merge_every_var_listrz"cond..merge_every_var_listcSs|Sr?r5)r"r5r5r6rar)r#)*rr:r sizer rr;r*rHrrr0r rrirkrr1rlrUrr logical_notrrp_to_sequence_except_dictexpand_undefined_varrrrchange_none_to_undefinedvarrrNrerZ update_outputrrhr rr-map)rr%r&r'Z return_namesrOrPrgZcopy_to_parent_funcZtrue_cond_blockZorigin_true_outputZfalse_cond_blockZorigin_false_outputZ is_dy2staticrXrYZ return_namer rrRrSZflattened_return_namesZoutput_selectorrcrdrfrgrZmerged_output_fnsZ merged_outputr5)r3rrr6r#hsPi                        r#cCst|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_flowrrfr*)r:r r<rrrUr*rrrrrr'rrrfrr)rZ layer_helperprogrrxrr5r5r6rs$       rcCs^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_outputrmrr+rrMaskr|r*r+rN)r)rr1rr rr-r.r2)rmrrr3r5r5r6rsrcCsBt|t|krtd|d||Sddt||D}|S)a) 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 rcSs g|] \}}||kr |ndqS)rr5)rvr_r`r5r5r6rys z-_select_input_infer_shape..)rprrr)Z first_shapeZ second_shapeZ out_shaper5r5r6_select_input_infer_shapes rcCstd it}t|dttfdt|ddgdt|dj|dj}|dj}|dj }|j |||d}|j d||dd |id |S) ay **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(Tensor): A tensor containing 1 integer number selecting which input to output Returns: Variable: The selected input variable select_inputr+rr+rrcrrr|rN)r) rr1rr-r.rrrfrr*Zcreate_variabler2)r+rr3Z output_shapeZ output_dtype output_typermr5r5r6rs  rcsvddlm}ddlm}\}fdd}t|r't||r' ddSttr3t|tr3|SttrStt|rS|krIfddS|||g|Sttr]t|tsgt|trttr|||gt d td t|d |St|rt|tgtRst||rttgtRr|||}|g|St d td t|d ) Nrrric s:ztWSty}z tdd|d}~ww)Nz.Exceptions thrown while doing select_input on z: )r Exception RuntimeError)r )r+rr'r5r6start_select_inputs z:select_input_with_buildin_type..start_select_inputcSsdSr?r5r5r5r5r6raz0select_input_with_buildin_type..csSr?r5r5)rr5r6ra'rzeReturn results from different branches in cond are not same type: false_var returned by false_fn is 'z' and true_var of true_fn is 'r~z\Unsupported return type of true_fn and false_fn in cond: false_var returned by false_fn is ') rrrrr:r rr*rrr;)r+rr'rrrrr5)rr+rr'r6r sr     #rcCst|trdSt|S); In this function, dict is not viewed as sequence. F)r:r/rrr5r5r6_is_sequence_except_dictOs rcCst|tr|gSt|S)r)r:r/r!rr5r5r6rXs 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. r)RETURN_VALUE_PREFIXricst|fddt|DS)Ncsg|]}dqS)paddingr5rarir5r6rynrzGexpand_undefined_var..pack_undefined_var_as..)r r)seqrir5r6pack_undefined_var_aslsz3expand_undefined_var..pack_undefined_var_asc s|sTt|s|durT|durP|durP|dkr7td|dt|d|dt|d|d |Std|dt|d|dt|d|d |S|S)Nrrrrrr) startswithr:rrr*)Zn1Zn2r'orderrrrr5r6map_fnqs>  z$expand_undefined_var..map_fncSrG)rr5rar5r5r6ryr;z(expand_undefined_var..cSrG)rcr5rar5r5r6ryr;)Z4paddle.jit.dy2static.transformers.return_transformerrrrr-rrr)nest1nest2rQr nest1_out nest2_outr5rr6ras6     rcsPddlmfdd}t|tt|t|}t|tt|t|}||fS)Nrrics|durdS|S)Nrr5rrir5r6rsz+change_none_to_undefinedvar..map_fn)rrr r-rr)rrrrrr5rir6rs  rrTbothc Cst|dgdd|p d}td it} tr)t|||||||||| d S| |j} | j dd|id| i|||p=d|||||| d d | S) aJ :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 (Tensor): A Tensor to print. first_n (int, optional): Only log `first_n` number of times. Default: -1. message (str, optional): A string message to print as a prefix. Default: None. summarize (int, optional): Number of elements in the tensor to be print. If it's value is -1, then all elements in the tensor will be print. print_tensor_name (bool, optional): Print the tensor name. Default: True. print_tensor_type (bool, optional): Print the tensor type. Default: 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, optional): 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: Tensor: Output tensor. NOTES: The input and output are two different Tensor, and in the following process, you should use the output Tensor 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]) >>> # doctest: +SKIP('Unable to get output') Variable: fill_constant_1.tmp_0 - message: The content of input layer: - lod: {} - place: Place(cpu) - shape: [2, 3] - layout: NCHW - dtype: int64 - data: [3 3 3 3 3 3] >>> # doctest: -SKIP >>> res [array([[3, 3, 3], [3, 3, 3]], dtype=int64)] rm) Zuint16rrZfloat64r+r,r$Z float8_e4m3fnZ float8_e5m2zpaddle.static.PrintprintTInr|) first_nr&messageprint_tensor_nameprint_tensor_typeprint_tensor_shapeprint_tensor_layoutprint_tensor_lod print_phaser~N)r) rrr1r rrupperZ"create_variable_for_type_inferencerr2) rmrrr&rrrrrrr3rr5r5r6PrintsNK  rc@s6eZdZd ddZddZddZdd Zd d ZdS) SwitchNcCstd|d|_d|_g|_dS)NswitchroF)rr3 inside_scopepre_not_conditions)r=r'r5r5r6r>- s zSwitch.__init__cCs|jstdt|ddgdt|jdkr-t|gdd}tj|d}|j|t |St|j}|j|d }tj |tj|dd }|j|ttj ||d gdd}t |S) Nz!case should be called inside with conditionr$z.the member function case of base.layers.SwitchrTrrrc)ry) rrrrprrlrrr logical_andrr)r=r cond_blockZnot_cond pre_cond_numZ pre_not_condZ new_not_condr5r5r6r2 s0     z Switch.casecCs:t|j}|dkr tdt|j|dgdd}t|S)Nrz&there should be at least one conditionrcTr)rprrrlrr)r=rrr5r5r6r!O s zSwitch.defaultcCs d|_|S)zN set flag that now is inside switch.block {} :return: Trr@r5r5r6rAY szSwitch.__enter__cCsd|_|dur dSdSrBrrCr5r5r6rGa szSwitch.__exit__r?)rHrIrJr>rr!rArGr5r5r5r6r, s   r)Nr"Nrr)NNNN) rNr"TTTTTr)R __future__rr functoolsrrrtypingrrrZ paddle.baserZpaddle.base.backwardr Zpaddle.base.frameworkr r r r rZpaddle.base.libpaddle.pirrrrrZpaddle.common_ops_importrrrrrZpaddle.frameworkrZpaddle.pir.corerZ paddle.utilsrrrrrrr r!r7r9rLr\rlrrrrMr$rr/rrrrrr rrr)rArCrIrMrNr#rrrrrrrrrrrr5r5r5r6s       ( K+:? . 7& {<    c;%C  =