o j@sddlZddlZddlmZmZddlmZmZmZgZej j Z ej j Z ej Z ejZejZddZddZd d Zd d Zd dZddZGdddZGdddZGdddZGdddZdS)N)core framework) cpu_places cuda_places xpu_placescCst}|||SN)rZPlaceZ set_place)placepr U/var/www/html/Deteccion_Ine/venv/lib/python3.10/site-packages/paddle/base/compiler.py _place_objs r cCs4|r|nt}|jD] }|jdvrdSq dS)N)sendrecvTF)rdefault_main_program global_blockopstype) main_programmainopr r r _is_pserver_mode$s  rcCs>|D]}|r|dur|drdSqdS)NZ_gradTF)nodesZis_oprrendswith)graphnoder r r _has_backward_op,s  rcCsVg}t|jD]\}}|jdkr||q |dddD] }||qdS)Nfeed) enumeraterrrappend _remove_op)programZpop_idxirindexr r r _prune_feed_ops7s  r%cCsP|jD]"}tj}tjjj}||jvr%t|| t|kr%dSqdS)NTF) rrZop_proto_and_checker_makerZOpRoleZOptimizeZkOpRoleVarAttrNameZ attr_namesintZ all_attrsZkOpRoleAttrName)blockrZop_makeroptimizer r r _has_optimize_opAs  r)cCs@|}|j|d}|durdSt|ddpt|dd}| S)NTZ_is_distributedFis_distributed)rvarsgetgetattr)r"var_namer'varr*r r r _should_broadcast_or_not_existsLsr0c@sLeZdZdZdddZddZddZdd d Zd d Zd dZ ddZ dS)CompiledPrograma :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 operators' 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]) NcCst|tjr ||_d|_nt|tjr"t|t|j|_||_nt dt |d|_ d|_ d|_ d|_d|_d|_d|_||_d|_dS)Nz[The type of program_to_graph parameter is wrong, expected Graph or Program, but received %sF) isinstancerGraph_graph_programrProgramr%desc TypeErrorr_scope_place _executor _compiled _is_inference_share_vars_from_places_build_strategy_exec_strategy)selfZprogram_or_graphZbuild_strategyr r r __init__s*   zCompiledProgram.__init__cCs:|jrJdtt|tt|tgsJd|_||_|S)zAdd inference optimize Args: config: instance of `NativeConfig` or `AnalysisConfig` to create predictor Returns: self z6Already compiled with inference, cannot be recompiled.T)r=anyr2InferNativeConfigInferAnalysisConfig _infer_config)rBconfigr r r _with_inference_optimizes z(CompiledProgram._with_inference_optimizecCstd)NzFSubclass of CompiledProgram should implement _with_distributed method.)NotImplementedErrorrBr r r _with_distributedsz!CompiledProgram._with_distributedc Cs|jr|r tjd|jjdurtd|jj|_n |dus%Jdg|_t|t t fs8Jd t ||j durAt|_ t|j|j _|jdurQt|_||j_|jjdkr|jjtjkrkt|d|j_n|jjtjkrwd|j_nt|d|j_d tvrtd r|jjdkrtd d|j_|jr|j jdkr|jjr|jj}|j jt|ksJd ||j _ |jr|jj!|j _"|jj#|j _$|jj%|j _&|j j'rd |j _(|jdur |jj)r |jjtjksJd |j jt|dksJd|j j*tj+j,ks Jdd|j _-g|_.|j/0D];}|1rO|2durO|23rO|2 tj4j5j6krO|7}|jdurOt8|j|rO|j.9|7qt t:t;|}t t<|j.|_.|j.=t>rnt?dt@||j.d|jA|j|j|j |j/S)Nz*share_vars_from is set, scope is ignored. zSThe shared Program is not compiled and executed, so there is no variables to share.zOCurrently, The places type can only be list or tuple, but the input type is {}.rrZFLAGS_use_cinnzwAt present, when CINN is turned on, each process can only contain one thread, so reset the number of threads to 1 here.z5The trainer numbers is not equal to endpoint numbers.Tz%DGC only used under CUDA environment.z.DGC is not avaliable for single card training.zADGC only can be used for AllReduce BuildStrategy.FzBCUDA Graph is not allowed to capture when running the first batch.)Br>sysstderrwriter; ValueErrorZ local_scopesZ _local_scopesr2listtupleformatrr@ BuildStrategyrr5Zis_distributionrAExecutionStrategyZ _use_deviceZ num_threads DeviceTypeCUDAlenXPUrglobalswarningswarnZ num_trainersZ_trainers_endpointsZtrainers_endpointsZ_nccl_comm_numZ nccl_comm_numZ_use_hierarchical_allreduceZuse_hierarchical_allreduceZ$_hierarchical_allreduce_inter_nranksZ#hierarchical_allreduce_inter_nranksZsync_batch_normZenable_sequential_executionZ _enable_dgcZreduce_strategyZReduceStrategyZ AllReduceZfuse_all_reduce_opsZ_persistable_varsr4rZis_varr/ persistableZVarDescZVarTypeZRAWnamer0r mapr setsortZis_cuda_graph_capturing RuntimeErrorParallelExecutorr9)rBplaces use_devicescopeZtpsrrar r r _compile_data_parallels                z&CompiledProgram._compile_data_parallelcCs t|jSr)rZcreate_paddle_predictorrGrKr r r _compile_inference@s z"CompiledProgram._compile_inferencecCs|jr|r|j|krtd|r|j|std|Sd|_||_||_|jr/||_|S|jg|_t |jt j r?t j }nt |jt jrJt j}nt j}|j||j|jd|_|S)aCompile 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)rhrirg)r<r9rSr:Z_equalsr=rkr;r?r2r CUDAPlacerYrZXPUPlacer\ZCPUrj)rBrir rhr r r _compileCs,    zCompiledProgram._compilecCsn|du}|r|D]}||ksJdqnt|tjr"t}n t|tjr,t}nt}|s5Jd|S)Nz7Place type not match. You may set wrong type of places.zNo places for execution.)_typer2rrlrrmrr)rBr Z place_listZ has_set_placer r r r _get_placesis   zCompiledProgram._get_placesr) __name__ __module__ __qualname____doc__rCrIrLrjrkrnrpr r r r r1Ws 1  &r1c@s\eZdZdZgZddZe dddZeddZed d Z ed d Z ed dZ dS)IpuDynamicPatcherz1 Patcher for IPU dynamic2static support. cCsdSrr rKr r r rCszIpuDynamicPatcher.__init__Nc sddlddlmddlm}ddlm}j}j}j }j |fdd}j r8|j d d jD]} | j} | } | | q;|r_d d |d dDndd |Ddd |Djr|_j} | jD]^\} }|D]U\}}| jj|jd|j|j|jdd}| |}||| jj|j j!j"dddWdn1swY#|j}|}|||| j| |<qq||fdd}|}|_S)zD Convert the ConcreteProgram to IPUConcreteProgram. rNrO)backward)switch_to_static_graph) device_guardcs<j}|jj}j}|||Sr)rZgradients_with_optimizer _optimizerstaticZExecutorCPUPlaceZdefault_startup_programrun)r"exestartup_program)rvconcrete_program ipu_strategypaddler r append_backward_descs   zHIpuDynamicPatcher.convert_concrete_program..append_backward_descZfloat16)dtypecSg|] }|dur|jqSrra.0elemr r r z>IpuDynamicPatcher.convert_concrete_program..rcSrrrrr r r rrcSsg|]}|jqSr rrr r r rsT)rar`rrshapeZbelong_to_optimizerg)value) initializercsfjr%jj}dh|_jjjj|dd}jjjj|dt jd }|S)NZcumsumF)Zuse_fp16_guard)to_fp16_var_names)rri) enable_fp16rzampZ CustomOpListsZunsupported_listZcast_model_to_fp16rZcast_parameters_to_fp16r{IpuCompiledProgramcompile)Zamp_listrr")r feed_list fetch_listrrrir r func_compiles* z@IpuDynamicPatcher.convert_concrete_program..func_compile)$rbaservZbase.dygraph.baserwZbase.frameworkrxinputsoutputsr~rz global_scoperto parametersr/raZ get_tensorrZ_share_data_with is_trainingrryZ _accumulatorsitemshelperZcreate_global_variablerrrZ_get_device_for_paramZset_variable_initializernnrConstantZfind_var)rrclass_instancerwrxrrr~rZparam_or_bufferZparam_or_buffer_tensorZ src_tensor optimizerkv param_nameZvar_tmpr/ZdeviceZparam_or_lr_tensorZ optim_tensorrrr )rvrrrrrrir convert_concrete_programsx            z*IpuDynamicPatcher.convert_concrete_programcsbddlmddlmddlmmm}|j}fdd}||_t j |d|gdS) zMonkey patch ProgramCache discriptor to support dynamic2static in IPU. Args: ipu_strategy: The ipu_strategy used in dynamic graph. Returns: None r) logging_utils)partial_program_from)MAX_TRACED_PROGRAM_COUNTCacheKey ProgramCachecst|stdt|jt|}||_||jvsjr`||jvr'd|jr2js2d| |\}}t ||j }|||j duf|j|<t |j}|kr`d||j|S)Nz.type(item) should be CacheKey, but received %sz3ipu_strategy chances detected. Please sync weights.zadynamic2static on IPU doesn't support mutiple caches. Please make suredynamic inputs is not used.zCurrent traced program number: {} > `max_tracing_count`:{}. 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.)r2rSrrqhashZ _recent_keyZ_caches need_compiler_Z _build_oncerurrr[rV)rBitemZitem_idr_Zcurrent_tracing_countrrrrrr r patch_gettersF      z;IpuDynamicPatcher.patch_program_cache..patch_getter __getitem__N) Zpaddle.jit.dy2staticrZ$paddle.jit.dy2static.partial_programrZ'paddle.jit.dy2static.program_translatorrrrrru patcher_cacher )rrZ old_getterrr rr patch_program_caches )z%IpuDynamicPatcher.patch_program_cachecs>ddlm}|jdfdd }||_tj|dgdS)Nr LRSchedulercs||d|jidS)Nlr) set_optionsZlast_lr)rBepochrZold_stepr r patch_step:s z8IpuDynamicPatcher.patch_lr_scheduler..patch_stepstepr)paddle.optimizer.lrrrrurr )rrrr rr patch_lr_scheduler2s z$IpuDynamicPatcher.patch_lr_schedulercCst|t|dSr)rurr)rr r r register_patchAs z IpuDynamicPatcher.register_patchcCs"tjD] \}}}t|||qdSr)rursetattr)modulekeyattrr r r release_patchFszIpuDynamicPatcher.release_patchr) rqrrrsrtrrC staticmethodrrrrrr r r r ru{s j A  ruc@seZdZdZddZddZddZdd Zd d Z d)ddZ   d*ddZ d+ddZ d,ddZ ddZ ddZddZdd Zed!d"Zed#d$Zed%d&Zed'd(ZdS)- IpuStrategya 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() cCsntr"t|_dddddd}|j|d|_g|_d|_ntdddl m }|r5| dSdS) Nrr)Zon_chipZuse_replicated_tensor_sharding)Zlocation_optimizerZ+accumulation_and_replication_reduction_typeZ4mean_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_ipur _ipu_strategyrhas_custom_opscustom_op_namesrrerrr)rBZdefault_optionsrr r r rC`s&    zIpuStrategy.__init__cCst|dS)a Register patchs 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)rurrKr r r rxszIpuStrategy.register_patchcCs tdS)aa 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)rurrKr r r rs zIpuStrategy.release_patchcCs:ddlm}|r||_||}|j|dStd)a 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) rrz,Only needs to set optimizer in dynamic mode.N)rrryparse_optimizerrrre)rBrroptimizer_attrsr r r set_optimizers  zIpuStrategy.set_optimizercs4fdd}|g}ddi}|D]}||q|S)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) cs>ddlm}tjtrdjiStj|rdiSdS)Nrrr)rrr2Z_learning_ratefloatrrr r get_lrs     z+IpuStrategy.parse_optimizer..get_lrZ is_dynamicT)update)rBrrZattr_fnrfnr rr rs zIpuStrategy.parse_optimizerrTFcCs0|dkr |r td||||d}||dS)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 dynamice. 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.)num_ipusrmicro_batch_sizeenable_manual_shardN)rer)rBrrrroptionsr r r set_graph_configs %zIpuStrategy.set_graph_configcCs6|d}|s |r td||||d}||dS)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) rzKOnly if enable_manual_shard=True, enable_pipelining is able to be set True.)enable_pipeliningbatches_per_stepenable_gradient_accumulationaccumulation_factorN) get_optionrer)rBrrrrrrr r r set_pipelining_configs 'z!IpuStrategy.set_pipelining_configcCsd|i}||dS)a 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) rN)r)rBrrr r r set_precision_configIsz IpuStrategy.set_precision_configN custom.opscCsH|dur|}||||d}|d|i|j||js"d|_dSdS)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) paddle_op popart_opdomainversion custom_opT)rrr r)rBrrrrrr r r add_custom_opes  zIpuStrategy.add_custom_opcCs,|j|dh}||rd|_dSdS)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) rTN)rrkeysr)rBrZrecompile_white_listr r r rs   zIpuStrategy.set_optionscCs|j|dS)a 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)rr)rBoptionr r r rzIpuStrategy.get_optioncC|j|dS)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)renable_patternrBpatternr r r rrzIpuStrategy.enable_patterncCr)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)rdisable_patternrr r r rrzIpuStrategy.disable_patterncC |dS)zJ Get the number of IPU devices from IpuStrategy instance. rrrKr r r r zIpuStrategy.num_ipuscCr)zU Get the boolean of training or inference from IpuStrategy instance. rrrKr r r rrzIpuStrategy.is_trainingcCr)zX Get the boolean of enable pipelining or not from IpuStrategy instance. rrrKr r r rrzIpuStrategy.enable_pipeliningcCr)zS Get the boolean of float16 mode or not from IpuStrategy instance. rrrKr r r rrzIpuStrategy.enable_fp16)rTrF)FrFr)F)Nrr)rqrrrsrtrCrrrrrrrrrrrrpropertyrrrrr r r r rLs@ ) 3 4 ,   rc@s"eZdZdZdddZddZdS)ral 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) NcCststd|durt}t|tjstdt|||_ d|_ |dur,||_ n ddl }|j |_ |dur>||_nt|_|jrLt|j|_nd|_tj|_dS)NzECan not use this function since PaddlePaddle is not compiled with IPUz:The type of program is wrong, expected Program, but got %sFrr )rrrSrrr2r6r8rr5r<r9rrzrrrrrcr_custom_op_namesZ IpuBackendZ get_instance_backend)rBr"rirrr r r rCBs2  zIpuCompiledProgram.__init__cCsR|j|j|j|jj|j}g}t|jD]\}}|j d|j dks/|j dkr4| |q|dddD]}| |q>> # 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]) FrfetchNr)rrZoptimizer_extract_passZoptimizer_state_align_pass)Zforward_graph_extract_passinfer_shape_passZavg_shard_passZdelete_scale_op_passrrZpopart_canonicalization_passZ custom_ops)Zipu_inplace_passZipu_graph_builder_passZipu_runtime_replacer_passrZgraph_to_program_passr" lr_scheduler org_program)'rZ set_scoper9Zset_ipu_strategyrr5rrrr7Z set_is_targetrr r!Zhas_varZ _remove_varflushrr3r4rZget_passapplyrcrZ ProgramDescZ set_not_ownedrr6Z_construct_from_deschasattrrZ _var_namer+Zlr_varr/Zset_need_check_feedrr)rBrrrZneed_to_remove_op_indexr#rr$r/ZpassesZ pass_nameZa_passZ convert_passr7r"Z lr_var_nameZprogram_global_blockZ feed_nameZfeed_varr r r rhst%                        zIpuCompiledProgram.compile)NNN)rqrrrsrtrCrr r r r rs * &r)rPr^rMrrrrr__all__rfrXrWZ NativeConfigrEZAnalysisConfigrFrYr rrr%r)r0r1rurrr r r r s4    &RN