EiBSSKrSSKrSSKrSSKrSSKrSSKrSSKJr SSKJ r J r SSK J r J r SSKJr SSKJrJr SSKrSSKJr \R,"\5rS\4S jrS"S \S \\\44S jjrS rS"SjrS#Sjr S\!S \"\!4Sjr#S \$\!\!44Sjr%Sr&Sr'Sr(Sr)\ S5r*\ "SS55r+S \+4Sjr,S$S\S\\S S4Sjjr-\ S$S\S\\S S4Sjj5r.\S5r/\S 5r0S!r1g)%N)contextmanager) dataclassfield) lru_cachewraps)which)OptionalUnion)parse current_envc&^^/SQn/nUR5Htumm[UU4SjU55(a7[T5S:a([T5S:aURTSTS35 MX[R STSTS35 Mv U$)a Verifies that all keys and values in `current_env` do not contain illegal keys or values, and returns a list of strings as the result. Example: ```python >>> from accelerate.utils.environment import verify_env >>> env = {"ACCELERATE_DEBUG_MODE": "1", "BAD_ENV_NAME": ">> valid_env_items = verify_env(env) >>> print(valid_env_items) ["ACCELERATE_DEBUG_MODE=1 ", "OTHER_ENV=2 "] ``` ); <> c32># UH oTT-;v M g7fN).0charkeyvalues Y/home/mande/repo/quber/.venv/lib/python3.13/site-packages/accelerate/utils/environment.py 0convert_dict_to_env_variables..4sE_TC%K(_s=rzWARNING: Skipping z7 as it contains forbidden characters or missing values.)itemsalllenappendloggerwarning)r forbidden_charsvalid_env_itemsrrs @@rconvert_dict_to_env_variablesr'"s1OO!'') U E_E E E#c(VW-\_`e\fjk\k  " "cU!E7"#5 6 NN/uAeWr?r@strr:rrBrs rparse_flag_from_envrISs* JJNN3G -E u  ""r(cX[RRU[U55nU$r)r>r?r@rGrHs rparse_choice_from_envrKYs JJNN3G -E Lr( library_namescxUVs/sH(o[RR5;dM&UPM* sn$s snf)zc Checks if any of `library_names` are imported in the environment. Will return any names that are. )sysmoduleskeys)rLlib_names rare_libraries_initializedrR^s.&3 U]#++BRBRBT6TH] UU Us%77c&SSKJnJnJnJnJnJnJn U"5(agU"5(agU"5(agU"5(agU"5(ag[RR5(agU"5(ag U"5(ag g) a Determines the current device type and distributed type without initializing any device. This is particularly important when using fork-based multiprocessing, as device initialization before forking can cause errors. The device detection order follows the same priority as state.py:_prepare_backend(): MLU -> SDAA -> MUSA -> NPU -> HPU -> CUDA -> XPU Returns: tuple[str, str]: A tuple of (device_type, distributed_type) - device_type: The device string (e.g., "cuda", "npu", "xpu") - distributed_type: The distributed type string (e.g., "MULTI_GPU", "MULTI_NPU") Example: ```python >>> device_type, distributed_type = get_current_device_type() >>> print(device_type) # "cuda" >>> print(distributed_type) # "MULTI_GPU" ``` ris_hpu_availableis_mlu_availableis_musa_availableis_neuron_availableis_npu_availableis_sdaa_availableis_xpu_available)mlu MULTI_MLU)sdaa MULTI_SDAA)musa MULTI_MUSA)npu MULTI_NPU)hpu MULTI_HPU)cuda MULTI_GPU)xpu MULTI_XPU)neuron MULTI_NEURON) importsrUrVrWrXrYrZr[torchrf is_availablerTs rget_current_device_typeroes,!   #   #   !   !  " ""   !   '#r(c[R"5S:Xa&[S5nUc[RSS3nU$SnU$)z; Returns the right nvidia-smi command based on the system. Windowsz nvidia-smi systemdrivez6\Program Files\NVIDIA Corporation\NVSMI\nvidia-smi.exe)platformsystemrr>r?)commands r _nvidia_smirvsNI% % ?M233mnG N Nr(c([R"[5SS/SS9nUR5nUR [ R 5n[U5nUVs/sH$o3R S5SR5PM& nnXB4$s snf)z~ Gets GPU count and names using `nvidia-smi` instead of torch to not initialize CUDA. Largely based on the `gputil` library. z--query-gpu=count,name--format=csv,noheaderTuniversal_newlines,r) subprocess check_outputrvstripsplitr>linesepr!)outputgpus gpu_countgpu gpu_namess r get_gpu_infors $ $ 02IJ_cF\\^F << #DD I6:;ds3"((*dI;  r)rs rget_driver_versionrsJ  $ $ 46MNcgF\\^F << #A &&r(c^[5upS1mUS:a@[U4SjU55(a&Sn[5n[U5[U5:aggg![a gf=f)z Checks if the devices being used have issues with P2P and IB communications, namely any consumer GPU hardware after the 3090. Notably uses `nvidia-smi` instead of torch to not initialize CUDA. zRTX 40rc3@># UHnTH nX!;v M M g7frr)r device_nameunsupported_deviceunsupported_devicess rr,check_cuda_p2p_ib_support..s)#/K*=&#1*=2#/sz 550.40.07FT)ranyrr Exception) device_names device_countacceptable_driver_versioncurrent_driver_versionrs @rcheck_cuda_p2p_ib_supportrs %1^" 'j ! #/ -8));)=&/059R3SS      sAA A&%A&cb[R"[5SS/SS9nUR5n[ [ [ UR[R5SRS555nUS:$![a% [RR5nUS:$f=f)zd Checks if the current GPU available supports FP8. Notably might initialize `torch.cuda` to check. z--query-gpu=compute_capabilityrxTryr.) )r|r}rvr~tuplemapr=rr>rrrmrfget_device_capability)rcompute_capabilitys rcheck_cuda_fp8_capabilityrs @(( ]<>U Vko "3sFLL,DQ,G,M,Mc,R#ST  '' @"ZZ==?  ''@sA8A??(B.-B.c\rSrSr%Sr\"SSS0S9r\\S'\"SSS 0S9r \\S '\"SSS 0S9r \\S '\"SSS 0S9r \\S'Sr g)CPUInformationaO Stores information about the CPU in a distributed environment. It contains the following attributes: - rank: The rank of the current process. - world_size: The total number of processes in the world. - local_rank: The rank of the current process on the local node. - local_world_size: The total number of processes on the local node. rhelpz The rank of the current process.)rBmetadatarankrz+The total number of processes in the world. world_sizez2The rank of the current process on the local node. local_rankz0The total number of processes on the local node.local_world_sizerN) __name__ __module__ __qualname____firstlineno____doc__rrr=__annotations__rrr__static_attributes__rr(rrrsfa63U*VWD#WA9f0ghJhA9m0noJo!!v?q6rscsr(rc0n[/SQS5US'[/SQS5US'[/SQS5US'[/S QS5US '[S 0UD6$) z| Returns various information about the environment in relation to CPU distributed training as a `CPUInformation` dataclass. )RANKPMI_RANKOMPI_COMM_WORLD_RANKMV2_COMM_WORLD_RANKrr) WORLD_SIZEPMI_SIZEOMPI_COMM_WORLD_SIZEMV2_COMM_WORLD_SIZErr) LOCAL_RANKMPI_LOCALRANKIDOMPI_COMM_WORLD_LOCAL_RANKMV2_COMM_WORLD_LOCAL_RANKr)LOCAL_WORLD_SIZEMPI_LOCALNRANKSOMPI_COMM_WORLD_LOCAL_SIZEMV2_COMM_WORLD_LOCAL_SIZErr)rEr) informations rget_cpu_distributed_informationr sp K*+npqrK 0QST!K !1dfg!K '7j 'K"#  (K ((r(local_process_indexverbosecUc [SS5n[RR5(Ga>SSKJn U"5(d [ S5eSSKnUR5 [R"[R"5S- 5nURU5nSnURXT5H nUS U3nM UVs/sHn[U5PM n nU R!5 [#U 5V V s/sHupU S:wdM U PM n n n [R$"SU 5 U(a>[R&"S5n [(R+S [-U 5S US U 35 gggs snfs sn n f) a Overrides whatever NUMA affinity is set for the current process. This is very taxing and requires recalculating the affinity to set, ideally you should use `utils.environment.set_numa_affinity` instead. Args: local_process_index (int): The index of the current process on the current server. verbose (bool, *optional*): Whether to log out the assignment of each CPU. If `ACCELERATE_DEBUG_MODE` is enabled, will default to True. NACCELERATE_DEBUG_MODEFr)is_pynvml_availablezkTo set CPU affinity on CUDA GPUs the `nvidia-ml-py` package must be available. (`pip install nvidia-ml-py`)@064bz Assigning z cpu cores to process z: )rIrmrfrnaccelerate.utilsr ImportErrorpynvmlnvmlInitmathceilr> cpu_countnvmlDeviceGetHandleByIndexnvmlDeviceGetCpuAffinityr=reverse enumeratesched_setaffinitysched_getaffinityr#infor!)rrrnvml num_elementshandleaffinity_stringjx affinity_listirCaffinity_to_set cpu_coress roverride_numa_affinityrsS%&=uE zz  8"$$}   yy"!45 001DE..vDA!"4(9:OE*99AQ 9)2=)AL)AQ!V1)AL Q0 ,,Q/I KK*S^$44JK^J__abkalm n +!":LsE3< E8 E8c[XS9 g)a  Assigns the current process to a specific NUMA node. Ideally most efficient when having at least 2 cpus per node. This result is cached between calls. If you want to override it, please use `accelerate.utils.environment.override_numa_afifnity`. Args: local_process_index (int): The index of the current process on the current server. verbose (bool, *optional*): Whether to print the new cpu cores assignment for each process. If `ACCELERATE_DEBUG_MODE` is enabled, will default to True. rrN)rrs rset_numa_affinityrEs /BTr(c## [RR5n[RR5 Sv [RR5 [RR U5 g![RR5 [RR U5 f=f7f)a A context manager that will temporarily clear environment variables. When this context exits, the previous environment variables will be back. Example: ```python >>> import os >>> from accelerate.utils import clear_environment >>> os.environ["FOO"] = "bar" >>> with clear_environment(): ... print(os.environ) ... os.environ["FOO"] = "new_bar" ... print(os.environ["FOO"]) {} new_bar >>> print(os.environ["FOO"]) bar ``` N)r>r?copyclearupdate)_old_os_environs rclear_environmentrWsv2jjoo'OJJ+   /*  /*s=CB>C?CCc+T# 0nUR5HZup#UR5nU[R;a[RUX'[ U5[RU'M\ Sv UHOnUR5nX!;aX[RU'M/[RR US5 MQ g!UHOnUR5nX!;aX[RU'M/[RR US5 MQ f=f7f)a A context manager that will add each keyword argument passed to `os.environ` and remove them when exiting. Will convert the values in `kwargs` to strings and upper-case all the keys. Example: ```python >>> import os >>> from accelerate.utils import patch_environment >>> with patch_environment(FOO="bar"): ... print(os.environ["FOO"]) # prints "bar" >>> print(os.environ["FOO"]) # raises KeyError ``` N)rupperr>r?rGpop)kwargs existing_varsrrs rpatch_environmentrzs$Mlln iik "** !#CM e* 3 % * C))+C#"/"4 3 sD) 6C))+C#"/"4 3 sD) s A1D(4C8AD(AD%%D(c^^^^Sm[U4Sj5mU4Sjm[U[5(dT"U5$U4SjmT"U5 [U4Sj5UlU$)aNDecorator to clean up accelerate environment variables set by the decorated class or function. In some circumstances, calling certain classes or functions can result in accelerate env vars being set and not being cleaned up afterwards. As an example, when calling: TrainingArguments(fp16=True, ...) The following env var will be set: ACCELERATE_MIXED_PRECISION=fp16 This can affect subsequent code, since the env var takes precedence over TrainingArguments(fp16=False). This is especially relevant for unit testing, where we want to avoid the individual tests to have side effects on one another. Decorate the unit test function or whole class with this decorator to ensure that after each test, the env vars are cleaned up. This works for both unittest.TestCase and normal classes (pytest); it also works when decorating the parent class. ACCELERATE_c3># [RR5VVs0sHupURT5(dMX_M! nnnSv [RVs/sHoRT5(dMUPM snH?nX2;aX#[RU'M[RR US5 MA gs snnfs snf![RVs/sHoRT5(dMUPM Os snfsnH?nX2;aX#[RU'M[RR US5 MA f=f7fr)r>r?r startswithr)kvrrprefixs renv_var_context5purge_accelerate_environment..env_var_contexts+-***:*:*<U*<$! V@T*< U . $&::F:af1E:F'&3&8BJJsOJJNN3- G V G2::F:af1E:F'&3&8BJJsOJJNN3- GsT"E CC E CE %CCAE E-D DA EE cB>^[T5UU4Sj5nSUlU$)NcX>T"5 T"U0UD6sSSS5 $!,(df  g=frr)argsrrfuncs rwrapperDpurge_accelerate_environment..wrap_function..wrappers" "T,V,#""s )T)r)_accelerate_is_purged_environment_wrapped)rrrs` r wrap_function3purge_accelerate_environment..wrap_functions) t -  -=A9r(c>[U5H]nURS5(dM[X5n[U5(dM8[ US5(aMK[ XT"U55 M_ U$)Ntestr)dirrgetattrcallablehasattrsetattr)test_class_instancenamemethodrs rwrap_test_methods7purge_accelerate_environment..wrap_test_methodss]+,Dv&& !4;F##GFT"U5$rr)clskwrs r.purge_accelerate_environment..s BSTWBXr()r isinstancetype classmethod__init_subclass__) func_or_clsrrrrs @@@@rpurge_accelerate_environmentrs^&F . . k4 ( ([))#k"$/0X$YK! r()F)r3r)2loggingrr>rsr|rN contextlibr dataclassesrr functoolsrrshutilrtypingr r rmpackaging.versionr getLoggerrr#dictr'boolr=r:rErIrKrGlistrRrrorvrrrrrrrrrrrrr(rr&s|  %(&" #   8 $t2 9 9sDy1A 9#  VcVd3iV2#sCx2#j  $ '8 ( (*  t t  t))($o$ohtn$oX\$oN U3U$USWU U"++D!*!*H;r(