͑i{SSKJr SSKrSSKJrJrJr SSKJrJ r SSK J r J r J r \(a)SSK JrJr SSKJr SS KJr "S S \5r"S S \SS9r/r\R.R0r\R2r\R6r\R:rSrSrSr Sr!Sr""SS5r"SS5r#"SS5r$"SS5r%g)) annotationsN) TYPE_CHECKINGAny TypedDict)core framework) cpu_places cuda_places xpu_places)Graph_Scope) Optimizer)Programc>\rSrSr%S\S'S\S'S\S'S\S'Srg ) _CustomOpstr paddle_op popart_opdomainintversionN__name__ __module__ __qualname____firstlineno____annotations____static_attributes__rT/var/www/html/banglarbhumi/venv/lib/python3.13/site-packages/paddle/base/compiler.pyrrs  r"rc8\rSrSr%S\S'S\S'S\S'S\S'S\S'S\S'S\S 'S\S 'S \S 'S \S 'S \S'S \S'S \S'S \S'S\S'S\S'S\S'S\S'S\S'S\S'S\S'S\S'S\S'S\S'S\S'S\S'S \S 'S\S!'S"\S#'S$rg%)&_IpuStrategyOptions"bool is_trainingneed_avg_shard enable_fp16use_no_bias_optimizerenable_distributionscaled_optimizer_state is_dynamicenable_model_runtime_executorrnum_ipusbatches_per_stepmicro_batch_size random_seed tiles_per_ipu num_buffersfloatavailable_memory_proportion loss_scalingmax_weight_norm timeout_mslrr accl1_type accl2_type accl3_typeonnx_dump_pathweight_decay_modeenable_pipeliningenable_gradient_accumulationaccumulation_factorenable_manual_shardr custom_oprNrrr"r#r%r%"s##!! $$'++ %**  &**  !!r"r%F)totalcR[R"5nURU5 U$N)rPlace set_place)placeps r# _place_objrMJs AKK Hr"cUR5HanUR5(dMUR5cM-UR5R5R S5(dMa g g)N_gradTF)nodesis_opoptypeendswith)graphnodes r#_has_backward_oprWPsO  JJLL %  ))'22  r"c/n[UR5R5H(up#URS:XdMUR U5 M* USSS2H"nUR5R U5 M$ g)Nfeed) enumerate global_blockopsrSappend _remove_op)programpop_idxirRindexs r#_prune_feed_opsrd[sjG7//1556 77f  NN1 72))%0r"cDURHn[Rn[RRRnUR 5UR ;dMW[UR5UR55[U5:XdM g g)NTF) r]rop_proto_and_checker_makerOpRoleOptimizekOpRoleVarAttrName attr_namesr all_attrskOpRoleAttrName)blockrRop_makeroptimizes r#_has_optimize_oprpes{ii222299BB  & & (BMM 9c LLN8335 6? ]?  r"cUR5nURRUS5nUcg[USS5=(d [USS5nU(+$)NT_is_distributedFis_distributed)r\varsgetgetattr)r`var_namermvarrss r#_should_broadcast_or_not_existsryps[  "E **..4 (C {S"3U;w u@N r"cZ\rSrSrSrS S SjjrSrSrS SjrSr S r S r S r g)CompiledProgram{a :api_attr: Static Graph The CompiledProgram is used to transform a program or graph for various optimizations according to the configuration of build_strategy, for example, the operators' fusion in the computation graph, memory optimization during the execution of the computation graph, etc. For more information about build_strategy, please refer to :code:`paddle.static.BuildStrategy`. Args: program_or_graph (Graph|Program): This argument is the Program or Graph being executed. build_strategy(BuildStrategy): This argument is used to compile the program or graph with the specified options, such as operator's fusion in the computational graph and memory optimization during the execution of the computational graph. For more information about build_strategy, please refer to :code:`paddle.static.BuildStrategy`. The default is None. Returns: CompiledProgram Example: .. code-block:: python >>> import numpy >>> import paddle >>> import paddle.static as static >>> paddle.enable_static() >>> place = paddle.CPUPlace() >>> exe = static.Executor(place) >>> data = static.data(name='X', shape=[None, 1], dtype='float32') >>> hidden = static.nn.fc(x=data, size=10) >>> loss = paddle.mean(hidden) >>> paddle.optimizer.SGD(learning_rate=0.01).minimize(loss) >>> exe.run(static.default_startup_program()) >>> compiled_prog = static.CompiledProgram( ... static.default_main_program()) >>> x = numpy.random.random(size=(10, 1)).astype('float32') >>> loss_data, = exe.run(compiled_prog, ... feed={"X": x}, ... fetch_list=[loss.name]) Nc[U[R5(aXlSUlOm[U[ R 5(a7[U5 [R"UR5UlXlO[S[U535eSUl SUl SUl SUlSUlSUlSUlX lg)NzYThe type of program_to_graph parameter is wrong, expected Graph or Program, but received F) isinstancerr _graph_programr rrddesc TypeErrorrS_scope_place _executor _compiled _is_inference_share_vars_from_places_build_strategy)selfprogram_or_graphbuild_strategys r#__init__CompiledProgram.__init__s & 3 3*K DM ()*;*; < < , -**%5%:%:;DK,MklprBmClDE   " $ -r"cUR(aS5e[[U[5[U[5/5(deSUlXlU$)zAdd inference optimize Args: config: instance of `NativeConfig` or `AnalysisConfig` to create predictor Returns: self z6Already compiled with inference, cannot be recompiled.T)ranyr~InferNativeConfigInferAnalysisConfig _infer_config)rconfigs r#_with_inference_optimize(CompiledProgram._with_inference_optimizesf%% D %6#456#67     "# r"c[S5e)NzFSubclass of CompiledProgram should implement _with_distributed method.)NotImplementedErrorrs r#_with_distributed!CompiledProgram._with_distributeds! T  r"c  UR(arU(a[RRS5 URRc [ S5eURRR 5UlOUcS5e/Ul[U[[45(dS[U5S35eURc[5Ul UR(aURRS:akURR (aPURR nURR[#U5:XdS5eX@RlUR(aoURR&URlURR*URlURR.URlURbURR2(awURR[#U5-S:dS5eURR4[R6R8:XdS 5eS URl/UlUR>RA5HnURC5(dMURE5cM-URE5RG5(dMRURE5R5[HRJRLRN:wdMURQ5nURcM[SURU5(dMUR<RUURQ55 M [[W[XU55n[[[UR<55UlUR<R]5 [HR^"5(a [aS 5e[HRb"UUR<SURdURURUR>5$) Nz*share_vars_from is set, scope is ignored. zSThe shared Program is not compiled and executed, so there is no variables to share.zLCurrently, The places type can only be list or tuple, but the input type is .rz5The trainer numbers is not equal to endpoint numbers.z.DGC is not available for single card training.z1DGC only can be used for AllReduce BuildStrategy.FzBCUDA Graph is not allowed to capture when running the first batch.)3rsysstderrwriter ValueError local_scopes _local_scopesr~listtuplerSr BuildStrategyr num_trainers_trainers_endpointslentrainers_endpoints_nccl_comm_num nccl_comm_num_use_hierarchical_allreduceuse_hierarchical_allreduce$_hierarchical_allreduce_inter_nranks#hierarchical_allreduce_inter_nranks _enable_dgcreduce_strategyReduceStrategy AllReducefuse_all_reduce_ops_persistable_varsrrPis_varrx persistablerVarDescVarTypeRAWnameryr^maprMsetsortis_cuda_graph_capturing RuntimeErrorr{r)rplaces use_devicescopetpsrVrs r#_compile_data_parallel&CompiledProgram._compile_data_parallelsq     !NO$$..6 *"&!6!6!@!@!M!M!OD $ (b ($!#D &4-00 Z[_`f[gZhhi j 0    '#0?D MM$$11A5 11--33C''44C@ G @7: 3 ==151M1MD . 99  ; BB  D == $)B)B''44s6{BQF @ F$$44 //99: CC C: 8=D 4!#KK%%'D HHJ*HHJ**,,HHJOO%)=)=)A)AAyy{MM-7 tLL**11$))+>(c*f-. "&c$*@*@&A!B ##%  ' ' ) )T ##   " "  KK     KK  r"cB[R"UR5$rH)rcreate_paddle_predictorrrs r#_compile_inference"CompiledProgram._compile_inferenceAs++D,>,>??r"cUR(aVU(aURU:wa [S5eU(a+URR U5(d [S5eU$SUlXlX lUR (aUR 5UlU$UR/Ul[UR[R5(a[RnOJ[UR[R5(a[RnO[R nUR#X0RURS9UlU$)zCompile the program based on the configs. Args: scope: The variables (resources) that are associated with this compiled program. place: The location that the compiled program will be run on. Returns: self z,Cannot compile program with different scope.z,Cannot compile program with different place.T)rrr)rrrr_equalsrrrrr~r CUDAPlace DeviceTypeCUDAXPUPlaceXPUCPUr)rrrKrs r#_compileCompiledProgram._compileDs >>- !OPPT[[0077 !OPPK    !446DN !KK=DL$++t~~66'__ DKK77'^^ '^^ !88%[[9DN r"cZUSLnU(a3UH,nUR5UR5:XaM'S5e O^[U[R5(a [ 5nO4[U[R 5(a [ 5nO [5nU(dS5eU$)Nz7Place type not match. You may set wrong type of places.zNo places for execution.)_typer~rrr rr r )rrK place_list has_set_placerLs r# _get_placesCompiledProgram._get_placesjs"$. wwyEKKM1M1 %00(] E4==11'\ '\ 555zr") rrrrrrrrrrrrrrH)rzGraph | ProgramrzBuildStrategy | NonereturnNone) rrrr__doc__rrrrrrrr!rr"r#r{r{{sP/h04.).-.  .6, \ |@$Lr"r{cx\rSrSrSr/rSr\S Sj5r\S5r \S5r \S5r \S 5r S r g) IpuDynamicPatcheri|z) Patcher for IPU dynamic2static support. cgrHrrs r#rIpuDynamicPatcher.__init__s r"Nc ,^^^^^^^SSKmSSKJm SSKJn SSKJn TRnTRnTRnTRR5mUUUUU4Sj5nTR(aURSS 9 TRH[n TRU R 5R#5n U R%5R#5n U R'U 5 M] U(a%US SV s/sHocMU R PM sn mO!UV s/sHocMU R PM sn mUV s/sHoR PM sn mTR((GafU"5TlTR,n U R.R15GH/upUR15GHunnU R2R5UR S UR6UR8UR:S S 9nU R=U5nU"U5 U R2R?UTR@RBRES S9S9 SSS5 TRGUR 5R#5nUR%5R#5nUR'U5 UU R.UU'GM GM2 UUUUUUU4Sj5nU"5nUTlT$s sn fs sn fs sn f!,(df  N=f)z4 Convert the ConcreteProgram to IPUConcreteProgram. rN)backward)switch_to_static_graph) device_guardc>TRnTRUTR5 TRR TR 55nTRR 5nURU5 U$rH) main_programgradients_with_optimizer _optimizerstaticExecutorCPUPlacedefault_startup_programrun)r`exestartup_programrconcrete_program ipu_strategypaddles r#append_backward_descHIpuDynamicPatcher.convert_concrete_program..append_backward_descsf&33G  - -g|7N7N O--(():;C$mmCCEO GGO $Nr"float16)dtyperT)rrrrSshapebelong_to_optimizerg)value) initializerc>TR(aTRRR5nS1UlTRRR TR USS9nTRRRTR5TR US9 [TR TTS9RTT5nU$)NcumsumF)use_fp16_guard)to_fp16_var_names)rr) r*ramp CustomOpListsunsupported_listcast_model_to_fp16rcast_parameters_to_fp16rIpuCompiledProgramcompile) amp_listrr`r feed_list fetch_listrrrs r# func_compile@IpuDynamicPatcher.convert_concrete_program..func_compiles''!==,,::<-5J)$*MM$5$5$H$H$11#(%I%!  !!99OO%$11&7: ) --)gi,  Nr")$rbaserbase.dygraph.baserbase.frameworkrinputsoutputsrr global_scoper*to parametersrxr get_tensorr_share_data_withr(rr _accumulatorsitemshelpercreate_global_variablerrSr_get_device_for_paramset_variable_initializernnrConstantfind_var)rrclass_instancerrrrrrparam_or_bufferparam_or_buffer_tensor src_tensorelem optimizerkv param_namevar_tmprxdeviceparam_or_lr_tensor optim_tensorrrrr r rrs`` @@@@@r#convert_concrete_program*IpuDynamicPatcher.convert_concrete_programs #>1!(("***:: **,      # #   I  . 0::O%*YY$$&jl #)..0;;=J " 3 3J ? ; /5abzNztzNI/5JvtvJI,34GDiiG4  # # #,@,B  )$//I!//557+,779'J#**AA$\\$(%mm$\\%mm,0 BC'<[UT5(d![S[U5R35e[ U5nX lX R ;dTR(aX R ;aT RS5 UR (a"TR(dT RS5 URU5up4[RTX1R5nUT "X1RSL54UR U'[UR 5nUT:aT RSUSTS35 UR U$)Nz,type(item) should be CacheKey, but received z3ipu_strategy chances detected. Please sync weights.zbdynamic2static on IPU doesn't support multiple caches. Please make suredynamic inputs is not used.zCurrent traced program number: z > `max_tracing_count`:z. Too much cached programs will bring expensive overhead. The reason may be: (1) passing tensors with different shapes, (2) passing python objects instead of tensors.)r~rrSrhash _recent_key_caches need_compilewarn _build_oncerr0r#r) ritemitem_idr_current_tracing_countr6r5rr3r4s r# patch_getter;IpuDynamicPatcher.patch_program_cache..patch_gettersRdH-- B4:CVCVBWX4jG& ll*l.G.Gll*!&&M<< (A(A!&&6'+&6&6t&<# #4#M#M "24G4G$ %((*=*=T*I) W%),DLL(9%(+CC!&&9:O9PPgiAhBBGG <<( (r" __getitem__N) paddle.jit.dy2staticr3$paddle.jit.dy2static.partial_programr4'paddle.jit.dy2static.program_translatorr5r6r7rEr patcher_cacher^)rr7 old_getterrCr6r5r3r4s` @@@@r#patch_program_cache%IpuDynamicPatcher.patch_program_cachesS 7M  "-- $ )$ )L$0 ''.. =* 5 r"c^^SSKJn URmSUU4SjjnX!l[RR UST/5 g)Nr LRSchedulercP>T"X5 TRSUR05 g)Nr;) set_optionslast_lr)repochrold_steps r# patch_step8IpuDynamicPatcher.patch_lr_scheduler..patch_step8s" T !  $ $dDLL%9 :r"steprH)paddle.optimizer.lrrOrWrrIr^)rrOrUrTs` @r#patch_lr_scheduler$IpuDynamicPatcher.patch_lr_scheduler0s@3## ; ;&''.. VX/NOr"cX[RU5 [RU5 grH)rrKrY)rs r#register_patch IpuDynamicPatcher.register_patch?s--l;,,\:r"cP[RHupn[XU5 M grH)rrIsetattr)modulekeyattrs r# release_patchIpuDynamicPatcher.release_patchDs"!2!@!@ F F &"Ar")r:rH)rrrrrrIr staticmethodr0rKrYr\rcr!rr"r#rr|sM 7;h h T< < | P P;;''r"rcf\rSrSr%SrS\S'S\S'S\S'SSjrSS jrSS jrSS jr SS jr SSS jjr S S!Sjjr S"S#Sjjr S$S%SjjrS&SjrS'SjrS(SjrS(Sjr\S)Sj5r\S*Sj5r\S*Sj5r\S*Sj5rSrg)+ IpuStrategyiJar Help users precisely control the graph building in :code:`paddle.static.IpuCompiledProgram`. Returns: The IpuStrategy instance. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:IPU) >>> import paddle >>> import paddle.static as static >>> paddle.enable_static() >>> ipu_strategy = static.IpuStrategy() r'has_custom_ops list[str]custom_op_namesr<c<[R"5(aT[R"5UlSSS.SSS.nURR U5 SUl/UlSUlO [S5eSSK J n U"5(aUR5 gg) Nrr)on_chipuse_replicated_tensor_sharding)location_optimizer+accumulation_and_replication_reduction_type4mean_accumulation_and_replication_reduction_strategyFTz\Can not use IpuStrategy in non IPU compiled environment, please re-compile with WITH_IPU=ON.in_dynamic_mode) ris_compiled_with_ipurg _ipu_strategyrQrhrjr<rrrrr\)rdefault_optionsrrs r#rIpuStrategy.__init__bs  $ $ & &!%!1!1!3D  !67'@AHI O    * *? ;"'D #%D $D n  +       ! r"c.[RU5 g)a Register patch function to support dynamic to static on IPU. This operation would break the dy2static functionality on CPU. Use `release_patch` to release the patch. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:IPU) >>> import paddle >>> import paddle.static as static >>> ipu_strategy = static.IpuStrategy() >>> ipu_strategy.register_patch() N)rr\rs r#r\IpuStrategy.register_patchzs" ((.r"c,[R5 g)a Release the registered IPU functions. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:IPU) >>> import paddle >>> import paddle.static as static >>> ipu_strategy = static.IpuStrategy() >>> ipu_strategy.release_patch() N)rrcrs r#rcIpuStrategy.release_patchs '')r"cSSKJn U"5(a3XlURU5nURR U5 g[ S5e)aj Set optimizer to ipu_strategy in dynamic mode. Args: optimizer (Optimizer): Optimizer to be used in training. Returns: None. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:IPU) >>> import paddle >>> import paddle.static as static >>> linear = paddle.nn.Linear(10, 10) >>> optimizer = paddle.optimizer.SGD(learning_rate=0.01, ... parameters=linear.parameters()) >>> ipu_strategy = static.IpuStrategy() >>> ipu_strategy.set_optimizer(optimizer) rrqz,Only needs to set optimizer in dynamic mode.N)rrrrparse_optimizerrtrQr)rr(rroptimizer_attrss r# set_optimizerIpuStrategy.set_optimizersE. +   'O"229=O    * *? ;MN Nr"c`^U4SjnU/nSS0nUHnURU"55 M U$)a Parse optimizer attributes for IPU dynamic to static support. Currently only support parse lr. Args: optimizer (Optimizer): Optimizer to be parsed. Returns: Dict. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:IPU) >>> import paddle >>> import paddle.static as static >>> linear = paddle.nn.Linear(10, 10) >>> optimizer = paddle.optimizer.SGD(learning_rate=0.01, ... parameters=linear.parameters()) >>> ipu_strategy = static.IpuStrategy() >>> attrs = ipu_strategy.parse_optimizer(optimizer) c>SSKJn [TR[5(aSTR0$[TRU5(aSTR50$g)NrrNr;)rXrOr~_learning_rater6)rOr(s r#get_lr+IpuStrategy.parse_optimizer..get_lrsW 7)22E::i6677I44kBBi66899Cr"r.T)update)rr(rattr_fnr}fns ` r#r|IpuStrategy.parse_optimizers;2 :('.B  " "24 (r"cdUS:XaU(a [S5eUUUUS.nURU5 g)a Set graph configuration to the IpuStrategy instance. Args: num_ipus (int, optional): Number of IPU devices. Default 1, which means only use 1 IPU. is_training (bool, optional): True is training graph, False is inference graph. Default True, which means is training mode. batch_size (int, optional): The batch-size in the graph. Used to make the graph batch-size fixed, if the batch-size in the graph is dynamic. Default 1, which means the batch-size would be set 1, if the batch-size is dynamic. enable_manual_shard (bool, optional): Enable graph sharding or not. Only if num_ipus > 1, enable_manual_shard is able to be set True. Default False, which means disabled. Returns: None. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:IPU) >>> import paddle >>> import paddle.static as static >>> paddle.enable_static() >>> ipu_strategy = static.IpuStrategy() >>> ipu_strategy.set_graph_config(num_ipus=1, ... is_training=True, ... micro_batch_size=1, ... enable_manual_shard=False) rzAOnly if num_ipus > 1, enable_manual_shard is able to be set True.)r0r(r2rDN)rrQ)rr0r(r2rDoptionss r#set_graph_configIpuStrategy.set_graph_configsDJ q=0S !& 0#6   !r"cURS5nU(dU(a [S5eUUUUS.nURU5 g)a Set pipelining configuration to the IpuStrategy instance. Used to optimize the throughput performance. Args: enable_pipelining (bool, optional): Enable data pipelining between subgraphs. Only if enable_manual_shard=True, enable_pipelining is able to be set True. Default False, which means disabled. batches_per_step (int, optional): Set the batches per run in data pipelining mode. Only if enable_pipelining=True, batches_per_step is able to be set > 1. Default 1, which means no data pipelining. enable_gradient_accumulation (bool, optional): Enable to accumulate gradients before updating the weights in training mode. Only if enable_pipelining=True, enable_gradient_accumulation is able to be set True. Default False, which means no gradient accumulation. accumulation_factor (int, optional): Specify the number of micro-batches to accumulate before applying the varUpdate. Default 1, which means disable the accumulation. Returns: None. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:IPU) >>> import paddle >>> import paddle.static as static >>> paddle.enable_static() >>> ipu_strategy = static.IpuStrategy() >>> ipu_strategy.set_pipelining_config(enable_pipelining=False, ... batches_per_step=1, ... enable_gradient_accumulation=False, ... accumulation_factor=1) rDzKOnly if enable_manual_shard=True, enable_pipelining is able to be set True.)rAr1rBrCN) get_optionrrQ)rrAr1rBrCrDrs r#set_pipelining_config!IpuStrategy.set_pipelining_configsPN#oo.CD"'8] "3 0,H#6   !r"c.SU0nURU5 g)a4 Set half computation configuration to the IpuStrategy instance. Used to optimize the performance. Args: enable_fp16 (bool, optional): Enable FLOAT16 mode and transform FLOAT32 to FLOAT16. Default False, which means disable FLOAT16 mode. Returns: None. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:IPU) >>> import paddle >>> import paddle.static as static >>> paddle.enable_static() >>> ipu_strategy = static.IpuStrategy() >>> ipu_strategy.set_precision_config(enable_fp16=False) r*N)rQ)rr*rs r#set_precision_config IpuStrategy.set_precision_configKs 0 ;  !r"NcUcUnUUUUS.nURSU05 URRU5 UR(dSUlgg)a\ Add a mapping to use popart custom ops running on the IPU. Args: paddle_op(str): the name of custom op in paddle. popart_op(str): the name of custom op in popart. domain(str): domain name of custom op in popart. version(int): version of custom op in popart. Returns: None. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:IPU) >>> import paddle >>> import paddle.static as static >>> paddle.enable_static() >>> ipu_strategy = static.IpuStrategy() >>> ipu_strategy.add_custom_op('paddle_relu', 'popart_relu') N)rrrrrET)rQrjr^rh)rrrrrrEs r# add_custom_opIpuStrategy.add_custom_opgsbF  !I""  +y12 ##I."""&D #r"cURRU5 S1nUR5U- (aSUlgg)a Set options from dict. Args: options(dict): dict of options. Returns: None. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:IPU) >>> import paddle >>> import paddle.static as static >>> paddle.enable_static() >>> ipu_strategy = static.IpuStrategy() >>> options = {'num_ipus':1, 'enable_fp16': True} >>> ipu_strategy.set_options(options) # type: ignore[arg-type] r;TN)rtrQkeysr<)rrrecompile_white_lists r#rQIpuStrategy.set_optionss<0 &&w/ $v <<>0 0 $D  1r"c>URRU5S$)ax Get option. Args: option(str): name of option. Returns: option value. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:IPU) >>> import paddle >>> import paddle.static as static >>> paddle.enable_static() >>> ipu_strategy = static.IpuStrategy() >>> num_ipus = ipu_strategy.get_option('num_ipus') r)rtr)roptions r#rIpuStrategy.get_options .!!,,V4W==r"c:URRU5 g)a Enable PopART pattern to optimize the graph. Args: pattern(string): the name of the pattern. Returns: None. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:IPU) >>> import paddle >>> import paddle.static as static >>> paddle.enable_static() >>> ipu_strategy = static.IpuStrategy() >>> ipu_strategy.enable_pattern("ViewSimplifyPattern") N)rtenable_patternrpatterns r#rIpuStrategy.enable_patterns. ))'2r"c:URRU5 g)a Disable PopART pattern. Args: pattern(string): the name of the pattern. Returns: None. Examples: .. code-block:: python >>> # doctest: +REQUIRES(env:IPU) >>> import paddle >>> import paddle.static as static >>> paddle.enable_static() >>> ipu_strategy = static.IpuStrategy() >>> ipu_strategy.disable_pattern("ViewSimplifyPattern") N)rtdisable_patternrs r#rIpuStrategy.disable_patterns. **73r"c$URS5$)z: Get the number of IPU devices from IpuStrategy instance. r0rrs r#r0IpuStrategy.num_ipuss z**r"c$URS5$)zE Get the boolean of training or inference from IpuStrategy instance. r(rrs r#r(IpuStrategy.is_training }--r"c$URS5$)zH Get the boolean of enable pipelining or not from IpuStrategy instance. rArrs r#rAIpuStrategy.enable_pipelinings 233r"c$URS5$)zC Get the boolean of float16 mode or not from IpuStrategy instance. r*rrs r#r*IpuStrategy.enable_fp16rr")rtrrjrhr<)rr)r(rrr)r(rrr%)rTrF) r0rr(r'r2rrDr'rr)FrFr) rAr'r1rrBr'rCrrr)F)r*r'rr)Nz custom.opsr) rrrz str | Nonerrrrrr)rr%rr)rrrr)rrrr)rr)rr')rrrrrr rr\rcr~r|rrrrrQrrrpropertyr0r(rAr*r!rr"r#rgrgJsi&"0/&*$O@%R !$) /"/"/" /" " /"  /"f#( !-2#$ 2"2"2"'+ 2" ! 2"  2"h">!%" .'.'.' .'  .'  .'`%<>23242++ .. 44 ..r"rgcD\rSrSrSrSSSjjrS SjrSrg) r ia The IpuCompiledProgram is used to transform a program to a ipu-target program, such as forward graph extraction, computing graph transformation, useless scale Ops clean, etc. Args: program(Program, optional): This parameter represents the :code:`Program` to be executed. Default is None, which means the program will be set to the default program :code:`paddle.static.default_main_program()` . scope(Scope, optional): The scope used to run this program, you can switch it to different scope. Default is None, which means use the global scope :code:`paddle.static.global_scope()` . ipu_strategy(IpuStrategy, optional): This argument is used to build the program with the specified options, such as half computation, training or inference session, the number of IPUs, etc. Default is None, which means build the program based on the default `ipu_strategy`. Returns: IpuCompiledProgram Example: .. code-block:: python >>> # doctest: +REQUIRES(env:IPU) >>> import paddle >>> import paddle.static as static >>> paddle.enable_static() >>> a = static.data(name='data', shape=[None, 1], dtype='int32') >>> b = a + 1 >>> main_prog = static.default_main_program() >>> ipu_strategy = static.IpuStrategy() >>> ipu_strategy.set_graph_config(num_ipus=1, is_training=True, micro_batch_size=1) >>> ipu_strategy.set_pipelining_config(enable_pipelining=False, batches_per_step=1, enable_gradient_accumulation=False, accumulation_factor=1) >>> ipu_strategy.set_precision_config(enable_fp16=False) >>> ipu_compiled_program = static.IpuCompiledProgram( ... main_prog, ... ipu_strategy=ipu_strategy) Nc<[R"5(d [S5eUc[R"5n[ U[R 5(d[S[U535eXl SUl UbX l O#SSK nURR5Ul UbX0lO[!5UlUR"(a[%UR&5UlOSUl[R*R-5Ulg)NzECan not use this function since PaddlePaddle is not compiled with IPUz8The type of program is wrong, expected Program, but got Frr)rrsrr default_main_programr~rrrSrrrrrrrtrgrhrrj_custom_op_names IpuBackend get_instance_backend)rr`rrrs r#rIpuCompiledProgram.__init__Hs ((**W  ?446G'9#4#455J4PW=/Z    K  --446DK  #!- !,D   & &$' (D(D$ED !$&D !446 r"cURRUR5 URRURR5 UR R 5n/n[UR5HSupVURRS5 URS:XdURS:XdMBURU5 MU USSS2HnURU5 M SH,nURU5(dMURU5 M. UR RR!5 ["R$"UR R5UlURR((a>SS/n U H4n ["R*"U 5n U R-UR&5 M6 /S Qn U HLn ["R*"U 5n U S :XaU R/S U5 U R-UR&5 MN ["R*"S 5n UR0(aU R/S UR05 U R-UR&5 /SQn U HXn ["R*"U 5n U R/S U5 U R/SU5 U R-UR&5 MZ ["R*"S5n ["R2"5n U R5SU 5 U R-UR&5 [6R8R;U 5n[=UR S5(asUR R>R@nUR R>UlUR R 5nURBUUR>l"UR 5nUH/nURGU5nURRIS5 M1 [=US5(dUR Ul%SURl&U$)a This interface is used to compile the input Program to a program to run the model on the ipu. Args: feed_list(list): This parameter represents the input Tensors of the model. fetch_list(list): This parameter represents the Tensors that need to be returned after the model. Returns: Program Example: .. code-block:: python >>> # doctest: +REQUIRES(env:IPU) >>> import paddle >>> import paddle.static as static >>> paddle.enable_static() >>> a = static.data(name='data', shape=[None, 1], dtype='int32') >>> b = a + 1 >>> main_prog = static.default_main_program() >>> ipu_strategy = static.IpuStrategy() >>> ipu_strategy.set_graph_config(num_ipus=1, is_training=True, micro_batch_size=1) >>> ipu_strategy.set_pipelining_config(enable_pipelining=False, batches_per_step=1, enable_gradient_accumulation=False, accumulation_factor=1) >>> ipu_strategy.set_precision_config(enable_fp16=False) >>> program = static.IpuCompiledProgram( ... main_prog, ... ipu_strategy=ipu_strategy).compile([a.name], [b.name]) FrYfetchNrZ)rYroptimizer_extract_passoptimizer_state_align_pass)forward_graph_extract_passinfer_shape_passavg_shard_passdelete_scale_op_passrr popart_canonicalization_pass custom_ops)ipu_inplace_passipu_graph_builder_passipu_runtime_replacer_passr graph_to_program_passr` lr_scheduler org_program)'r set_scoperset_ipu_strategyrtrr\r[r]r set_is_targetrSr^r_has_var _remove_varflushrr rr(get_passapplyrr ProgramDesc set_not_ownedr r_construct_from_deschasattrr _var_namertlr_varrxset_need_check_feedrr<)rr r r\need_to_remove_op_indexrbrRrcrxpasses pass_namea_pass convert_passrr` lr_var_nameprogram_global_block feed_namefeed_vars r#r IpuCompiledProgram.compilersaJ  , &&t'9'9'G'GH}}113 "$|//0EA GG ! !% (ww& BGGw$6'..q11 -TrT2E  # #E *3%C##C((((-%   "jj!3!34    ) )(,F$ y1 T[[)$   I]]9-F.. ; 2 LL %  =>  JJ|T%:%: ; T[[!   I]]9-F JJ{I . JJ|Z 0 LL %  }}%<= !""9d34;;'##88> 4==. 1 1--44>>K#'==#=#=G  ==557L*6*;*;K*HG ' '335"I+// :H MM - -e 4#w .."&--G */'r")rrrrrtrr)NNN)r`zProgram | Nonerz _Scope | NonerzIpuStrategy | Nonerr)r rir rirr)rrrrrrr r!rr"r#r r sE(X#'#+/ (7(7(7) (7  (7T}r"r )& __future__rrtypingrrrrrr r r r paddle.base.corer rpaddle.optimizerr paddle.staticrrr%__all__r{r NativeConfigrAnalysisConfigrrrMrWrdrpryrrgr rr"r#rs# 00::.*%I iu@ $$22 %%)) __  1~~BK'K'\P.P.fRRr"