+ jH^RIHt^RIt^RIt^RIt^RIt^RIt^RIHtH t ^RI H t ^RI H t ^RIHtHt^RIHtHt^RIHt^RIt^RIHuHt^R IHt^R IHtHtH t H!t!H"t"^R I#H$t$^R I%H&t&^R I'H(t(H)t)^RI*H+t+H,t,]'d ^RI-H.t.H/t/.R.Ot0Rt1]2!4t3]4^3Rlt5RRlt6!RR]Pn4t8Rt9!RR]4t:RRlt;!RR4t<!R R] 4t=R!R"lt>R#^R$^R%^/R&R'llt?R(R)lt@R/R*R+lltA!R,R]<4tB!R-R]:4tCR#)0) annotationsN)ABCabstractmethod)Enum)partial)Any TYPE_CHECKING) deprecatedSelf)warn)_get_privateuse1_backend_name)_add_execution_trace_observer!_disable_execution_trace_observer _enable_execution_trace_observer_ExperimentalConfig _remove_execution_trace_observer) is_fbcode)1profiler_allow_cudagraph_cupti_lazy_reinit_cuda12)kineto_availableProfilerActivity) MemoryProfileMemoryProfileTimeline)CallableIterableProfilerActionprofileExecutionTraceObserver ProfilerStepcdV\9d%\PV4\WVR7R#R#))category stacklevelN)_WARNINGS_SHOWNaddr )msgr r!s&&&X/home/luca/screen-checking/.venv/lib/python3.14/site-packages/torch/profiler/profiler.py _warn_oncer&1s' /!C  S ;"c V^8dQhRRRR/#)experimental_config_ExperimentalConfig | Nonereturnzdict[str, Any])formats"r% __annotate__r/7s 6 63 6 6r'cVf/#\VRR4pV'g/#\P!V4p\ T\ 4'dT#/# \PdRT/u#i;i)Ncustom_profiler_configbackend)getattrjsonloadsJSONDecodeError isinstancedict)r*rawparseds& r%_parse_custom_profiler_configr;7st" %'? FC   C --6525    3 sAA+*A+c ]tRt^FtRtRtRtR#) _NumpyEncoderzr Json encoder for numpy types (np.int, np.float, np.array etc.) Returns default encoder if numpy is not available c ^RIp\ YP 4'd \T4#\ YP4'd \T4#\ YP4'dTP4#\PP Y4# \d#\PP Y4u#i;i)zEncode NumPy types to JSONN) numpy ImportErrorr4 JSONEncoderdefaultr7integerintfloatingfloatndarraytolist)selfobjnps&& r%rB_NumpyEncoder.defaultLs 7  c:: & &s8O [[ ) ):  ZZ ( (::< ##++D6 6 7##++D6 6 7sB*C C r-N)__name__ __module__ __qualname____firstlineno____doc__rB__static_attributes__r-r'r%r=r=Fs  7r'r=c>\PP4#)a Returns a set of supported profiler tracing activities. Note: profiler uses CUPTI library to trace on-device CUDA kernels. In case when CUDA is enabled but CUPTI is not available, passing ``ProfilerActivity.CUDA`` to profiler results in using the legacy CUDA profiling code (same as in the legacy ``torch.autograd.profiler``). This, in turn, results in including CUDA time in the profiler table output, but not in the JSON trace. )torchautograd_supported_activitiesr-r'r%supported_activitiesrW\s >> / / 11r'cJ]tRt^jtRt]R4t]R4t]R4tRt R#)_ITraceObserverzZAbstract interface for a Trace observer. This satisfies 3 methods: start, stop and cleanupc R#Nr-rIs&r%start_ITraceObserver.startn r'c R#r[r-r\s&r%stop_ITraceObserver.stoprr_r'c R#r[r-r\s&r%cleanup_ITraceObserver.cleanupvr_r'r-N) rMrNrOrPrQrr]rardrRr-r'r%rYrYjsC9      r'rYc V^8dQhRRRR/#)r) activitiesz>Iterable[ProfilerActivity | dict[ProfilerActivity, list[str]]]r,z>tuple[set[ProfilerActivity], dict[ProfilerActivity, set[str]]]r-)r.s"r%r/r/{s//N/C/r'c\4p/pVFp\V\4'd)W19d\RV R24hVP V4KA\V\ 4'dOVP 4F8wrEWA9d\RV R24hVP V4\V4W$&K: K\R\V4 24h W3#)a.Parse a mixed activities list into a set of activities and a filter dict. Each item is either a bare ``ProfilerActivity`` (collect all defaults) or a ``dict[ProfilerActivity, list[str]]`` (collect only the named subset). An empty list value (e.g. ``{CUDA: []}``) means collect nothing for that group. z Activity z specified more than oncez'Expected ProfilerActivity or dict, got ) setr7r ValueErrorr#r8items TypeErrortype)rgparsed_activitiesactivity_filtersitemkeyvals& r%_parse_activitiesrs{s03u9; d, - -( 9TF2K!LMM  ! !$ ' d # # JJL+$y5N%OPP!%%c*(+C % ) Ed4j\RS S  ..r'cL]tRt^tRtRRRRRRRRRRR RR RR RR RR RRR/ RRlltRRltRRltRRltRRlt RRlt R6RRllt RRlt RR lt R7R!R"lltR#R$ltR8R%R&lltR'tR(R)ltR*R+ltR,R-ltR.tR/R0lt]!R1]R27R9R3R4ll4tR5tR#):_KinetoProfilea Low-level profiler wrap the autograd profile Args: activities (iterable): list of activity groups (CPU, CUDA) to use in profiling, supported values: ``torch.profiler.ProfilerActivity.CPU``, ``torch.profiler.ProfilerActivity.CUDA``, ``torch.profiler.ProfilerActivity.XPU``. Default value: ProfilerActivity.CPU and (when available) ProfilerActivity.CUDA or (when available) ProfilerActivity.XPU. Each item can be a ``ProfilerActivity`` enum (collects all default activity types for that group) or a ``dict`` mapping a ``ProfilerActivity`` to a list of individual activity type names to collect, e.g. ``{ProfilerActivity.CUDA: ["GPU_MEMCPY", "CUDA_RUNTIME"]}``. An empty list (e.g. ``{ProfilerActivity.CUDA: []}``) means collect nothing for that group. The same activity group must not appear more than once. See :class:`~torch.profiler.ProfilerActivity` for the valid activity type names and device-specific behavior. record_shapes (bool): save information about operator's input shapes. profile_memory (bool): track tensor memory allocation/deallocation (see ``export_memory_timeline`` for more details). with_stack (bool): record source information (file and line number) for the ops. with_flops (bool): use formula to estimate the FLOPS of specific operators (matrix multiplication and 2D convolution). with_modules (bool): record module hierarchy (including function names) corresponding to the callstack of the op. e.g. If module A's forward call's module B's forward which contains an aten::add op, then aten::add's module hierarchy is A.B .. deprecated:: ``with_modules`` is deprecated and will be removed in a future version. It only collects data for TorchScript models, which are themselves deprecated, and does nothing in eager mode. Use ``with_stack=True``, which records ``nn.Module`` events for eager models. experimental_config (_ExperimentalConfig) : A set of experimental options used by profiler libraries like Kineto. Note, backward compatibility is not guaranteed. execution_trace_observer (ExecutionTraceObserver) : A PyTorch Execution Trace Observer object. `PyTorch Execution Traces `__ offer a graph based representation of AI/ML workloads and enable replay benchmarks, simulators, and emulators. When this argument is included the observer start() and stop() will be called for the same time window as PyTorch profiler. acc_events (bool): Enable the accumulation of FunctionEvents across multiple profiling cycles post_processing_timeout_s (float): Optional timeout in seconds for post-processing profiler results. In this context, post-processing happens after the profiling itself has finished. If specified, event parsing will stop after this duration and return partial results. Useful for handling large traces that may take too long to process. .. note:: This API is experimental and subject to change in the future. Enabling shape and stack tracing results in additional overhead. When record_shapes=True is specified, profiler will temporarily hold references to the tensors; that may further prevent certain optimizations that depend on the reference count and introduce extra tensor copies. rgN record_shapesFprofile_memory with_stack with_flops with_modulesr*execution_trace_observer acc_eventscustom_trace_id_callbackpost_processing_timeout_scHV^8dQhRRRRRRRRRRRRR R R R R RRRRRRR/ #)r)rgEIterable[ProfilerActivity | dict[ProfilerActivity, list[str]]] | Nonervboolrwrxryrzr*r+r{_ITraceObserver | Noner|r}Callable[[], str] | Noner~ float | Noner,Noner-)r.s"r%r/_KinetoProfile.__annotate__sooo  o  oooo8o#9oo#;o$0o or'c  RVe\V4wVnVnM\4Vn/VnW nWPnW0nW@nW`nVeDVP'd2V'd*^RI p \R4V PV4p RV n T pWpn Wn WnWnWnRVnRVnRVnRVn\*P,VP9d RVnM\*P.VP9d RVnM|\*P0VP9d RVnMU\*P2VP9d RVnM.\*P4VP9d\74Vn/Vn/Vn\=VP4VnVP>PAR4R8H;'g%\CVP>PAR44Vn"RVn#RVn$RVn%VPD'd\*PLVP9d \OR 4h\CVP>PAR R44Vn%VP>PAR 4'd^R I(H)pV!4PU4VP>PAR 4'd^RI+H,pV!4PU4R#R#R VP>9d \OR4hR#)Nzxtrace_only=True is incompatible with with_stack=True (stack traces require event post-processing). Disabling trace_only.Fcudaxpumtiahpur2 cupti_monitorz>cupti_monitor profiler backend currently requires CPU activitycupti_monitor_async_exportenable_graph_dependencies)_GraphDependencyRecorderenable_event_node_ids)_EventNodeRecorderzKcupti_monitor_async_export is only supported with the cupti_monitor backend)-rsrgrorWrvryrwrxrz trace_onlycopyr r*r{r|r}r~profilerhas_cudagraphsmem_tl use_devicerCUDAXPUMTIAHPU PrivateUse1r preset_metadata_trace_metadatar;_custom_profiler_configgetr_use_cupti_monitor_cupti_profiler_observer_monitor_window_id_cupti_async_exportCPUrj!torch.profiler._cupti._graph_depsrarm"torch.profiler._cupti._event_nodesr)rIrgrvrwrxryrzr*r{r|r}r~rexperimental_config_copyrrs&$$$$$$$$$$$ r%__init___KinetoProfile.__init__s  !5Fz5R 2DOT224DOFHD !*$,$(  +#...  (  =AII#= $38 $ /": #6 (@%$(@%)B&-1 #48   DOO 3$DO  ! !T__ 4#DO  " "doo 5$DO  ! !T__ 4#DO  ) )T__ <;=DO02/1'D  $ $( $#'">">"B"B # ##X#X $T%A%A%E%Eo%V W  .2%.2$)  " " "##4??: T(,,,001MuU(D $++//0KLLV(*..0++//0GHHQ"$((*I*T-I-I I Jr'cV^8dQhRR/#r)r,rr-)r.s"r%r/rAstr'c FVP4VP4R#r[) prepare_trace start_tracer\s&r%r]_KinetoProfile.startAs  r'cV^8dQhRR/#rr-)r.s"r%r/rEsdr'c &VP4R#r[) stop_tracer\s&r%ra_KinetoProfile.stopEs  r'cV^8dQhRR/#rr-)r.s"r%r/rHsJ'J'tJ'r'c \\R4'd%^RIHuHpVP P VnVPeVP'g \R4VPeVP'gVP'dRM VPp\P!\P VP"9TVP$VP&VP(VP*VP,RVP.VPVP0VP2VP4'd VP4MRR7 VnVP'Ed3^RIHpRVnV!\=VP>PAR44\=VP>PAR44\=VP>PAR44VP>PAR 4\=VP>PAR 44\=VP>PAR 44\CVP>PAR ^44VPDR 7Vn#\PH!VPF4VPPK4R#) _inductorNzWarning: Profiler clears events at the end of each cycle. Only events from the current cycle will be reported. To keep events across cycles, set acc_events=True.T) use_cpurrvryrwrxrz use_kinetor*r|r}r~ro)ProfilerObserverenable_cuda_sync_eventsenable_environment_countersenable_pm_sampling pm_metricsrrpftrace_compression_level)enable_cuda_syncrrrrrr defer_export)&hasattrrTtorch._inductor.configrconfigtriton cudagraphsrrr|r&rrprofrrrrgrvryrwrxrzr*r}r~ro(torch.profiler._cupti.observers.profilerr_monitor_trace_windowrrrrDrr#_set_active_cupti_profiler_observer_prepare_trace)rIinductor_configrrs& r%r_KinetoProfile.prepare_traceHs, 5+ & & < <"1"8"8"C"CD  MM % E  MM !4???!%!8!8!8dooJ LL)--@%"00??#22??!..$($<$<??)-)F)F*.*H*H((("&!6!6DM"  " " " Q)-D &-=!%00445NO" -100445RS- $(00445IJ$ 77;;LI+/00445PQ+ '+00445LM'+.00445PRST+"55A!-D )J  4 4T5R5R S $$&r'cV^8dQhRR/#rr-)r.s"r%r/rs1-1-T1-r'c VP'dVPP4VPf \R4hVPP 4VP 'd)VP eVP P4VP'dVPRR4VP'dVPRR4VP'dVPRR4VP'dVPRR4VP'dVPRR4\4'Ed#VP4pV'd-VPR\ P"!V\$R 74Rp\'\(R 4'd(^R IHpV!\/\(P0R R 44pVP2'dXV'dVR8g\54'g9R\6P8R&VPRR4R\6P8R&VP:P=4FwrEVPWE4K R#R#)Nz2Profiler must be initialized before starting tracerw1rxrvrzrydistributedInfoclsversion) TorchVersionrz0.0z12.6DISABLE_CUPTI_LAZY_REINIT0TEARDOWN_CUPTI)r{r]rAssertionError _start_tracerr open_windowrwadd_metadata_jsonrxrvrzryr_get_distributed_infor4dumpsr=rrTtorch.torch_versionrr3rrrosenvironrrk)rI dist_info cuda_versionrkvs& r%r_KinetoProfile.start_traces  ( ( (  ) ) / / 1 ==  !UV V ""$  " " "t'D'D'P  ) ) 5 5 7      " "#3S 9 ???  " "< 5      " "?C 8      " ">3 7 ???  " "< 5   224I&&%tzz)'O Lui((<+GEMM65,QR ""","7HJJ:= 67&&'BCH 03 +,,,224&&q,55 r'cV^8dQhRR/#rr-)r.s"r%r/rs 1 1D 1r'c tVP'dVPP4VPf \R4hVP'dD\ P !R4VPe VPP4Vn VPPRRR4R#)Nz2Profiler must be initialized before stopping trace) r{rarrrrrr close_windowr__exit__r\s&r%r_KinetoProfile.stop_traces  ( ( (  ) ) . . 0 ==  !UV V  " " "  4 4T :,,8*.*G*G*T*T*V' tT40r'c V^8dQhRRRR/#)r)pathstruse_python_exportrr-)r.s"r%r/rs6J6J6J6Jr'c  VPf \R4hVP'Ed8VPpVe!VP'dVP fB\ R4Ve#VP'dVP4RVnRVnR#\P!RRRR7pVP4VPPVPVP4VPPVP VPV4VP'g)VPP4RVnRVnR#V'd*VPPWPRR 7R#VP!R 4'd\P!R RR 7;_uu_4pVPPVPVP4\#VPR 4;_uu_4p\$P"!VR4;_uu_4pVP'V4RRR4RRR4RRR4R#VPPWP4R# +'giLI;i +'giLT;i +'giR#;i)zs Exports the collected trace in Chrome JSON format. If kineto is enabled, only last cycle in schedule is exported. Nz:Profiler must be initialized before exporting chrome tracez@CUPTI monitor observer unavailable; skipping chrome trace exportw+t.jsonFsuffixdeleteTr.gzw+brrbwb)rrrr availablerr&jointempfileNamedTemporaryFilecloseexport_chrome_tracenamer set_exportrendswithopengzip writelines)rIrrobsfpfinfouts&&& r%r"_KinetoProfile.export_chrome_traces ==  L   " " "//C{#---43J3J3R V ?s}}}HHJ04-*.',,geB HHJ MM - -bggt7K7K L  ) ) 4 4''$ +++--22404-*.'   MM - -**d . ]]5 ! !,,U7CCr 11"''4;O;OP"''4((C41F1F$OOC(2G(DC MM - -d4H4H I2G1F((DCCs= AJ4 J! ;J J! J4 JJ! ! J1 ,J44 K cV^8dQhRR/#rr-)r.s"r%r/r s++$+r'c VP'd;VPe+VPP4RVnRVnR#R#R#)zBlock until every deferred cupti_monitor export is written, then unregister. No-op unless the cupti_monitor backend is active. Call on the training thread when you need the file(s) on disk; the finalize force-flushes CUPTI (safe here).N)rrrrr\s&r%wait_for_exports_KinetoProfile.wait_for_exports sF  " " "t'D'D'P  ) ) . . 0,0D )&*D #(Q "r'cV^8dQhRR/#)r)r,rr-)r.s"r%r/rs  3 r'c bVP'gR#VPpRVnRVnV#)zDetach this cycle's cupti_monitor ProfilerObserver (with its unwritten window) so the deferred export can be finalized OFF the training thread (call ``obs.join(force=False)`` on a worker). None for non-cupti backends.N)rrr)rIr s& r%take_pending_cupti_export(_KinetoProfile.take_pending_cupti_exports3&&&++(,%"& r'c V^8dQhRRRR/#)r)rrmetricr-)r.s"r%r/r!s 9 9# 9s 9r'c jVPf \R4hVPPW4#)zSave stack traces to a file Args: path (str): save stacks file to this location; metric (str): metric to use: "self_cpu_time_total" or "self_cuda_time_total" z4Profiler must be initialized before exporting stacks)rr export_stacks)rIrrs&&&r%r_KinetoProfile.export_stacks!s/ ==  !WX X}}**488r'c$V^8dQhRRRRRR/#)r)enablerrgzIterable[ProfilerActivity]r,rr-)r.s"r%r/r,s)DDD(BD Dr'c \VPfR#VPPW4R#)aToggle collection of activities on/off at any point of collection. Currently supports toggling Torch Ops (CPU) and CUDA activity supported in Kineto Args: activities (iterable): list of activity groups to use in profiling, supported values: ``torch.profiler.ProfilerActivity.CPU``, ``torch.profiler.ProfilerActivity.CUDA`` Examples: .. code-block:: python with torch.profiler.profile( activities=[ torch.profiler.ProfilerActivity.CPU, torch.profiler.ProfilerActivity.CUDA, ] ) as p: code_to_profile_0() // turn off collection of all CUDA activity p.toggle_collection_dynamic(False, [torch.profiler.ProfilerActivity.CUDA]) code_to_profile_1() // turn on collection of all CUDA activity p.toggle_collection_dynamic(True, [torch.profiler.ProfilerActivity.CUDA]) code_to_profile_2() print(p.key_averages().table( sort_by="self_cuda_time_total", row_limit=-1)) N)rtoggle_collection_dynamic)rIrrgs&&&r%r(_KinetoProfile.toggle_collection_dynamic,s#: ==  //Cr'c(V^8dQhRRRRRRRR/#)r)group_by_input_shapergroup_by_stack_nrDgroup_by_overload_nameinclude_python_functionsr-)r.s"r%r/rMs2  "  !%  #'  r'c pVPf \R4hVPPVVVV4#)aEAverages events, grouping them by operator name and (optionally) input shapes, stack and overload name. Returns an :class:`~torch.autograd.profiler_util.EventList` of the aggregated events. .. note:: To use shape/stack functionality make sure to set record_shapes/with_stack when creating profiler context manager. z8Profiler must be initialized before getting key averages)rr key_averages)rIr!r"r#r$s&&&&&r%r&_KinetoProfile.key_averagesMsC ==  J }}))  " $   r'c VPf \R4hVPe(VPP'd \ R4hVPP #)z Return the list of unaggregated :class:`~torch.autograd.profiler_util.FunctionEvent` objects, for use in the trace callback or after profiling has finished. z4Profiler must be initialized before accessing eventszhevents() is not available when trace_only=True in ExperimentalConfig. Use export_chrome_trace() instead.)rrr*r RuntimeErrorfunction_eventsr\s&r%events_KinetoProfile.eventshs\ ==  !WX X  # # /D4L4L4W4W4WI }},,,r'c$V^8dQhRRRRRR/#r)rqrvaluer,rr-)r.s"r%r/rvs!>>>C>D>r'c RVPRR4,R,pW0PV&\PP W4R#)zW Adds a user defined metadata with a string key and a string value into the trace file "z\"N)replacerrTrU_add_metadata_json)rIrqr/ wrapped_values&&& r% add_metadata_KinetoProfile.add_metadatavs> emmC77#= $1S! ))#=r'c$V^8dQhRRRRRR/#r.r-)r.s"r%r/rs!66S666r'c `W PV&\PPW4R#)z[ Adds a user defined metadata with a string key and a valid json value into the trace file N)rrTrUr3rIrqr/s&&&r%r _KinetoProfile.add_metadata_jsons$ %*S! ))#5r'c$V^8dQhRRRRRR/#r.r-)r.s"r%r/rs!***C*D*r'c "W PV&R#)z Preset a user defined metadata when the profiler is not started and added into the trace file later. Metadata is in the format of a string key and a valid json value N)rr9s&&&r%preset_metadata_json#_KinetoProfile.preset_metadata_jsons %*S!r'c  ^RIHpVP4'dVP4'gR#VP 4pRVRVP 4RVP 4RVP4RVPP4/pVR8XdD\PPP4pRPR V44VR &V#) rNr2rank world_sizepg_count pg_confignccl.c38"TFp\V4xK R#5ir[)r).0rs& r% 7_KinetoProfile._get_distributed_info..s0NAQs nccl_version)torch.distributed distributed is_availableis_initialized get_backendget_rankget_world_size get_pg_countdistributed_c10d_get_all_pg_configsrTrrDrr)rIdistr2rrJs& r%r$_KinetoProfile._get_distributed_infos(  ""$*=*=*?*?""$ w DMMO $--/ ))+ ..BBD   f  ::??224L(+0N0N(NIn %r'cV^8dQhRR/#)r)r,rr-)r.s"r%r/rs ; ; ;r'c HRpVUu.uFp\W4'dKV R2NK ppV'd\RPV4 R24hVPeVPPf \ R4h\ VPP4#uupi)rvz=Truez, z required for memory profiling.zDProfiler and kineto_results must be initialized for memory profiling)rvrwrx)r3rjrrkineto_resultsrr)rIrequiredimissings& r%_memory_profile_KinetoProfile._memory_profilesD(0I18H;aS;I  ' 233RST T == DMM$@$@$H V T]]99::Js B Bz`export_memory_timeline` is deprecated and will be removed in a future version. Please use `torch.cuda.memory._record_memory_history` and `torch.cuda.memory._export_memory_snapshot` instead.)r c$V^8dQhRRRRRR/#)r)rrdevice str | Noner,rr-)r.s"r%r/rs!2=2=32= 2=d2=r'c  $Vf`VP'd&VPR8wdVPR,pM(\PP4'dRMRp\ VP 44VnVPR4'dVP PW4R#VPR4'd\P!RR R 7;_uu_4pVPR 4'd(VP PVPV4M&VP PVPV4\VP4;_uu_4p\P!VR 4;_uu_4pVP!V4RRR4RRR4RRR4R#VP PW4R# +'giL?;i +'giLJ;i +'giR#;i) aExport memory event information from the profiler collected tree for a given device, and export a timeline plot. There are 3 exportable files using ``export_memory_timeline``, each controlled by the ``path``'s suffix. - For an HTML compatible plot, use the suffix ``.html``, and a memory timeline plot will be embedded as a PNG file in the HTML file. - For plot points consisting of ``[times, [sizes by category]]``, where ``times`` are timestamps and ``sizes`` are memory usage for each category. The memory timeline plot will be saved a JSON (``.json``) or gzipped JSON (``.json.gz``) depending on the suffix. - For raw memory points, use the suffix ``.raw.json.gz``. Each raw memory event will consist of ``(timestamp, action, numbytes, category)``, where ``action`` is one of ``[PREEXISTING, CREATE, INCREMENT_VERSION, DESTROY]``, and ``category`` is one of the enums from ``torch.profiler._memory_profiler.Category``. Output: Memory timeline written as gzipped JSON, JSON, or HTML. .. deprecated:: ``export_memory_timeline`` is deprecated and will be removed in a future version. Please use ``torch.cuda.memory._record_memory_history`` and ``torch.cuda.memory._export_memory_snapshot`` instead. Nrz:0zcuda:0cpuz.htmlrrrrz raw.json.gzwt)rrTrrMrr]rrexport_memory_timeline_htmlrrexport_memory_timeline_rawrexport_memory_timelinerrr)rIrr`r r r s&&& r%rg%_KinetoProfile.export_memory_timelinesPB >4??f#<4/%*ZZ%<%<%>%>E,D,@,@,BC  == ! ! KK 3 3D A ]]5 ! !,,U7CCr==//KK::277FKKK66rwwG"'']]c499T4+@+@DOOC(,A] DC KK . .t <,A+@]] DCCs=-BG>/ G+ G !G+ )G> G(#G+ + G; 6G>> H )rrrrrrrr|rgror}r{r*rrr~rrwrrvrryrzrxF)self_cpu_time_total)FrFFr[)rMrNrOrPrQrr]rarrrrrrrrr&r+r5rr=rr]r FutureWarningrgrRr-r'r%rurus7ro o $ o % o!o!o#o;?o<@o!o>Bo37obJ'X1-f 16Jp+  9DB 6 ->6*( ; y 2=  2=r'ruc.]tRtRtRt^t^t^t^t^t Rt R#)riaP Profiler actions that can be taken at the specified intervals. NONE, WARMUP, RECORD, and RECORD_AND_SAVE are user-facing values that may be returned from a user-provided schedule. DEVICE_STOPPED is set internally by the profiler when device collection stops early due to errors; it must not be returned from a user-provided schedule. r-N) rMrNrOrPrQNONEWARMUPRECORDRECORD_AND_SAVEDEVICE_STOPPEDrRr-r'r%rrs" D F FONr'c$V^8dQhRRRRRR/#)r)prevrcurrentr,rr-)r.s"r%r/r/s!#r'c&\RV RV R24h)zProfiler internal error: z -> z should be unreachable)r))rsrts&&r%_unreachable_transitionrvs"  #D6gY6LM r'repeat skip_firstskip_first_waitc4V^8dQhRRRRRRRRRRRRRR /#) r)waitrDwarmupactiverwrxryr,rr-)r.s"r%r/r/sP;; ; ;  ;  ;  ;;;r'c aaaaaaRVVVVVV3RllpS^8gS^8gS^8:gS^8gS^8d\RS RS RS RS RS R2 4hS^8Xd\R ^R 7V#) a Returns a callable that can be used as profiler ``schedule`` argument. The profiler will skip the first ``skip_first`` steps, then wait for ``wait`` steps, then do the warmup for the next ``warmup`` steps, then do the active recording for the next ``active`` steps and then repeat the cycle starting with ``wait`` steps. The optional number of cycles is specified with the ``repeat`` parameter, the zero value means that the cycles will continue until the profiling is finished. The ``skip_first_wait`` parameter controls whether the first ``wait`` stage should be skipped. This can be useful if a user wants to wait longer than ``skip_first`` between cycles, but not for the first profile. For example, if ``skip_first`` is 10 and ``wait`` is 20, the first cycle will wait 10 + 20 = 30 steps before warmup if ``skip_first_wait`` is zero, but will wait only 10 steps if ``skip_first_wait`` is non-zero. All subsequent cycles will then wait 20 steps between the last active and warmup. c V^8dQhRRRR/#)r)steprDr,rr-)r.s"r%r/schedule..__annotate__s#.r'c<V^8d\RV R24hVS8d\P#VS,pS^8wd VS, pSS,S,pS^8dW, S8d\P#W,pVS8d\P#VSS,8d\P#W!^, 8d\P#\P #)rzStep must be non-negative. Got rE)rrrmrnrorp) r num_stepsmod_stepr}rwrxryr{r|s & r% schedule_fnschedule..schedule_fns !8 #B4&!JK K * !&& & J D a  DLD6MF* A:$*f4!&& &# d?!&& & v %!(( (!m+%% $33 r'z.Invalid profiler schedule arguments. Got wait=z (need >= 0), warmup=z (need >= 0), active=z (need > 0), repeat=z (need >= 0), skip_first=z (need >= 0).z>Profiler won't be using warmup, this can skew profiler resultsr!)rr )r{r|r}rwrxryrsdddddd r%schedulers02 ax6A:1 j1ns!!C!N!r'c"\P#)zm Default profiler behavior - immediately starts recording the events, keeps doing it on every profiler step. )rro)rs&r%_default_schedule_fnr>s   r'c(V^8dQhRRRRRRRR/#)r)dir_namer worker_namerause_gziprrr-)r.s"r%r/r/Fs0!!!!! !r'c>aaaaaa^RIo^RIoRVVVVVV3RllpV#)z Outputs tracing files to directory of ``dir_name``, then that directory can be directly delivered to tensorboard as logdir. ``worker_name`` should be unique for each worker in distributed scenario, it will be set to '[hostname]_[pid]' by default. NcV^8dQhRR/#rr-)r.s"r%r//tensorboard_trace_handler..__annotate__Us  D r'c<\PPS4'g\P!SRR7S'g)SP 4 R\P!4 2oS RSP4 R2pS'd VR,pVP!\PPSV4SR7R# \dp\ RS,4ThRp?ii;i) T)exist_okzCan't create directory: NrrEz.pt.trace.jsonrr) rrisdirmakedirs Exceptionr) gethostnamegetpidtime_nsrr) re file_namersockettimerrrs & r% handler_fn-tensorboard_trace_handler..handler_fnUsww}}X&& Q Ht4#//12!BIIK=AK"m1T\\^$4NC !E)I   GGLL9 -/  Q"#=#HIqP QsC C.C))C.)rr)rrrrrrrsffff @@r%tensorboard_trace_handlerrFs  $ r'ca]tRtRtRtRRRRRRRRR RR RR RR RR RRRRRRRRR/ RV3RllltRtRtRRltRRlt RRlt RRlt Rt RR lt R!R"ltR#R$ltR%tV;t#)&rijaProfiler context manager. Args: activities (iterable): list of activity groups (CPU, CUDA) to use in profiling, supported values: ``torch.profiler.ProfilerActivity.CPU``, ``torch.profiler.ProfilerActivity.CUDA``, ``torch.profiler.ProfilerActivity.XPU``. Default value: ProfilerActivity.CPU and (when available) ProfilerActivity.CUDA or (when available) ProfilerActivity.XPU. Each item can be a ``ProfilerActivity`` enum (collects all default activity types for that group) or a ``dict`` mapping a ``ProfilerActivity`` to a list of individual activity type names to collect, e.g. ``{ProfilerActivity.CUDA: ["GPU_MEMCPY", "CUDA_RUNTIME"]}``. An empty list (e.g. ``{ProfilerActivity.CUDA: []}``) means collect nothing for that group. The same activity group must not appear more than once. See :class:`~torch.profiler.ProfilerActivity` for the valid activity type names and device-specific behavior. schedule (Callable): callable that takes step (int) as a single parameter and returns ``ProfilerAction`` value that specifies the profiler action to perform at each step. on_trace_ready (Callable): callable invoked at the end of each profiling cycle (when ``schedule`` returns ``ProfilerAction.RECORD_AND_SAVE``). Receives the :class:`profile` instance as its only argument, typically used to export the trace (e.g. via :meth:`export_chrome_trace`) or print a summary. record_shapes (bool): save information about operator's input shapes. profile_memory (bool): track tensor memory allocation/deallocation. with_stack (bool): record source information (file and line number) for the ops. with_flops (bool): use formula to estimate the FLOPs (floating point operations) of specific operators (matrix multiplication and 2D convolution). with_modules (bool): record module hierarchy (including function names) corresponding to the callstack of the op. e.g. If module A's forward call's module B's forward which contains an aten::add op, then aten::add's module hierarchy is A.B .. deprecated:: ``with_modules`` is deprecated and will be removed in a future version. It only collects data for TorchScript models, which are themselves deprecated, and does nothing in eager mode. Use ``with_stack=True``, which records ``nn.Module`` events for eager models. experimental_config (_ExperimentalConfig) : A set of experimental options used for Kineto library features. Note, backward compatibility is not guaranteed. execution_trace_observer (ExecutionTraceObserver) : A PyTorch Execution Trace Observer object. `PyTorch Execution Traces `__ offer a graph based representation of AI/ML workloads and enable replay benchmarks, simulators, and emulators. When this argument is included the observer start() and stop() will be called for the same time window as PyTorch profiler. See the examples section below for a code sample. acc_events (bool): Enable the accumulation of FunctionEvents across multiple profiling cycles post_processing_timeout_s (float): Optional timeout in seconds for post-processing profiler results. If specified, event parsing will stop after this duration and return partial results. Useful for handling large traces that may take too long to process. custom_trace_id_callback (Callable[[], str], optional): User-supplied trace ID generator, invoked once per profiling cycle. Defaults to a random UUID; retrieve via :meth:`get_trace_id`. .. note:: Use :func:`~torch.profiler.schedule` to generate the callable schedule. Non-default schedules are useful when profiling long training jobs and allow the user to obtain multiple traces at the different iterations of the training process. The default schedule simply records all the events continuously for the duration of the context manager. .. note:: Use :func:`~torch.profiler.tensorboard_trace_handler` to generate result files for TensorBoard: ``on_trace_ready=torch.profiler.tensorboard_trace_handler(dir_name)`` After profiling, result files can be found in the specified directory. Use the command: ``tensorboard --logdir dir_name`` to see the results in TensorBoard. For more information, see `PyTorch Profiler TensorBoard Plugin `__ .. note:: Enabling shape and stack tracing results in additional overhead. When record_shapes=True is specified, profiler will temporarily hold references to the tensors; that may further prevent certain optimizations that depend on the reference count and introduce extra tensor copies. Examples: .. code-block:: python with torch.profiler.profile( activities=[ torch.profiler.ProfilerActivity.CPU, torch.profiler.ProfilerActivity.CUDA, ] ) as p: code_to_profile() print(p.key_averages().table(sort_by="self_cuda_time_total", row_limit=-1)) Using the profiler's ``schedule``, ``on_trace_ready`` and ``step`` functions: .. code-block:: python # Non-default profiler schedule allows user to turn profiler on and off # on different iterations of the training loop; # trace_handler is called every time a new trace becomes available def trace_handler(prof): print( prof.key_averages().table(sort_by="self_cuda_time_total", row_limit=-1) ) # prof.export_chrome_trace("/tmp/test_trace_" + str(prof.step_num) + ".json") with torch.profiler.profile( activities=[ torch.profiler.ProfilerActivity.CPU, torch.profiler.ProfilerActivity.CUDA, ], # In this example with wait=1, warmup=1, active=2, repeat=1, # profiler will skip the first step/iteration, # start warming up on the second, record # the third and the fourth iterations, # after which the trace will become available # and on_trace_ready (when set) is called; # the cycle repeats starting with the next step schedule=torch.profiler.schedule(wait=1, warmup=1, active=2, repeat=1), on_trace_ready=trace_handler, # on_trace_ready=torch.profiler.tensorboard_trace_handler('./log') # used when outputting for tensorboard ) as p: for iter in range(N): code_iteration_to_profile(iter) # send a signal to the profiler that the next iteration has started p.step() The following sample shows how to setup up an Execution Trace Observer (`execution_trace_observer`) .. code-block:: python with torch.profiler.profile( ... execution_trace_observer=( ExecutionTraceObserver().register_callback("./execution_trace.json") ), ) as p: for iter in range(N): code_iteration_to_profile(iter) p.step() You can also refer to test_execution_trace_with_kineto() in tests/profiler/test_profiler.py. Note: One can also pass any object satisfying the _ITraceObserver interface. rgNron_trace_readyrvFrwrxryrzr*r{r|r}r~cPV^8dQhRRRRRRRRR RR RR RR RR RRRRRRRRRRR/#)r)rgrrz&Callable[[int], ProfilerAction] | NonerzCallable[..., Any] | Nonervrrwrxryrzr*r+r{rr|r}rr~rr,rr-)r.s"r%r/profile.__annotate__sqCqCqC 9 qC 2 qCqCqCqCqCqC8qC#9qCqC#;qC $0!qC" #qCr'c  @ <Ve\V4wrM \4p\V4^8Xd \R4h\ST`TTTTTTT T ;'g\ P4V V V R7 V'dW nRVn M\VnRVn W0n ^Vn RVn VPVP4pV\P8Xd \!R4hVVnVVn/\P&\P&3.b\P&\P(3VP*.b\P&\P,3VP*VP..b\P&\P03VP*VP..b\P(\P&3\3\4R4VP.VP6.b\P(\P(3.b\P(\P,3VP..b\P(\P03VP..b\P,\P&3\3\4R4VP6.b\P,\P(3\3\4R4VP6.b\P,\P,3.b\P,\P03.b\P0\P&3VP6VP8.b\P0\P(3VP6VP8VP*.b\P0\P,3VP6VP8VP*VP..b\P0\P03VP6VP8VP*VP..b\P(\P3VP.VP6VP8.b\P,\P3VP6VP8.\P\P3.\P\P(3VP*.\P\P&3.\P\P,3VP*VP..\P\P03VP*VP..\P&\P3\3\:R R 4.\P0\P3\3\:R R 4.\P(R3VP.VP6.\P,R3VP6VP8.\P0R3VP6VP8.\PR3./ CVn\>P@PC\D4R#) Nz"No valid profiler activities found) rgrvrwrxryrzr*r{r|r}r~TFtProfilerAction.DEVICE_STOPPED is set internally by the profiler and must not be returned by a user-provided schedulez+Incorrect schedule: WARMUP followed by NONEz+Incorrect schedule: RECORD followed by NONEz-Incorrect schedule: RECORD followed by WARMUPrmrqrp)#rsrWlenrsuperrr"build_execution_trace_obs_from_envr record_stepsrrstep_num step_rec_fnrrqrjcurrent_action_prev_schedule_actionrmrnrrorrprr r _trace_readyrv action_maprKinetoStepTrackerinit_step_countPROFILER_STEP_NAME)rIrgrrrvrwrxryrzr*r{r|r}r~activities_setrschedule_action __class__s&$$$$$$$$$$$$$ r%rprofile.__init__s$  ! 1* = NA13N ~ ! # !EF F !')!!% 3%=&K&K%HHJ!%=&?   $M $D 0DM %D , 8<-- 6 n;; ;P . &5"l  ."5"5 6l  ."7"7 84;M;M:Nl  ."7"7 8""  ; l  ."@"@ A""  Dl  " "N$7$7 8KL  ;l " " "N$9$9 :B#l $ " "N$9$9 :T=M=M>&&.*=*== %&4&C&C# NN - - / /+ 5 5~7L7LMM##~':':: ==/*PP  #1"?"?D  [*=*=> ::>>-r 2 2 KKBJJNN+CRHH  " " 1 12D E    #33#dmm"44 D     & & ( r'cV^8dQhRR/#rr-)r.s"r%r/r-s111r'c WnR#)z} Set the trace ID generator. Called at the start of each cycle, so updating it between cycles yields distinct IDs per cycle. N)r})rIcallbacks&&r%set_custom_trace_id_callback$profile.set_custom_trace_id_callback-s )1%r'c NVPfR#VPP#)z Returns the current trace ID. N)rtrace_idr\s&r% get_trace_idprofile.get_trace_id4s! == }}%%%r'cV^8dQhRR/#rr-)r.s"r%r/r<s&&d&r'c PVP'dVPV4R#R#r[)rr\s&r%rprofile._trace_ready<s!        % r'cV^8dQhRR/#rr-)r.s"r%r/r@sdr'c rVPPW34pV'dVF pV!4K R#R#r[)rr)rIrr action_listactions&&& r%rprofile._transit_action@s0oo));*GH %& r'cV^8dQhRR/#)r)r,zprof._ProfilerStats | Noner-)r.s"r%r/rFs$$2$r'c NVPfR#VPP#r[)r_statsr\s&r%rprofile._statsFs == }}###r') rrrr}rrrrr)rMrNrOrPrQrrrr]rarrrrrrrR __classcell__)rs@r%rrjsSjqC qC <@ qC 59 qC$qC %qC!qC!qC#qC;?qC<@qC!qC>BqC 37!qCqCf4 ) 9W)r1&& $$r'c]tRtRtRtRRltRRlt]RRl4tR R lt R R lt R!R Rllt ]R!RRll4t RRlt ]R4tRtRRltRRltRRltRRltRRltRtR #)"riLafExecution Trace Observer Each process can have a single ExecutionTraceObserver instance. The observer can be added to record function callbacks via calling register_callback() explicitly. Without calling unregister_callback(), repeated calls to register_callback() will not add additional observers to record function callbacks. Once an ExecutionTraceObserver is created, the start() and stop() methods control when the event data is recorded. Deleting or calling unregister_callback() will remove the observer from the record function callbacks, finalize the output file, and will stop incurring any overheads. cV^8dQhRR/#rr-)r.s"r%r/#ExecutionTraceObserver.__annotate__[s 1 1$ 1r'c ZRVnRVnRVnRVnRVnRVnR#)z! Initializes the default states. FrN) _registered_execution_trace_runningextra_resources_collection resources_diroutput_file_pathoutput_file_path_observerr\s&r%rExecutionTraceObserver.__init__[s4!(-%*/'"$%'.0&r'cV^8dQhRR/#rr-)r.s"r%r/rf###r'c &VP4R#z? Calls unregister_callback() to make sure to finalize outputs. Nunregister_callbackr\s&r%__del__ExecutionTraceObserver.__del__f   "r'cV^8dQhRR/#)r)r,zExecutionTraceObserver | Noner-)r.s"r%r/rms0Mr'c \PPRR4R8Xd\P!RRRR7;_uu_4pVP pRRR4\4pTPX4\PPR R4R8XdTPR 4T#TPR4T#R# +'giLx;i \ dp\R T 2^R 7Rp?R#Rp?ii;i) a Returns an ExecutionTraceObserver instance if the environment variable ENABLE_PYTORCH_EXECUTION_TRACE is set to 1, otherwise returns None. Configures the observer to also collect extra resources if the environment variable ``ENABLE_PYTORCH_EXECUTION_TRACE_EXTRAS=1``. These are resources such as generated kernels, index tensor data etc. that are required to make the Execution Trace replayable. ENABLE_PYTORCH_EXECUTION_TRACErrrz.et.jsonFrNzTExecution trace will not be recorded. Exception on creating default temporary file: r%ENABLE_PYTORCH_EXECUTION_TRACE_EXTRAST) rrrrrrrr rregister_callbackset_extra_resource_collection)r filenamerets r%r9ExecutionTraceObserver.build_execution_trace_obs_from_envls ::>>:C @C G 00*U!wwH()B   *zz~~EsKsR006I007I% jkljmn   s5!C CC C CC C>#C99C>cV^8dQhRR/#rr-)r.s"r%r/rs  D r'c ZWnVP'dVPRR7R#)a Collects extra resources such as generated kernels, index tensor data, and any other metadata that is required to complete the Execution Trace content. The caller should call this method with val=True after calling register_callback() if they want to collect the extra resources. T) can_createN)rget_resources_dir)rIrrs&&r%r4ExecutionTraceObserver.set_extra_resource_collections*+.'  * * *  " "d " 3r'c V^8dQhRRRR/#)r)rrr,r r-)r.s"r%r/rs#$r'c RRlpVP'g;WnVPR4'dV!4pWn\ V4VnV#)z^ Adds ET observer to record function callbacks. The data will be written to output_file_path. cV^8dQhRR/#)r)r,rr-)r.s"r%r/>ExecutionTraceObserver.register_callback..__annotate__s  C r'c\P!RRRR7;_uu_4pVPuuRRR4# +'giR#;i)rrFrN)rrr)r s r%get_temp_uncompressed_fileLExecutionTraceObserver.register_callback..get_temp_uncompressed_files1,,U75QQUWwwRQQQs 9 A r)rrrrr)rIrrs&& r%r(ExecutionTraceObserver.register_callbacksN  $4 !((//#=#? -= *<=MND  r'cV^8dQhRR/#r)r,rar-)r.s"r%r/rs""Z"r'c VP'gR#VP'd VP#\PVPVR7pV'gR#W nVP#)a Generates the resources directory for the generated kernels, or index tensor data or any other metadata that is required to complete the Execution Trace content. The directory is created right where the ET file is being output. Only works if the observer has called set_extra_resource_collection(val=True). Returns None if the observer is not configured with extra resource collection. N) create_dir)rrrget_resources_dir_for_et_pathr)rIr generated_paths&& r%r(ExecutionTraceObserver.get_resources_dirsf...    %% %/MM  ! !jN +!!!r'c V^8dQhRRRR/#)r)rrr,rar-)r.s"r%r/rs $ r'c \PPV4wr#\PPV\PP V4^,R,4p\PP V4'g$V'd\P !V4V#R#V# \d\RT 2^R7R#i;i)r _resourcesz(Execution trace exception when creating rN) rrsplitrsplitextexistsmkdirrr ) trace_pathrwork_dirr resource_dirs&& r%r4ExecutionTraceObserver.get_resources_dir_for_et_paths!ggmmJ7ww|| bgg&&y1!4|C ww~~l++ HH\*! B<.Q#$  sB77CCcV^8dQhRR/#rr-)r.s"r%r/rs4%4%T4%r'c laRV3RllpRRlpSP'djSP4V!4\ 4SP P R4'dV!SPSP 4R SnR#R# \dp\RT 2^R7Rp?LsRp?ii;i) z5 Removes ET observer from record function callbacks. cV^8dQhRR/#rr-)r.s"r%r/@ExecutionTraceObserver.unregister_callback..__annotate__s 2 2d 2r'c<SP4pT'gR#^RIHpTP Uu.uF p\ TRR4fKTPNK" ppTF]pTfK \PPT4p\PPY4p\P!YW4K_ R# \dp\RT 2^R7Rp?R#Rp?ii;iuupi)z>Execution trace exception when generating resource directory: rN) PyCodeCache__file__)rrr torch._inductor.codecacher/modulesr3r0rrbasenamershutilcopyfile) r(rr/r kernel_files kernel_filerdstrIs r%_save_triton_kernelsHExecutionTraceObserver.unregister_callback.._save_triton_kernelss #557   >%,,,A1j$/ ,  , &ww'' 4ggll<6 1 ,% TUVTWX   s"B>C'C'> C$ CC$c$V^8dQhRRRRRR/#)r)uncompressed_filer output_filer,rr-)r.s"r%r/r-s! ) )S )s )t )r'c L\RV RV 24\VR4;_uu_4p\P!VR4;_uu_4pVPV4RRR4RRR4\P !V4R# +'giL0;i +'giL;;i)zExecution Trace: compressing z to rrN)printrrrrremove)r<r=r r s&& r% _save_gz_fileAExecutionTraceObserver.unregister_callback.._save_gz_filest 12C1DD V W'..#YY{D11TOOC(2/ II' (21/.s# BB B B B B# z(Execution trace failed to save kernels: rNgzF)rrarr rrrr)rIr9rArsf r%r*ExecutionTraceObserver.unregister_callbacks  2 28 )     IIK S$& - .$$--d33d<S>ST$D    S?sCPQRR SsB B3B..B3c VP#)zN Returns True if the execution trace observer is registered, otherwise False. )rr\s&r% is_registered$ExecutionTraceObserver.is_registereds r'c VP#)z; Returns True if the observer is running, otherwise False. )rr\s&r% is_running!ExecutionTraceObserver.is_runnings,,,r'cV^8dQhRR/#rr-)r.s"r%r/rs%%t%r'c VP'd8VP'g$\4RVnVP4R#R#R#)z Starts to capture. TN)rrr_record_pg_configr\s&r%r]ExecutionTraceObserver.starts>    D$A$A$A , .,0D )  " " $%B r'cV^8dQhRR/#rr-)r.s"r%r/r's22d2r'c PVP'd\4RVnR#R#)z Stops to capture. FN)rrr\s&r%raExecutionTraceObserver.stop's#  ( ( ( - /,1D ) )r'cV^8dQhRR/#rr-)r.s"r%r/r/rr'c &VP4R#rrr\s&r%rdExecutionTraceObserver.cleanup/rr'cV^8dQhRR/#rr-)r.s"r%r/r5sjr'c BVP'd VP#R#)z' Returns the output file name or None. N)rr\s&r%get_output_file_path+ExecutionTraceObserver.get_output_file_path5s  (( (r'cV^8dQhRR/#rr-)r.s"r%r/r>s  4 r'c VP'd\PP4'd\PP 4'dk\PP P Pp\PPR\P!V\R74R#R#R#R#)z## process_group:init ##rN) rFrTrLrMrNrS_worldpg_config_inforU _record_function_with_args_enterr4rr=)rIr\s& r%rM(ExecutionTraceObserver._record_pg_config>s    !!..00!!0022"..??FFUUN NN ; ;* >}= 31 r')rrrrrrNri)rMrNrOrPrQrr staticmethodrrrrrrpropertyrFrIr]rardrWrMrRr-r'r%rrLs  1# > $"4*4%l  - %2#   r')rWrrrrr)NFF)D __future__rrr4rr4rabcrrenumr functoolsrtypingrr typing_extensionsr r warningsr rTtorch.autograd.profilerrUrrtorch._Cr torch._C._profilerrrrrrtorch._environmentrtorch._utils_internalrtorch.autogradrrtorch.profiler._memory_profilerrrcollections.abcrr__all__rrir" UserWarningr&r;rAr=rWrYrsrurrvrrrrrr-r'r%rrs" #%. &&2)S=P2 $%)Q< 67D$$7, 2 c "/6P =P =fT" ;  ;  ;;|!!H_$n_$D~_~r'