ёiczSSKJr SSKrSSKJrJrJr SSKJr SSK r SSK J r SSK J r SSK Jr SSKJrJrJrJrJr SS KJrJrJrJr SS KJrJrJrJrJr SS K J!r! SS K"J#r# SS K$J%r%J&r&J'r'J(r(J)r)J*r*J+r+J,r, S8Sjr-"SS5r."SS\.5r/"SS5r0"SS5r1"SS\.5r2Sr3"SS5r4\5\6\74r8Sr9Sr:"SS5r;S9S jrS:S#jr?S:S$jr@S%rAS&rBS'rCS(rD"S)S*5rES;S+jrFS,rGS-rHS.rIS/rJS0rKS1rLS2rMS3rNS4rO\S>> 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 summarizenameassert_assert)CondData)typeinputsattrs) rrlisttupler-intstrrrr(rlocals append_op) r$r&r'r( input_data assert_op layer_namehelperops ]/var/www/html/banglarbhumi/venv/lib/python3.13/site-packages/paddle/static/nn/control_flow.pyAssertr<;sb fvh ? ftUDJ/1Py+s,KLtVc4:.0OP}}[U[5(d [S5e[5(d#[TU]UR R5 Xlg)NzWhileGuard takes a while op) rBWhilerCrsuperrFr9rDwhile_op)rErd __class__s r;rFWhileGuard.__init__s?(E**9: :}} G X__99 : r=c>[5(aM[URR/5R 5UlUR R 5$[RURl [TU]5$rI) rrrdcond_varbodyblockrLrbIN_WHILE_BLOCKstatusrcrEres r;rLWhileGuard.__enter__s^ ==' (>(>CHHJDJ::'') )$33 w ""r=c4>[5(a<[URR/5 URR XU5$Ubg[ RURlURR5 [TU]XU5$NF) rrrdrhrjrUrbAFTER_WHILE_BLOCKrl _completercrErRrSrTres r;rUWhileGuard.__exit__ss == dmm,,- .::&&x&A A  $66  !w6::r=)rjrd) rWrXrYrZrFrLrUr\ __classcell__res@r;r_r_s!#;;r=r_c*\rSrSrSrSrSrSrSrg)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 c&[U[5(dM[USS/S5 [SURS5S:wa"[ S[UR5S35e[ U5UlURR5Ul g)Nr$r%z static.nn.Ifc X-$rIr]abs r;If.__init__..s15r=4condition expected shape as [1], but given shape as .) rBr0rrshaperCrif_opr$rh)rEr$s r;rF If.__init__s|$%% $T6F8^ L($**a8A=J4PTPZPZK[J\\]^!&  ) r=c6URR5$rI)r true_blockrKs r;r If.true_blockszz$$&&r=c6URR5$rI)r false_blockrKs r;rIf.false_blockszz%%''r=)rhrN) rWrXrYrZr[rFrrr\r]r=r;rxrxs2*'(r=rxc:\rSrSrSrS SjrSrSrSrSr S r g) ConditionalBlockaV **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 NcXl[5(a"U(a[U5S:wa [S5egUHn[ US[ S5 M X l[SUS9Ulg)NrzSFor ConditionalBlock Api, Only support one input while is_scalar_condition is Trueinputrconditional_blockr() r.rlenrCrr is_scalar_conditionrr9)rEr.rr( each_inputs r;rFConditionalBlock.__init__sa =="s6{a'7i $ :w:LM%$7 !"5DA r=c|[5(a#[UR5R5$[ U5$rI)rrxr.rConditionalBlockGuardrKs r;rjConditionalBlock.blocks+ ==dkk?--/ /$T**r=cURRR5nURRRUR5n[ 5n[ 5n[ XX0RS9upCUVs/sHoRRU5PM nn/nUH.nURU5n U (dMURU 5 M0 UR[RRRS9n URSUR US.Xz/S.UUR"S.S9n UR%U5(aUR'X!U 5 ggs snf)N)r9r-r)r+Input)OutScope) sub_blockrr-r.outputsr/)r9rD current_blockrj parent_idxsetget_inputs_outputs_in_block_var_recursive_find_var_recursiveappend create_varr VarDescVarType STEP_SCOPESr5r.r"need_append_conditional_block_gradappend_conditional_block_grad) rE inside_block parent_block intermediateparams each_name param_listout_listinner_out_name inner_var step_scopeconditional_block_ops r;completeConditionalBlock.completesZ{{//==? {{//55l6M6MN u : ,{{ EK DJy ' ' 2F  *N$88HIy *+ ",,%%11-  ,55$ #%|<)'+'?'? 6   2 2< @ @  . .,@  A5 sEcRURnURnUS:g=(a X#:g$)N)backward_block_idxidx)rErgrad_sub_block_idxinside_block_idxs r;r3ConditionalBlock.need_append_conditional_block_gradBs2)<<'++ " $ O);)O r=cURnURRRU5n[ 5n[ 5nUR Hn[ U[5(deURH3n URU 5Hn X;dM URU 5 M M5 URH,n URU 5Hn URU 5 M M. M /n UH8nURU5nU(dMU RUR5 M: [ R""UR$[ 5UR$/5unn[ R&R)5n[ R&R*R,nUR$R/5nUR1US5 UR3UU5 UR5SU 5 UR7SU Vs/sHnUS-PM sn5 [ 5nUR95HnUR$R;UR=55(dU[ R>"5:XaMLUR$RAUR=55 URU5 UU;dMM URCUR$5 UREUR$5 UR95HnUU;dM [GUU5 M URRRI5 gs snf)aY 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. rrz Input@GRADz@GRADN)%rr9rDrjropsrBr input_namesradd output_namesoutputrrr(r get_grad_op_descdescop_proto_and_checker_makerkOpRoleAttrNameOpRoleBackwardr5 copy_from _set_attr set_input set_outputoutput_arg_nameshas_var_recursiveencodeempty_var_namevarinfer_var_type infer_shaper _sync_with_cpp)rErrrrgrad_sub_blockrreach_opiname in_var_nameoname out_var_namerinner_input_namer grad_op_descop_grad_to_varop_role_attr_namebackward new_op_descparamnew_vars grad_var_nameargs r;r.ConditionalBlock.append_conditional_block_gradLs"*<<11778JKu %))Ggx00 00 ,,#*==#7K"6 ;/$8- !--$+NN5$9L $$\2%:.* & $889IJIy!!)..1!' (,'<'< % %su~/B/B.C( $ n !;;KKM2299BB"''113 l1o./:gz2  C u57? C 5(99;M##55m6J6J6LMM D$7$7$99    # #M$8$8$: ; LL 'N2< "">#6#67 3 34//1Ch+C@2   //1/Ds M )r9r.rFN) rWrXrYrZr[rFrjrrrr\r]r=r;rrs#> B+ *X L2r=rcD^\rSrSrSrU4SjrU4SjrU4SjrSrU=r $)ria+ 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. c|>[US[S5 [TU] URR 5 Xlg)Nrjr)rrrcrFr9rDrj)rErjres r;rFConditionalBlockGuard.__init__s/5'#35LM 223 r=c >[TU]5$rI)rcrLrms r;rLConditionalBlockGuard.__enter__sw ""r=cX>URR5 [TU] XU5$rI)rjrrcrUrss r;rUConditionalBlockGuard.__exit__s% w6::r=)rj) rWrXrYrZr[rFrLrUr\rurvs@r;rrs #;;r=rcSnURHn[U[5(deURHBnUR U5H*nXr;dM U"XW5(aMUR U5 M, MD UR H,nURU5Hn UR U 5 M M. M [5n URRUR5n UHnU RU5n Sn URU5(aURU5n U (aMFU (dMOU R[ R"R$R&:XdMU R U5 M X- nX4$)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 cjSS/0nURU;aX RnUH nXA;dM g g)N shuffle_batchshuffle_batch_seedTFr)r:var_nameIGNORE_VAR_NAMES var_namesr(s r;is_ignore_vars3get_inputs_outputs_in_block..is_ignore_varssD ,.B-CD 77& &(1I!#"r=N)rrBr rrrrrrrDrjrrhas_varrr-r rrDENSE_TENSOR_ARRAY)r inner_inputs inner_outputsr9rr:rrrrremove_inner_inputsrparent_block_varcurrent_block_vars r;rrs[ ""h''''^^E!xx 3N==!$$[1 /$__E " % 0 !!,/!1% %&&,,]-E-EFL# ';;KH    - - - 1 1+ >   !!!&&||##667 # #K 0$ 5L  &&r=c:\rSrSrSrSrSrSrS SjrSr S r S r g) rbia :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.] rrNcXl[USS/S5 [SURS5S:wa"[ S[ UR5S35e[ 5(ag[RUl [SUS 9Ul X l g) Nr$r%zstatic.nn.Whilec X-$rIr]r|s r;r While.__init__..Dsqur=rrrwhiler) rhrrrrCr0rrbBEFORE_WHILE_BLOCKrlrr9is_test)rEr$r r(s r;rFWhile.__init__As~  vx9JK $djj! 4 9FtDJJGWFXXYZ  == .. !'5  r=c[U5$rI)r_rKs r;rj While.blockNs $r=c URRnUR5nURUR5R5nUR R 1n[5n[X%X@R5upT/nUH.nURU5nU(dMURU5 M0 XVV s1sHoR iM sn -nXPR R 1-nUR[RRRS9n UR!SUV s/sHn UR#U 5PM sn UR /S.Xj/S.X R$S.S9 gs sn fs sn f)Nrr )X Condition)r StepScopes)rr r)r9rDrrjrrhr(rrrrrr rrrr5rr ) rErD while_blockrr x_name_listout_varsrrxrx_names r;rrWhile._completeQsn{{// "002 #))  & & ( 3 3 ++, e %@ m[[& " +N$88HIy *, 1111   **++ !,,%%11-  #."-!//7"-#mm_ %LA + E  2s E77E< )rhr9r rlr) rWrXrYrZr[r rkrqrFrjrrr\r]r=r;rbrbs+KZN  ' r=rbcSn[U[[RR45(dD[U[5(a,[U[ 5(a[ R"X5 gUngUR[RRR:XaURRnURUR5R5nU(a8UR!UR"5(d[ R"X5 ggg[U[5(aS[U[5(a>U"X5(a1[$R&"SUR(SUR(S35 [ R*R,R/5 [ R"X5 SSS5 g!,(df  g=f)zn Assign input to output, but skip the process of copying DenseTensorArray unless it's created in while_block. c[UR5[UR5:wag[URUR5Hup#X#:wdM SX#4;dM g g)NTrF)rrzip)x_vary_varx_dimy_dims r;has_shape_diff4assign_skip_lod_tensor_array..has_shape_diffsP u{{ s5;;/ / U[[9LE~"UN"::r=Nz>In dy2static mode, we attempt to assign a variable with shape z into a variable with shapez, which is not always right.)rBr r eagerTensorsupport_ret_buildin_typepaddleassignr-rrrrjprogramrrrr(warningswarnrbase framework_stride_in_no_check_dy2st_diff)rrr!rDrs r;assign_skip_lod_tensor_arrayr.~sv  eh (9(9: ; ; fh ' 'J +- -  MM% ( F zzT\\))<<<{{** #))  & & ( 3 3   @ @ L L MM% (!M< vx ( (5(++u-- MMPQVQ\Q\P]]xyzFzFyGGcd [[ " " A A C MM% (D C Cs 8G G&cURn[R"/URSS9nUR 5nUR UR 55 URUR55 X#lURU5 UR5RUR55nX%lX54$)Nrrdtype fill_value) stop_gradientr&fullr1get_defining_op move_before as_operationset_typer-add_extra_inputriadd_arg)rdvaluer3 fake_value fake_value_op block_args r;#create_fake_value_for_undefined_varr?s''M2U[[QGJ..0Mh3356 %, Z( '' 5I+   r=cv\rSrSrS Sjr\S5r\S5r\S5r\S5r Sr S r S r S r S rg)LoopVariNc6XlX lX0lSUlgrp)curr_varnext_varr>_is_fake)rErCrDr>s r;rFLoopVar.__init__s  " r=c^[UR[RR5$rI)rBrCr&pirValuerKs r;is_variable_curr_varLoopVar.is_variable_curr_var$--)9)9::r=c[UR[RRR R 5$rI)rBrCr&jit dy2staticutils UndefinedVarrKs r;is_undefined_curr_varLoopVar.is_undefined_curr_vars. MM6:://55BB  r=c^[UR[RR5$rI)rBrDr&rHrIrKs r;is_variable_next_varLoopVar.is_variable_next_varrLr=cUR$rI)rErKs r;is_fakeLoopVar.is_fakes }}r=cXlgrI)r>)rEr>s r;bind_block_argLoopVar.bind_block_args"r=cXlgrIrD)rErDs r; bind_next_varLoopVar.bind_next_vars r=c^^TR(deSn[U[RR5(a U"TU5$[ U5(a[ UU4SjU5$[TRUTR5$)NcF[X5up#[X!U5nSUlU$)NT)r?rArE)rdrDr<r>loop_vars r;create_loop_var_like>LoopVar.infer_type_with_next_var..create_loop_var_likes-$G% !JzY?H $H Or=c(>TRUT5$rI)infer_type_with_next_var)rrErds r;r2LoopVar.infer_type_with_next_var..sD99#xHr=) rRrBr&rHrIrr rArCr>)rErDrdrds` ` r;rg LoopVar.infer_type_with_next_varst))))  h 0 0 1 1'(; ; x  H t}}h??r=cVSURSURSURS3$)NzLoopVar(curr_var=z , next_var=z , block_arg=))rCrDr>rKs r;__repr__LoopVar.__repr__s."4==/T]]OrCrDNN)rWrXrYrZrFpropertyrJrRrUrXr[r_rgrlr\r]r=r;rArAsm ;;  ;;#!@(jr=rAc b ^^[U5(d [S5e[U5(d [S5e[US[[4S5 [ U5S:Xa [ S5eU"U6n[USS/S5 [S URS 5S :wa"[S [UR5S 35e[5(GaS n[[U5n[U5Vs/sHnUR(dMUPM nn[XXV s/sHoR PM sn 5mTR#5n [ U R%55[ U5:Xde['XR%55H$up{UR)U R+55 M& [SU5n U"U 6n [-U [[45(dU /n U4Sjn[/UU SSS9 U"X-5nSSKJm U4Sjn[4R6RUU5 U"[SU56nSUl[Xb5 [[;S[U555[[;S[U555-n[=U/SU5Q5 SSS5 TR?5n[ U5[ U5:Xde['UU5H unnUUl M [U5HpnURB(dMUR RE5(dM7UR RG5nURI5RKU5 Mr [SU5$[M5(aURO5nU(asU"U6n[-U[[45(dU/n[ U5[ U5:wa [ S5eU"U6RO5n[[PUU5 U(aMsU$[SXSU5n[UU5nURW5 U(a[YU5nU"U6nOU"U6n[-U[[45(dU/n[[UU5n[/UUSS9 U"U6n[[PUU5 [4R\"UU5 SSS5 U$s snfs sn f![ an[ SU35eSnAff=f!,(df  GNY=f![ an[ SU35eSnAff=f!,(df  U$=f)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%c X-$rIr]r|s r;rwhile_loop..0s15r=rzLthe shape of the variable returned by cond should be [1],but given shape as rc[R"5nURn[RR[RR /nX#;agUR (dgURRURR:wa<[R"URURR5nX@l ggrI) r _get_amp_attrs _amp_levelAmpLevelO1O2rJrCr1rDr&cast)rc amp_attrs amp_levelapply_amp_level_list cast_out_vars r;cast_value_in_amp%while_loop..cast_value_in_amp8s++-I!,,I      $ 400  &&(*;*;*A*AA%{{%%x'8'8'>'>  %1! Br=cTUR(a UR$UR$rI)rJr>rCrs r;rrsYs%(%=%=CMMO3<<Or=cr>^UU4Sjm/n[X5Hup4URT"XC55 M U$)Nc>[U5(a [TUU5$UR(aURUT5nU$UR U5 UnU$rI)rr rRrgr_)rcrD new_loop_var!infer_loop_var_type_with_next_varrds r;rbwhile_loop..infer_loop_vars_type_with_next_vars..infer_loop_var_type_with_next_vardsg"8,,,=$$   55'/'H'H$h( ('!..x8'/ ''r=)rr)rq next_vars new_loop_varsrDrcrrds @r;#infer_loop_vars_type_with_next_vars7while_loop..infer_loop_vars_type_with_next_varscs@( !# *-i*C&H!((9(M+D%$r=Fc2[U[5=(aB [UR[RR R R5=(d8 [U[RR R R5$rI)rBrArCr&rNrOrPrQrs r;rrssf"1g.&JJ (<(<(B(B(O(O'P #1fjj&:&:&@&@&M&MN 'Pr=) check_typesskip_ifzUbody in while_loop should return the same arity (length and structure) as loop_vars: Nto_static_variablec(>UR(dg[UR[RR 5(d5[UR[ [[45(d [S5eT"UR5Ulg)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.) rJrBrDr&rHrIr%floatr2 ValueError)rcrs r;check_next_var"while_loop..check_next_varss44!%%vzz'7'7$X%6%6uc8JKK$m%7x7H7H$I!r=cUR$rIr^rs r;rrss3<while_loop..s"N;MC<<;McUR$rIr^rs r;rrss r=z]body in while_loop should return the same arity (length and structure) and types as loop_varsr)/callablerCrr0r1rrrrrrr rArrJrrCriargsrr[_clonerBr&paddle.jit.dy2static.convert_operatorsrr&rPr3filterroptimize_updaterDrX use_emptyr5get_parent_block remove_opritemr.rbrrjr_deal_with_undefined_varr')r$rirqr r(pre_condrrcvariable_loop_varsr cur_blockrrrrer next_condoptimized_resultsresultfake_value_def_opnow_cond output_varswhile_loop_blockhas_mutable_vars_in_looprrrds @@r; while_looprs` D>>?@@ D>>?@@y+e}6LM 9~FGGYH(6(4J (..!49 ""&x~~"6!7q :  }} 1"'w : $I. .,, .  " /AB/A||/AB ]]_ y~~'(C0B,CC CC!$%79I!J '' 5"K! D d Ii$77&K  %0 % %P $<I  J LL & &~y A7CI'+I # + 7!%LI&" HI& "  iO"N;M"NO PKP%446$%-?)@@@@ #$68I J Hf &H !K *HH$5$5$?$?$A$A$,$5$5$E$E$G!!224>>%+ $   ==? *KkD%=99*m ;3y>1 D[)..0H 6 Y OhX50;    ! $-i8M .K *K+e}55&-K 0iHI !+ye L %2KK h)- ". U Cp  <<=3@ m_t 889s<   " !. st-SSS B S-$ S 1B*S-8[U[/[Q75(dUcT"5$[U5(a[ U4SjU5$g)Nc>T"5$rIr])rrs r;rC_deal_with_undefined_var..create_var_like..s +D+Fr=)rBr r%rr )o_varrs r;create_var_like1_deal_with_undefined_var..create_var_likesL uxC*BC D D},. . u   !!FN N r=z+The length of loop_vars should be the same.)paddle.jit.dy2static.utilsrQrrrrrBr)rrqrQrresultsrl_varrs @r;rrsv O ;3y>)FGGGK3  e * *em NN?51 2 NN5 ! 4 Nr=c (USUSUSUSUS3 nU$)Nz of 'z' in z must be z, but received: rr])whatarg_nameop_name right_value error_value error_messages r;_error_messagers5 &hZuWIY -' }A 7 r=cxSnU"X5upUn[U5HupV[[XVUS9nM UnU"5$)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[US[[4S5 UHn[U[5(d%[ [ SSS[[ U555e[U5S:wa-[ [ SSSS[[U55S-55eUup4[USS /S 5 [U5(aM[ S 5e Uc[U5S - nXS nUS UnX4$[U5(d [ S5eX4$)zW 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.Nr)The default in Op(case) must be callable.) rr0r1rBrCrr-rr3rr)rdefaultpred_fnrfn default_indexs r;_case_check_argscase.._case_check_argsgs* =/D%=&I$Ggu--",'W 7|q "*'CL)H4 HD $fvh(? B<<K9%@ ? .2M#215G).=9M%%'""GH H%%r=rtrue_fnfalse_fn)reversedrr$)rrr(rrrrfinal_fns r;rr&sKB-&^.mEMH!-0 4dhO1H :r=c[S0[5D6nSnU"XU5upbUnUHup[[XUS9nM Un U "5$)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] c[US/SQS5 [UR5S:wa[R"US5n[ US[ [[4S5 [U[5(aUR5OUn[SU55(a[ [U55OUn/nUGHn[U[5(d%[[SSS[[U555e[!U5S :wa-[[S SSS [#[!U55S -55eUupV[U[$5(d%[[S SS[$[U555eXS;a['SUS35eUR)U5 [+U5(aM[[SU3SSS[U555e Uc [-U5SSn[-U5SSnO[+U5(d [S5e/nUHDup[R."S/SUS9n [R0"X 5n UR)X45 MF Xr4$)N branch_index)uint8int32int64zstatic.nn.switch_caser branch_fns switch_casec38# UHn[U5v M g7frI)r)rrs r;r3switch_case.._check_args.. s5*B8B<<*rrrrrrzThe key's typez-The key in 'branch_fns' must be unique, but 'z' appears more than once.zThe type of function for key rrrrr0)rrr1r&rzrr0r1dictrBitemsall enumeraterCrr-rr3r2rrrsortedr4equal) rrr keys_of_fns index_fn_pairkeyrrindex new_indexrs r; _check_args switch_case.._check_argss_   ' #   ++ , 7!;;|W=L:|dE4-@-P#-Z">">J   J  5*555 :& '   'MmU33",$%Z( =!Q&"*$%C ./(: $GCc3''"($%S ! CC5Hab""3'B<<"7u=$%"R Y(l ?Z(,Q/G +CR0J'""GH H #IE 1#WOI<< 8D  $ ,$ %%r=r)r)rr4rr$) rrrr(r9rrrrrrs r;rrsZh 3&( 3FZ&x)7KMH& 4dhO'H :r=c[[U5S-5Vs/sHn/PM nn[U5HPupE[U5H(upgU"U5(dMX6RU5 M: USRU5 MR U$s snf)Nrrrangerrr) containerdiscriminators_bucketsrrir$s r;get_indices_by_discriminatorr\s ^!4q!89:9ar9G:y)  0GADzz !!#&1 BK  s # * N;s B c[[U55Vs/sHn/PM nn[U5H4upE[U5H upgXG;dM X6RU5 M2 M6 U$s snfrIr)r index_groupsrrrrrindicess r;select_by_indicesrhsh \!2343ar3G4y) #L1JA~ !!$'2* N 5s A*c[SUS5n[U5Vs/sHnSPM nnUH7upE[U5[U5:Xde[XT5H upgXsU'M M9 U$s snf)Nc$U[US5-$Nr)r)accpairs r;r7create_container_by_items_and_indices..ts#DG ,r=r)rrrr)items_indices_pairs total_lengthrrpartial_containerrrrs r;%create_container_by_items_and_indicesrrs|,.A1L %\232!2I3&9"$%W555W8IC!cN9':  4s A)c^^UU4SjnU$)NcX>T"5 T"U0UD6sSSS5 $!,(df  g=frIr])rkwargsrjrs r;new_fnrun_with_block..new_fns Wt&v&WWs )r])rrjrs`` r;run_with_blockr~s' Mr=c\rSrSrSr\S5r\S5r\S5r \S5r \S5r Sr S r \S 5r\S 5rS rg )OutputSelectoricXlX lX0lX@l[ U5Ul[ U5UR :Xde[ U5UR :XdegrI)r true_output false_outputnamesr num_output)rErflattened_true_outputflattened_false_outputrs r;rFOutputSelector.__init__sU 02 34)*doo===5zT__,,,r=c/n/n[URURUR5Hup4n[R X0R R4X@R R4/U5unn[RX0R R4X@R R4/U5up4URU5 URU5 M X4$rI) rrrrrconstant_to_variable_promotionrrrprecision_promotionr)rEunified_true_outputunified_false_outputtrue_out false_outr(s r;unified_outputOutputSelector.unified_outputs !),   d//* %H ==zz445 6 67  %3$F$Fzz445 6 67 % !X & &x 0 ' ' 2+* ,#88r=c URS$rr'rKs r;r#"OutputSelector.unified_true_output""1%%r=c URS$)Nrr*rKs r;r$#OutputSelector.unified_false_outputr,r=c[URS5up[URS5up2X:XdS5eU$)NcJ[U[RR5$rIrBr&rHrIrs r;r1OutputSelector.variable_indices..jFJJ$4$45r=cJ[U[RR5$rIr1rs r;rr2r3r=z?true_variable_indices and false_variable_indices should be same)rr#r$)rEtrue_variable_indicesrfalse_variable_indicess r;variable_indicesOutputSelector.variable_indicessY#?  $ $ 5$  %A  % % 5% !%> M >%$r=c[[UR55Vs/sHnXR;dMUPM sn$s snfrI)rrrr7)rErs r;constant_indicesOutputSelector.constant_indicessE3t//01 1--- 1   s AAc[URUR5un[URUR5unX4$rI)rr#r7r$)rEvariable_true_outputvariable_false_outputs r;get_variable_outputs#OutputSelector.get_variable_outputssO"3  $ $  ! !#  $5  % %  ! !$  $::r=c[URUR5un[XR4X R45nU$rI)rr#r:rr7)rEvariable_resultsconstant_outputrestored_outputs r;#restore_outputs_by_variable_results2OutputSelector.restore_outputs_by_variable_resultssN.  $ $  ! !  @ 44 5 33 4 r=c ^ ^ SSKJn SSKJm [[ [ 4m [U6up4SnSnSn[SU55(aU$[SU55(aU$[U 4S jU55(asU"U5(afU"U5(aU$[R"S [US5S USS US S35 UVV s/sHup[X)5"USS9PM sn n$[SU55(a[U 4SjU55(af[R"SS[US 5S3-S[US5S3-5 UVV s/sHup[X)5"X"U5S9PM sn n$[U 4SjU55(a9[R"SUSUS3S-5 UVs/sH nT "U5PM sn$[SUSUSSUS S35es sn nfs sn nfs snf)NrrrQcT^[T5S::ag[U4SjTSS55$)NrTc32># UH oTS:Hv M g7frNr]routoutss r;r\OutputSelector.constant_to_variable_promotion..all_has_same_value..s:#d1g~srrrNs`r;all_has_same_valueIOutputSelector.constant_to_variable_promotion..all_has_same_values(4yA~:ab:: :r=cT^[T5S::ag[U4SjTSS55$)NrTc3V># UHn[U5[TS5Lv M g7frKrrLs r;r[OutputSelector.constant_to_variable_promotion..all_has_same_type..s"FXctCyDaM1Xs&)rPrQs`r;all_has_same_typeHOutputSelector.constant_to_variable_promotion..all_has_same_type(4yA~FT!"XFF Fr=cUH:n[U[RR5(dM.URs $ grI)rBr&rHrIr1)rNrMs r;get_first_value_dtypeLOutputSelector.constant_to_variable_promotion..get_first_value_dtypes2c6::#3#34499$r=c3j# UH)n[U[RR5v M+ g7frIr1rrMs r;r@OutputSelector.constant_to_variable_promotion..$ADSz#vzz//00D13c3(# UHoSLv M g7frIr]r^s r;rr_s+dsd{dsc3<># UHn[UT5v M g7frIrBrrMpromotion_builtin_typess r;rr_s @DJs3 4 4z>Return results from different branches in cond has same type: z*, but has different value: true value is 'z' and false value is 'rz/', so we will promote the constant to variable.r1c3j# UH)n[U[RR5v M+ g7frIr1r^s r;rr_r`rac3t># UH-n[U[RR/TQ75v M/ g7frIr1res r;rr_s6J  sVZZ--H0GH I Is58zBReturn 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 'c3<># UHn[UT5v M g7frIrd)rrMrQs r;rr_$s=z#|,,rgz1Return results has maybe unbound local variable `z`, please ensure do not use ``z after cond.zMUnsupported 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 `)rrrrQr%r2rrrr)r*r-ranyrC) out_with_blocksr(rrNrrRrWr[rMrjrQrfs @@r;r!-OutputSelector.constant_to_variable_promotionskM;#'e"4' ;  G   ADA A AK +d+ + +K  @D   %%!$''  TUYZ^_`ZaUbTcd??CAwiG]^bcd^e]fgCC'6 '6 ##5=cN&5  ADA A AcJ J G G  MMT7T!W Fcded47m_A&' #2 #2JC194T:#2   == = = MMCD6Ifgkfllmn  1@@1L&@ @ 0a 9WX\]^X_W``a c  = AsG7$!G=Hc^[U6umn[R"5nURn[RR [RR /nXE;aT$SnU4Sjn[ST55(aNU"T5(dA[R"STSRSTSRS35 U"U5mT$T$) NcT^[T5S::ag[U4SjTSS55$)NrTc3Z># UH oRTSR:Hv M" g7frKrhrLs r;rQOutputSelector.precision_promotion..all_has_same_dtype..As FXcyyDGMM1Xs(+rPrQs`r;all_has_same_dtype>OutputSelector.precision_promotion..all_has_same_dtype>rYr=c>U4Sjn/nU"U5nUHMupEX4R:wa([[RU5"U[U5nUR U5 MO U$)Nc>[T5S::aTSR$[SU55(a'[SU55(a[R$USSR$)Nrrc3`# UH$upUR[R:Hv M& g7frI)r1r&float16rrMrs r;rpOutputSelector.precision_promotion..promote_precision..get_expected_precision..Hs">MFCCII/o,.c3`# UH$upUR[R:Hv M& g7frI)r1r&float32r{s r;rr|Js">MFCCII/or})rr1rnr&r)rorNs r;get_expected_precision]OutputSelector.precision_promotion..promote_precision..get_expected_precisionDsrt9>7==(>M>M">>)*1-a0666r=)r1rr&rzrr)rornew_outsexpected_dtyperMrjrNs r;promote_precision=OutputSelector.precision_promotion..promote_precisionCsd 7H3ODN- !YY.(e<<^LC$ . Or=c3j# UH)n[U[RR5v M+ g7frIr1r^s r;r5OutputSelector.precision_promotion..[s' 9=#JsFJJ,, - -razYReturn results from different branches in cond has different dtype: true value dtype is 'rz' and false value dtype is 'rz<', so we will promote the lower precision to the higher one.) rr rurvrwrxryrr)r*r1) ror(rr{r|r}rurrNs @r;r""OutputSelector.precision_promotion0s'a'') (( MM   MM     0K G  0  9=   $T** MMklpqrlslylykz{WX\]^X_XeXeWffLL %_5DK r=)rrrrrN)rWrXrYrZrFrr'ror#r$r7r:r?rE staticmethodr!r"r\r]r=r;rrs -996&&&& % %   ; I I V44r=rc j ^ ^!^"[5(a[U[5(dS5eURS:XdS5eUR 5nU(a=Ub8[ U5(d![ S[U5R35eU"5$gUb8[ U5(d![ S[U5R35eU"5$gSnSn[USS/S 5 [US [[S54S 5 [5(a[U5nUbQ[ U5(d![ S[U5R35eUR5 U"5nSSS5 UbS[ U5(d![ S[U5R35eUR5 U"5nSSS5 GO GO[!S0[#5D6m U 4S jnUbj[ U5(d![ S[U5R35e[%U/S S 9n U R'5 U"5n U b [)X5nSSS5 Ub~[ U5(d![ S[U5R35e[%[*R,"U5/S S 9n U R'5 U"5n U b [)X5nSSS5 UcUcgUc [/S5eUc [/S5eUcSn S/[1[3U55-nOS n [5XVU5upV[1[3U55[1[3U55:wa6[/S[1[3U55S[1[3U55S35e[7[3U5[3U5[3U55Hupn[9XSS9 M SnU"[3U5[3U5[3U55 U (a[;5(d [=XV5upV[5(Ga [?U5[?U5nn[7[3U5[3U55VVVs/sHunn[?U5HnUPM M nnnn[AWUUUS9nURC5unnUR5 [EU5 SSS5 UR5 [EU5 SSS5 URG5 [?URI55nURKU5n[MUU5$[*RN"USS9m!U!4Sjm"U"4Sjn[Q[SU[3U5[3U5[3U555n[)SU5n[MU[?U55nU$!,(df  GN:=f!,(df  GN=f!,(df  GN=f!,(df  GN=f![.an[/SUSU35eSnAff=fs snnnf!,(df  GNb=f!,(df  GNP=f) ac 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 Variablerz#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(c>[UT5$rI)copy_var_to_parent_block)rr9s r;rcond..s *B3*Or=TrzpIncompatible 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: cB[XU5Hup4n[U5n[U5n[[U55H[nX6cXFcXFbMX6cM[R "SUS[ X65SX6S[ XF5SXFS3 5 M] M g)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.)rrrrr)r*r-)seq_true seq_false seq_namesf_truef_falsef_namers r;check_ret_nonecond..check_ret_noneIs'*8 'J #FVV_Fg&GS[)K' 0|+ /MM)&2 -.b =STXY`YeTfSggijqjviwxFF*(Kr=)rrrhc >[X/TU5$rI)select_input_with_buildin_type)r( false_vartrue_varmasks r;rrs*H  !4+ r=c0>[[TU5X5$rI)r r) false_vars true_varsr( merge_funcs r;merge_every_var_list"cond..merge_every_var_listsWZ6 NNr=cU"5$rIr])rs r;rrsRTr=)r$)*rrBr sizerrrCr-rWrrr3rrrrrr4rrjr r& logical_notrr_to_sequence_except_dictexpand_undefined_varrrrchange_none_to_undefinedvarrrr?r update_outputrrEr!rzr0map)#rrrr( return_namesrrrcopy_to_parent_functrue_cond_blockorigin_true_outputfalse_cond_blockorigin_false_output is_dy2staticr%r& return_namerrrrseq_outrflattened_return_namesoutput_selectorr=r>rBrDrmerged_output_fns merged_outputr9rrs# @@@r;r$r$hsKR$))N+NN)yyA~DDD~yy{ "((#MdSZmNdNdMefy # #))#NtT\~OfOfNgh z!KLT6F85LMtVc4:.0GH}}D!  G$$I$w-J`J`Iab!!#%i $  H%%J4PX>KbKbJcd""$'z %$ 0vx0O  G$$I$w-J`J`Iab/v4PO &&(%,Y"%1"/+#K)  H%%J4PX>KbKbJcd 0##D)*  "'')&.j#&2#0+$L*|3 C   C   !{S)A+)N%OO   %9 |% !  #K 01S .6s#;K#HIJJfgjlDEQlRhSgTTn o  -0 - . .-([   !(5 I -" - . . KMM$? % ! }} K L ! 6 "%(5(6"" " W%  & " " )  ! "(    0 0 2 !    ) *    * +! "5==?3)MM   _== ;;t7 +D  O $\ 2 $[ 1 $\ 2  "/3DEM$\7=3IJM _$#%$)(*)j 1+>abcade  L" &  sf$V8V14W5W4 W'"X * X X# V.1 W W W$' X1XX X # X2c[U[5(dU$URnUR5RnUS:dS5eUR U5nUR [RRR:Xa$URUR5(aUnU$URURURUR S9n[ R""X5 U$)NrzOGot wrong parent block index when assigning var to parent scope in control_flowr1rr-)rBr rDrrrjr-r rrrrr(rr1rr&r')r layer_helperprogrrrs r;rrs c8 $ $  $ $D##%00J ?Y?::j)L DLL((;;;  , ,SXX 6 6  (22))3993883   c, r=c[S 0[5D6n[US[S5 [ USS/S5 [US[ [ 4S5 URSXS.SU0S9 U$) 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_outputrrrrrMaskrr-r.r)r)rr4rr rr0r1r5)rrrr9s r;rrsn  5FH 5Fug?;T6G9oFw D%=/B  )  Nr=c[U5[U5:wa[R"SUSU35 U$[X5VVs/sHup#X#:XaUOSPM nnnU$s snnf)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 rr)rr)r*r) first_shape second_shaper}r~ out_shapes r;_select_input_infer_shapersq ;3|,, RS^R__abnao p 14[1OP1Oaf"$1OIP QsAcL[S 0[5D6n[US[[4S5 [ USS/S5 [ USRUSR5nUSRnUSRnURXCUS9nURSXS.S U0S 9 U$) aQ **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.rrrrrrrr)r) rr4rr0r1rrrr1r-create_variabler5)r.rr9 output_shape output_dtype output_typerMs r;rrs 468 4Fvx$?T6G9nE -VAY__fQiooNL!9??L)..K  [ ! C  *  Jr=c^^^^SSKJn SSKJn TumnUUU4Sjn[ TU5(a[ XT5(aS$[ T[ 5(a[ U[ 5(aU$[ T[ 5(a9[ T[U55(aTU:XaU4Sj$U"T5U"U5/mU$[ T[ 5(a[ U[ 5(d*[ U[ 5(aV[ T[ 5(aAU"T5U"U5/m[R"S[T5S[U5S 35 U$[ TU5(a[ U[ /[ Q75(d-[ XT5(a4[ T[ /[ Q75(aU"U5U"T5snmTU/mU$[S [T5S[U5S 35e) NrrrHcd>[TT5$![an[STSU35eSnAff=f)Nz.Exceptions thrown while doing select_input on z: )r Exception RuntimeError)rr.rr(s r;start_select_input:select_input_with_buildin_type..start_select_inputsB - - @c!M  s  /*/cgrIr]r]r=r;r0select_input_with_buildin_type..str=c>T$rIr])rsr;rr's9r=zeReturn 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 'rkz\Unsupported return type of true_fn and false_fn in cond: false_var returned by false_fn is ') rrrrQrBr r%r-r)r*rC)r.rr(rrQrrrs``` @r;rr sI7 Ix)\**z00 v)X&&:h+I+I!! I7 8 8Z4>>>  $ $#9-"8,FF ; 9677 x * *8566 y( + +$Y/1CH1MN  226y/1BCXq " , ! 9l++ x(!F-E!F G G8** y8"G.F"G H H x ( y ) )X&   ((,Y'88VW[\dWeVffg i  r=cD[U[5(ag[U5$)3 In this function, dict is not viewed as sequence. F)rBrrrs r;_is_sequence_except_dictrOs!T q>r=cH[U[5(aU/$[U5$)r)rBrr"rs r;rrXs"!Ts q>r=c ^^^ SSKJm SSKJm U4Sjm UUU 4Sjn[ [ U[ U5[ U5[ U5[ U5Vs/sHnSPM sn55n[ [ U[ U5[ U5[ U5[ U5Vs/sHnSPM sn55n[U5(dUSn[U5(dUSnXV4$s snfs snf)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_PREFIXrHc f>[U[U5Vs/sH nT"S5PM sn5$s snfNpadding)r!r)seqrrQs r;pack_undefined_var_as3expand_undefined_var..pack_undefined_var_asls0 73<@URT5(d[UT5(dUcUczUbwUS:Xa9[R"SUS[ U5SUS[ U5SUS3 5 O8[R"SUS[ U5SUS[ U5SUS3 5 T"U5$U$)Nrrrrrr) startswithrBr)r*r-)n1n2r(orderrrQrs r;map_fn$expand_undefined_var..map_fnqs233 r< ( (BJzbnA:MM)$0 H:Rt+A$r(2bTRFF MM)$0 H:Rt+A$r(2bTRFF ), , r=r)4paddle.jit.dy2static.transformers.return_transformerrrrQr0rrr) nest1nest2rrr nest1_out nest2_outrrQrs @@@r;rras 8 (  $U + $U + $U +07 871Q7 8  I  $U + $U + $U +07 871Q7 8  I $E * *aL #E * *aL  ! 9 9s  C%! C*c ^SSKJm U4Sjn[U[[ U[ U5555n[U[[ U[ U5555nX44$)NrrHc>UcT"S5$U$rr])rrQs r;r+change_none_to_undefinedvar..map_fns 9 * *r=)rrQr!r0rr)rrrrrrQs @r;rrsN7 !S-H(IJI S-H(IJI  r=c [US/SQS5 U=(d Sn[S 0[5D6n [5(a.[R "UUUUUUUUUU R 5S5 $U RUR5n U RSSU0SU 0UUU=(d SUUUUUU R 5S . S 9 U $) a :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)] r) uint16rzrfloat64rrr% float8_e4m3fn float8_e5m2zpaddle.static.PrintprintTInr) first_nr'messageprint_tensor_nameprint_tensor_typeprint_tensor_shapeprint_tensor_layoutprint_tensor_lod print_phaser)r) rrr4rrrupper"create_variable_for_type_inferencer1r5) rrrr'rrrrrrr9rs r;PrintrsV    mG  -FH -F}}||                 6 6u{{ CF  e}"}"!2!2"4#6 0&,,.   Mr=c6\rSrSrS SjrSrSrSrSrSr g) Switchi, Nc>[SUS9UlSUl/Ulg)NswitchrF)rr9 inside_scopepre_not_conditions)rEr(s r;rFSwitch.__init__- s !(6 !"$r=c"UR(d [S5e[USS/S5 [UR5S:Xa;[ U/SS9n[ R"US9nURRU5 O[UR5nURUS - n[ R"U[ R"US9S 9nURRU5 [ [ R"XQS 9/SS9n[U5$) Nz!case should be called inside with conditionr%z.the member function case of base.layers.SwitchrTrrr)ry) r rrrr rr&rr logical_andr)rEr cond_blocknot_cond pre_cond_num pre_not_cond new_not_conds r;r Switch.case2 s  @A A   H <   t&& '1 ,)9+4PJ))I6H  # # * *8 4t667L22r-s#66 < );   HV.;;4((((Vv2v2r;J;*<'~I I X!%-+)\ ! 4j4jnAH#Lxvxv  __Dvr .:$"J@F: z     } }@99r=