.hddlmZddlZddlZddlZddlZddlZddlZddlm Z ddl m Z ddl m Z ddl mZddlmZddlZddlZddlmZddlmZddlmcmZddlmZdd lmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'dd l(m)Z)dd l*m+Z+dd l,m-Z-e)e$d Z.e)e$dZ/e)e$dZ0e)e$dZ1e)e$dZ2e)e$dZ3e)e$dZ4e)e%dZ5e)e%dZ6e)e%dZ7e)e%dZ8e&re)e$dre!jrde d;dZ:dZ;dejzdZ?d>dZ@d ZAd!ZBd"ZCd?d#ZDd$ZEd%ZFd&ZGd@d'ZHd@d(ZId)ZJdAd*ZKdBd+ZLdCd,ZMd-ZNdDd.ZOdEd/ZPdFd0ZQd1ZRGd2d3ZSdGdHd4ZTd5ZUe dId6ZVdJd7ZWGd8d9ZX dK dLd:ZYy)M) annotationsN)contextmanager)deepcopy)datetime)Path)Any) __version__) DEFAULT_CFG_DICTDEFAULT_CFG_KEYSLOGGER NUM_THREADSPYTHON_VERSION TORCH_VERSIONTORCHVISION_VERSIONWINDOWScolorstr) check_version)CPUInfo) torch_loadz1.9.0z1.10.0z1.11.0z1.13.0z2.0.0z2.1.0z2.4.0z0.10.0z0.11.0z0.13.0z0.18.0z==2.4.0zKnown issue with torch==2.4.0 on Windows with CPU, recommend upgrading to torch>=2.4.1 to resolve https://github.com/ultralytics/ultralytics/issues/15049c#pKtjxrtj}|xrtjdk(}|r1|dvr-|rtj|gntjd|r4|dk(r.|rtj|gntjyyyw)ziEnsure all processes in distributed training wait for the local master (rank 0) to complete a task first.nccl>r) device_idsNr)dist is_availableis_initialized get_backendbarrier) local_rank initializeduse_idss [/var/www/html/ai-service/venv/lib/python3.12/site-packages/ultralytics/utils/torch_utils.pytorch_distributed_zero_firstr#:s##%?$*=*=*?K:d..0F:Gz018  -dlln zQ18  -dlln'{sB4B6c d}|S)zVApply torch.inference_mode() decorator if torch>=1.9.0 else torch.no_grad() decorator.ctrtjr|Strtj|Stj|S)zLApply appropriate torch decorator for inference mode based on torch version.) TORCH_1_9torchis_inference_mode_enabledinference_modeno_grad)fns r"decoratez&smart_inference_mode..decorateJs> 88:IKIE((KBO O5==KBO O)r,s r"smart_inference_moder/GsP Or-ctr!tjj||Stjjj|S)aI Get the appropriate autocast context manager based on PyTorch version and AMP setting. This function returns a context manager for automatic mixed precision (AMP) training that is compatible with both older and newer versions of PyTorch. It handles the differences in the autocast API between PyTorch versions. Args: enabled (bool): Whether to enable automatic mixed precision. device (str, optional): The device to use for autocast. Returns: (torch.amp.autocast): The appropriate autocast context manager. Notes: - For PyTorch versions 1.13 and newer, it uses `torch.amp.autocast`. - For older versions, it uses `torch.cuda.autocast`. Examples: >>> with autocast(enabled=True): ... # Your mixed precision operations here ... pass )enabled) TORCH_1_13r'ampautocastcuda)r1devices r"r4r4Ts:.yy!!&'!::zz~~&&w//r-cddlm}d|vr tj|d<|j ddS#t$rYwxYw)z=Return a string with system CPU information, i.e. 'Apple M2'.rPERSISTENT_CACHEcpu_infounknown)ultralytics.utilsr9rname Exceptiongetr8s r" get_cpu_infor@qsO3)) +2<<> Z (    I 66   s5 AActjj|}|jd|jdz ddS)zGReturn a string with system GPU information, i.e. 'Tesla T4, 15102MiB'., iz.0fMiB)r'r5get_device_propertiesr= total_memory)index propertiess r" get_gpu_inforH~s>11%8Joo b!8!8G!DS I MMr-c t|tjst|j dr|Sdt dt dtd}t|j}dD]}|j|d}d|vrd d l m }|jd }|j|jdd }tt!|D],}||dk(s |rt|j#d nd||<.d j%d|D}|dk(} |dv} | s| rdt&j(d<nU|rR|dk(rd}d |vr1d j%|jd D cgc]} | s|  c} }t&j(j+dd} |t&j(d<tj,j/r9tj,j1t!|jd k\st3j4|tj,j1d k(rdnd} t7d|dtj,j/dtj,j1d| d| | sw| sutj,j/rW|r|jd nd}dt!|z}t9|D]#\}}||d k(rdn|d|dt;|dz }%d}nW| rBt<rj@j/r|dtCdz }d }n|d!tCdz }d}|d"vrtjDtF|r't3j4|r|n|jItj|Scc} w)#a1 Select the appropriate PyTorch device based on the provided arguments. The function takes a string specifying the device or a torch.device object and returns a torch.device object representing the selected device. The function also validates the number of available devices and raises an exception if the requested device(s) are not available. Args: device (str | torch.device, optional): Device string or torch.device object. Options are 'None', 'cpu', or 'cuda', or '0' or '0,1,2,3'. Auto-selects the first available GPU, or CPU if no GPU is available. newline (bool, optional): If True, adds a newline at the end of the log string. verbose (bool, optional): If True, logs the device information. Returns: (torch.device): Selected device. Examples: >>> select_device("cuda:0") device(type='cuda', index=0) >>> select_device("cpu") device(type='cpu') Notes: Sets the 'CUDA_VISIBLE_DEVICES' environment variable for specifying which GPUs to use. )tpuintelz Ultralytics u 🚀 Python-z torch- )zcuda:none()[]'rLz-1r)GPUInfo,g?)countmin_memory_fractionc3&K|] }|s| ywNr.).0ps r" z select_device..s0a!0scpu>mps:0mpsCUDA_VISIBLE_DEVICESr50Nz}See https://pytorch.org/get-started/locally/ for up-to-date torch install instructions if no CUDA devices are seen by torch. zInvalid CUDA 'device=z' requested. Use 'device=cpu' or pass valid CUDA device(s) if available, i.e. 'device=0' or 'device=0,1,2,3' for Multi-GPU. torch.cuda.is_available(): z torch.cuda.device_count(): z% os.environ['CUDA_VISIBLE_DEVICES']:  zCUDA:z (z) zcuda:0zMPS (r_zCPU (>r]r_)% isinstancer'r6str startswithr rrlowerreplaceultralytics.utils.autodevicerTsplitselect_idle_gpurVrangelenpopjoinosenvironr?r5r device_countr info ValueError enumeraterH TORCH_2_0backendsr_r@set_num_threadsr rstrip)r6newlineverbosesremoverTpartsselectedir]r_xvisibleinstalldevicesspacedargs r" select_devicers`6&%,,'3v;+A+ABR+S {m=0@ VWXA [   F?,+, v~8 S!9,,5;;t3DZ],^s5z" DAQx43;3x||A/a D0U00 E/C $ $C c-1 )*  V F &=XX&,,s*;AQqqABF**..!7>-3 )* '')ejj.E.E.G3v||\_O`Ka.a KKN::**,14  'x0016 0G0G0I/J/ 0G0G0I/J8 )   suzz668'-&,,s#3c!f g& LDAq !q&Be,E!B|A6GsK KA L u~~11>>@ u\^$C (( u\^$C (( n k* Aahhj1 << OBs ,O4Octjjrtjjt jS)zReturn PyTorch-accurate time.)r'r5r synchronizetimer.r-r" time_syncrs. zz   99;r-c|jj|jd}tj|jj tj |j|jz}tj||j|jj|j_ |j5tj|j|jjn |j}|j|jj|j j tj |j|jzz }tj||j#ddj#d|z}|j&|j%dt'j(|n||j_ |j+dS)a Fuse Conv2d and BatchNorm2d layers for inference optimization. Args: conv (nn.Conv2d): Convolutional layer to fuse. bn (nn.BatchNorm2d): Batch normalization layer to fuse. Returns: (nn.Conv2d): The fused convolutional layer with gradients disabled. Example: >>> conv = nn.Conv2d(3, 16, 3) >>> bn = nn.BatchNorm2d(16) >>> fused_conv = fuse_conv_and_bn(conv, bn) rr6biasFweightview out_channelsr'diagdivsqrteps running_varmmshapedatarzerosr6mul running_meanreshaperegister_parameternn Parameterrequires_grad_)convbnw_convw_bnb_convb_bn fused_biass r"fuse_conv_and_bnrs`"[[  d// 4F ::biimmEJJrvv/F$GH IDxxf-224;;3D3DEDKKKO))J[U[[**4;;3E3E FaeajajF 77RYY]]2??377 2>>TVTZTZCZ8[\ \D$r1 56>>rBTIJ yy  Z(@A#    u %%r-c|jj|jd}tj|jj tj |j|jz}tj||j|jj|j_ |j5tj|j|jjn |j}|j|jj|j j tj |j|jzz }tj||j#ddj#d|z}|j&|j%dt'j(|n||j_ |j+dS)a Fuse ConvTranspose2d and BatchNorm2d layers for inference optimization. Args: deconv (nn.ConvTranspose2d): Transposed convolutional layer to fuse. bn (nn.BatchNorm2d): Batch normalization layer to fuse. Returns: (nn.ConvTranspose2d): The fused transposed convolutional layer with gradients disabled. Example: >>> deconv = nn.ConvTranspose2d(16, 3, 3) >>> bn = nn.BatchNorm2d(3) >>> fused_deconv = fuse_deconv_and_bn(deconv, bn) rrrrFr)deconvrw_deconvrrrrs r"fuse_deconv_and_bnrsa"}}!!&"5"5r:H ::biimmEJJrvv/F$GH ID$166v}}7J7JKFMMOUkkNaU[[,,V]]5I5I JgmgrgrF 77RYY]]2??377 2>>TVTZTZCZ8[\ \D$r1 56>>rBTIJ {{!!&",,z*BC%    ''r-c,|syt|}t|}tdjd|j D}t |}|rdddddd d d d d dd dd dd }t j|t|jD]A\} \} } | jdd} | jj} t | jr| jD]\} }t j| d| d| d| d |jd |j!dt#t%|j&d |j)d|j+dt#|j,jddd  t j| d| d| d dd ddt#gd dd dd dd Dt/||}t1|ddrdnd}|rd|d d!nd}t1|d"dxst1|d#ij3d"d}t5|j6jd$d%xsd&}t j|d'|d(|d)d*|d)d+|d)d,| ||||fS)-a Print and return detailed model information layer by layer. Args: model (nn.Module): Model to analyze. detailed (bool, optional): Whether to print detailed layer information. verbose (bool, optional): Whether to print model information. imgsz (int | list, optional): Input image size. Returns: n_l (int): Number of layers. n_p (int): Number of parameters. n_g (int): Number of gradients. flops (float): GFLOPs. N collectionsc3\K|]$\}}t|jdk(s||f&yw)rN)rl_modules)rZnms r"r\zmodel_info..Es-2tda_bcdcmcm_nrs_sAq62ts , ,layerz>5r=z>40typez>20gradientz>10 parametersz>12rmusigmaz module_list.rSz>5g.z>12gz>10.3gztorch.z>15Fr-is_fusedcy)NFr.r.r-r"zmodel_info..Vsr-z (fused)rB.1fz GFLOPs yaml_fileyamlyoloYOLOModelz summaryz: rUz layers, z parameters, z gradients)get_num_paramsget_num_gradients __import__ OrderedDict named_modulesrlr rrrtitemsrg __class____name__ _parametersnamed_parameters requires_gradnumelrdlistrmeanstddtype get_flopsgetattrr?rstem)modeldetailedrzimgszn_pn_glayersn_lhrmnrmtpnr[flopsfusedfsr model_names r" model_infor1s4   C E "C  & 2 22teFYFYF[2t tF f+Crl6#,vcl:c2B.`s5Qqwwy5sumrrs r"rr^s 5%"2"2"45 55r-cBtd|jDS)zEReturn the total number of parameters with gradients in a YOLO model.c3VK|]!}|js|j#ywrY)rrrs r"r\z$get_num_gradients..esHQqwwyHs))rrs r"rrcs H%"2"2"4H HHr-cx|jjrHddlm}||jg|j j d}|jdn5t|jtt|jdd}t|jjdd|d<|S) a[ Return model info dict with useful model information. Args: trainer (ultralytics.engine.trainer.BaseTrainer): The trainer object containing model and validation data. Returns: (dict): Dictionary containing model parameters, GFLOPs, and inference speeds. Examples: YOLOv8n info for loggers >>> results = { ... "model/parameters": 3151904, ... "model/GFLOPs": 8.746, ... "model/speed_ONNX(ms)": 41.244, ... "model/speed_TensorRT(ms)": 3.211, ... "model/speed_PyTorch(ms)": 18.755, ...} r) ProfileModelsrz model/name)zmodel/parametersz model/GFLOPs inferencezmodel/speed_PyTorch(ms))argsprofileultralytics.utils.benchmarksrlastr6runrmrrroundr validatorspeed)trainerrresultss r"model_info_for_loggersrhs(||>w~~FJJLQO L!!/w}} =!)GMM":A> */w/@/@/F/F{/SUV)WG %& Nr-c ddl}|sy t|}t|j }t |t s||g} t|dr-tt|jjdnd}tjd|jd||f|j}|jt!||gd dd z d z}||dz|z |dz|z S#t$rd}YwxYw#t"$r]tjd|jdg||j}|jt!||gd dd z d zcYSwxYw#t"$rYywxYw) a Calculate FLOPs (floating point operations) for a model in billions. Attempts two calculation methods: first with a stride-based tensor for efficiency, then falls back to full image size if needed (e.g., for RTDETR models). Returns 0.0 if thop library is unavailable or calculation fails. Args: model (nn.Module): The model to calculate FLOPs for. imgsz (int | list, optional): Input image size. Returns: (float): The model FLOPs in billions. rNstride rrFinputsrzeA)thop ImportError unwrap_modelnextrrcrhasattrmaxintrr'emptyrr6rrr>)rrr r[rimrs r"rrsv U# !!# $%&ENE Z9@9QSU\\--/0"5WYFaVV.9AGG9r rc34K|]}|jywrYrrs r"r\z0get_flops_with_torch_profiler..rr)rur rrrcrrrrrr'rrr6profilerrr key_averagesr>)rrr[rrprofrs r"get_flops_with_torch_profilerrs   E U    A eT " @6=eX6N#c%,,**,-r2TVZ[[ [[!QWWQZ8 J ^^ # #t # 4  "I 9T%6%6%899C?a 6)E!H4v= L   @ [[!QWWQZ0%0 B ^^ # #t # 4  "I   9T%6%6%899C? L @sDBD' D?D'D$ D''AG F GF *GGcZ|jD]}t|}|tjur!|tjurd|_d|_B|tjtjtjtjtjhvsd|_ y)z*Initialize model weights to random values.gMbP?gQ?TN) modulesrrConv2d BatchNorm2drmomentum Hardswish LeakyReLUReLUReLU6SiLUinplace)rrts r"initialize_weightsr+sv ]]_ G  >  ".. AEAJ 2<<rww"''J JAIr-c dk(r|S|jdd\}}t|zt|zf}tj||dd}|sfd||fD\}}tj|d||d z d||dz gd S) a Scale and pad an image tensor, optionally maintaining aspect ratio and padding to gs multiple. Args: img (torch.Tensor): Input image tensor. ratio (float, optional): Scaling ratio. same_shape (bool, optional): Whether to maintain the same shape. gs (int, optional): Grid size for padding. Returns: (torch.Tensor): Scaled and padded image tensor. ?r NbilinearF)sizemode align_cornersc3ZK|]"}tj|zz z$ywrY)mathceil)rZrgsratios r"r\zscale_img..s'?1 !e)b.)B.?s(+rrgS㥛?)value)rrF interpolatepad)imgr6 same_shaper5rwr{s ` ` r" scale_imgr>s | 99QR=DAq QYQY(A --!*E JC ?A?1 55q!ad(Aq1Q4x0 >>r-c|jjD]7\}}t|r||vs|jds||vr+t |||9y)a Copy attributes from object 'b' to object 'a', with options to include/exclude certain attributes. Args: a (Any): Destination object to copy attributes to. b (Any): Source object to copy attributes from. include (tuple, optional): Attributes to include. If empty, all attributes are included. exclude (tuple, optional): Attributes to exclude. _N)__dict__rrlresetattr)abincludeexcludekvs r" copy_attrrIsR   "1 LQg-!,,s2CqG|  Aq!  r-c|jDcic]?\}|vs tfd|Ds |j|jk(s=|Ac}}Scc}}w)aQ Return a dictionary of intersecting keys with matching shapes, excluding 'exclude' keys, using da values. Args: da (dict): First dictionary. db (dict): Second dictionary. exclude (tuple, optional): Keys to exclude. Returns: (dict): Dictionary of intersecting keys with matching shapes. c3&K|]}|v ywrYr.)rZrrGs r"r\z"intersect_dicts..s:W!1A::Ws)rallr)dadbrFrGrHs ` r"intersect_dictsrO sX XXZ s sTQ17s:Ww:W7W\]\c\cgijkglgrgr\rAqD ss ss AAAAc~t|tjjtjjfS)z Return True if model is of type DP or DDP. Args: model (nn.Module): Model to check. Returns: (bool): True if model is DataParallel or DistributedDataParallel. )rcrparallel DataParallelDistributedDataParallelrs r" is_parallelrTs* ebkk66 8[8[\ ]]r-c t|dr1t|jtjr |j}n?t|dr1t|j tjr |j }n|S})a] Unwrap compiled and parallel models to get the base model. Args: m (nn.Module): A model that may be wrapped by torch.compile (._orig_mod) or parallel wrappers such as DataParallel/DistributedDataParallel (.module). Returns: m (nn.Module): The unwrapped base model without compile or parallel wrappers. _orig_modmodule)rrcrVrModulerW)rs r"r r 'sY  1k "z!++ryy'I A Q !j299&EAH r-cfdS)aR Return a lambda function for sinusoidal ramp from y1 to y2 https://arxiv.org/pdf/1812.01187.pdf. Args: y1 (float, optional): Initial value. y2 (float, optional): Final value. steps (int, optional): Number of steps. Returns: (function): Lambda function for computing the sinusoidal ramp. ctdtj|tjzz z dz dz zzS)Nrr r)rr3cospi)rstepsy1y2s r"rzone_cycle..Gs=S!dhhq477{U':;;q@!DRPSUUr-r.)r^r_r]s```r" one_cycler`;s  VUr-c.tj|tjj|tj|tj j |tj j ||rtrftjdddtjj_ dtjd<t|tjd<ytj dyt#y)z Initialize random number generator (RNG) seeds https://pytorch.org/docs/stable/notes/randomness.html. Args: seed (int, optional): Random seed. deterministic (bool, optional): Whether to set deterministic algorithms. T) warn_onlyz:4096:8CUBLAS_WORKSPACE_CONFIGPYTHONHASHSEEDz3Upgrade to torch>=2.0.0 for deterministic training.N)randomseednpr' manual_seedr5manual_seed_allruuse_deterministic_algorithmsrvcudnn deterministicrorprdr warningunset_deterministic)rfrls r" init_seedsroJs KKIINN4 d JJ4  JJt$   . .tt D15ENN .4=BJJ0 1+.t9BJJ' ( NNP Qr-ctjddtjj_t j jddt j jddy)z@Unset all the configurations applied for deterministic training.FrcNrd)r'rjrvrkrlrorprmr.r-r"rnrndsH &&u-).ENN&JJNN,d3JJNN#T*r-c&eZdZdZddZdZddZy)ModelEMAa Updated Exponential Moving Average (EMA) implementation. Keeps a moving average of everything in the model state_dict (parameters and buffers). For EMA details see References. To disable EMA set the `enabled` attribute to `False`. Attributes: ema (nn.Module): Copy of the model in evaluation mode. updates (int): Number of EMA updates. decay (function): Decay function that determines the EMA weight. enabled (bool): Whether EMA is enabled. References: - https://github.com/rwightman/pytorch-image-models - https://www.tensorflow.org/api_docs/python/tf/train/ExponentialMovingAverage ctt|j|_||_fd|_|jj D]}|jdd|_y)a@ Initialize EMA for 'model' with given arguments. Args: model (nn.Module): Model to create EMA for. decay (float, optional): Maximum EMA decay rate. tau (int, optional): EMA decay time constant. updates (int, optional): Initial number of updates. cBdtj| z z zS)Nr)r3exp)rdecaytaus r"rz#ModelEMA.__init__..s uDHHaR#X,>(>?r-FTN) rr evalemaupdatesrvrrr1)selfrrvrwrzr[s `` r"__init__zModelEMA.__init__s^L/0557 ? $$& $A  U # $ r-c|jr|xjdz c_|j|j}t|j }|j j j D]=\}}|jjs||z}|d|z ||jzz }?yy)zp Update EMA parameters. Args: model (nn.Module): Model to update EMA from. rN) r1rzrvr  state_dictryrris_floating_pointdetach)r{rrmsdrGrHs r"updatezModelEMA.updates << LLA L 4<<(Au%002C++-335 3177,,FA!a%3q6==?22A 3 r-cN|jrt|j|||yy)a Update attributes and save stripped model with optimizer removed. Args: model (nn.Module): Model to update attributes from. include (tuple, optional): Attributes to include. exclude (tuple, optional): Attributes to exclude. N)r1rIry)r{rrErFs r" update_attrzModelEMA.update_attrs" << dhhw 8 r-N)gH.?ir)r.) process_groupreducer)r __module__ __qualname____doc__r|rrr.r-r"rrrrls&"3$ 9r-rrc  t|tjd}t|tsJdd|vsJd tjjtd d d }|jd r|d |d<t|dd r t |dj|d_t|ddr d|d_|dj!|dj#D] }d|_ it&|jdi}dD]}d||< d|d<|j)D cic]\}} |t*vs|| c} }|d<i|||xsi} tj,| |xs|t.j0j3|xs|dz } t j4d|d|rd|dndd| dd| S#t $r'}t jd|d|icYd}~Sd}~wwxYwcc} }w)a Strip optimizer from 'f' to finalize training, optionally save as 's'. Args: f (str | Path): File path to model to strip the optimizer from. s (str, optional): File path to save the model with stripped optimizer to. If not provided, 'f' will be overwritten. updates (dict, optional): A dictionary of updates to overlay onto the checkpoint before saving. Returns: (dict): The combined checkpoint dictionary. Examples: >>> from pathlib import Path >>> from ultralytics.utils.torch_utils import strip_optimizer >>> for f in Path("path/to/model/checkpoints").rglob("*.pt"): >>> strip_optimizer(f) r]) map_locationz%checkpoint is not a Python dictionaryrz'model' missing from checkpointz Skipping z!, not a valid Ultralytics model: Nz2AGPL-3.0 License (https://ultralytics.com/license)zhttps://docs.ultralytics.com)dateversionlicensedocsryr criterionF train_args) optimizer best_fitnessryrzscalerrepochg.AzOptimizer stripped from rUz saved as rSrLrMB)rr'r6rcdictr>r rmrnow isoformatr r?rrrhalfrrr rr saveropathgetsizerr) fr{rzremetadatar[rrGrHcombinedmbs r"strip_optimizerrs& qu||E': ;!T"K$KK"!|>>>|  ((*G. H uuU|uX' qz6"qz/' qz;'#' gJOO wZ " " $   ; :!%% b"9 :D D!AgJ(, N1=M8Mq!tNAlO4(3a3GMr3H JJxa a 3 &B KK*1#QAA3a/@2.NaPRSVxWYZ[ OG 1#%FqcJK 6Os*AGHH HG?9H?Hc|djD]k}|jD]V\}}|dk7s t|tjs'|j tj usD|j||<Xm|S)a  Convert the state_dict of a given optimizer to FP16, focusing on the 'state' key for tensor conversions. Args: state_dict (dict): Optimizer state dictionary. Returns: (dict): Converted optimizer state dictionary with FP16 tensors. statestep)valuesrrcr'Tensorrfloat32r)r~rrGrHs r"$convert_optimizer_state_dict_to_fp16rstG$++-$KKM $DAqF{z!U\\:qww%--?W668a $$ r-c#BKtd}tjjrFtjj  |tjj ||d<y|y#tjj ||d<wxYww)aN Monitor and manage CUDA memory usage. This function checks if CUDA is available and, if so, empties the CUDA cache to free up unused memory. It then yields a dictionary containing memory usage information, which can be updated by the caller. Finally, it updates the dictionary with the amount of memory reserved by CUDA on the specified device. Args: device (torch.device, optional): The CUDA device to query memory usage for. Yields: (dict): A dictionary with a key 'memory' initialized to 0, which will be updated with the reserved memory. r)memoryrN)rr'r5r empty_cachememory_reserved)r6 cuda_infos r"cuda_memory_usagersvAI zz    EO"'**"<">> from ultralytics.utils.torch_utils import profile_ops >>> input = torch.randn(16, 3, 640, 640) >>> m1 = lambda x: x * torch.sigmoid(x) >>> m2 = nn.SiLU() >>> profile_ops(input, [m1, m2], n=100) # profile over 100 iterations rNParamsz>12sGFLOPsz GPU_mem (GB)z>14sz forward (ms)z backward (ms)inputz>24soutputTtor)rrrFrr r rc3<K|]}|jywrY)r)rZyis r"r\zprofile_ops..Ps 6b 6rnanric3hK|])}jd|z jd|z z+yw)rN)r)rZr{rs r"r\zprofile_ops..]s/'iRSqQWWR[1_(M'is/2)r6rc3~K|]5}t|tjrt|jnd7yw)rN)rcr'rtuplerrs r"r\zprofile_ops..bs,i]^Au||1LuQWW~RXXis;=c3<K|]}|jywrYrrs r"r\zprofile_ops..cs:a :r12z12.4gz>14.3fz14.4g)(r r rcr'r6rr rrgccollectr5rrrrrrrfloat16rrrr>rkrrrbackwardfloatrandnrrrtolistrrrXrrdappend)ropsrr6 max_num_objr rrtftbr*rmemr@rys_ins_outr[rrs @r" profile_opsrs(*G fell +v& KK D/(4(=nT=RSbcgRh 4.$ )JJL JJ -UE7/) DDL"3-C5, )A '4 0V aA#Av.:a3NSTSZSZ^c^k^kSkqrA1iAB ]a Xa[!e LQORUUXYYgh# )q9A*62 0i({!aD({!0:DQ:MS 6A 66STYY[ddf#,;AaD 09X.44C1Q4!A$;$.22B1Q4!A$;$.22B".v6)!KK ! + #C'iWXW_W_WfWfWh'i$i j'-&+mm y2S88/90jcdfgbhi e>HBII>VC:1<<>::\] qfU5M#fbZ5zRUVZR[\`Qabefkblmqarst5#r2tUCD   &&(Y, )/)` Ny *   )0#(&P94Q9P>>Q4Q5ceZdZdZddZdZy) EarlyStoppinga Early stopping class that stops training when a specified number of epochs have passed without improvement. Attributes: best_fitness (float): Best fitness value observed. best_epoch (int): Epoch where best fitness was observed. patience (int): Number of epochs to wait after fitness stops improving before stopping. possible_stop (bool): Flag indicating if stopping may occur next epoch. cVd|_d|_|xs td|_d|_y)z Initialize early stopping object. Args: patience (int, optional): Number of epochs to wait after fitness stops improving before stopping. rrinfFN)r best_epochrpatience possible_stop)r{rs r"r|zEarlyStopping.__init__zs+  0E%L "r-c f|y||jkDs|jdk(r||_||_||jz }||jdz k\|_||jk\}|rJt d}t j |d|jd|jd|jd|S) a Check whether to stop training. Args: epoch (int): Current epoch of training fitness (float): Fitness value of current epoch Returns: (bool): True if training should stop, False otherwise FrrzEarlyStopping: z:Training stopped early as no improvement observed in last z( epochs. Best results observed at epoch z@, best model saved as best.pt. To update EarlyStopping(patience=z^) pass a new patience value, i.e. `patience=300` or use `patience=0` to disable EarlyStopping.)rrrrrr rr)r{rfitnessdeltastopprefixs r"__call__zEarlyStopping.__call__s ? T&& &$*;*;q*@#DO 'D '"t}}q'89 % /0F KK(TUYUbUbTcd226//1BC448MM?CTU   r-N)2)rrrrr|rr.r-r"rros #r-rc tttdr|s|S|durd}td}tj|d|d|dk(rtj |d|d d }t j} tj||d }t j|z } d} |rtjdd|||} |r|jdk(r| j} t j} tj5|r?|jdvr1tj|j5|| } dddn|| } ddd|jdk(rtjj!|t j| z } | | z}|r&tj|d|dd| dd| dd|Stj|d| dd|S#t$r&}tj |d ||cYd}~Sd}~wwxYw#1swYxYw#1swYxYw)uX Compile a model with torch.compile and optionally warm up the graph to reduce first-iteration latency. This utility attempts to compile the provided model using the inductor backend with dynamic shapes enabled and an autotuning mode. If compilation is unavailable or fails, the original model is returned unchanged. An optional warmup performs a single forward pass on a dummy input to prime the compiled graph and measure compile/warmup time. Args: model (torch.nn.Module): Model to compile. device (torch.device): Inference device used for warmup and autocast decisions. imgsz (int, optional): Square input size to create a dummy tensor with shape (1, 3, imgsz, imgsz) for warmup. use_autocast (bool, optional): Whether to run warmup under autocast on CUDA or MPS devices. warmup (bool, optional): Whether to execute a single dummy forward pass to warm up the compiled model. mode (bool | str, optional): torch.compile mode. True → "default", False → no compile, or a string like "default", "reduce-overhead", "max-autotune-no-cudagraphs". Returns: model (torch.nn.Module): Compiled model if compilation succeeds, otherwise the original unmodified model. Notes: - If the current PyTorch build does not provide torch.compile, the function returns the input model immediately. - Warmup runs under torch.inference_mode and may use torch.autocast for CUDA/MPS to align compute precision. - CUDA devices are synchronized after warmup to account for asynchronous kernel execution. Examples: >>> device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") >>> # Try to compile and warm up a model with a 640x640 input >>> model = attempt_compile(model, device=device, imgsz=640, use_autocast=True, warmup=True) compileTdefaultzcompile:z starting torch.compile with 'z ' mode...z max-autotunez mode='zB' not recommended, using mode='max-autotune-no-cudagraphs' insteadzmax-autotune-no-cudagraphsinductor)r0backendz. torch.compile failed, continuing uncompiled: Nrrrrr5>r_r5z complete in rz s (compile z s + warmup zs)z compile complete in z s (no warmup))rr'rr rrrmr perf_counterrr>rrrr)r4r5r)rr6r use_autocastwarmupr0rt0r t_compilet_warmdummyt1r@totals r"attempt_compilers#J 5) $D  t| j !F KK6(8iHI ~&.pqr+   B e$ C!!#b(I F  Aq%v> FKK61JJLE      ! ! # !  >^^FKK0%e A%%%L  ! ;;& JJ " "6 *""$r)  E  vhmE#;k)CP[\bcf[ggijk L  vh3Ic?-PQ L7 &!OPQsST %% ! !sB8G00H.> H"H.0 H9HHH"H+ 'H..H7)rr)r5)r1boolr6rd)rSFT)FT)r)r-Fr)r.r.)r.)r nn.Modulereturnr)rr-d)rF)zbest.ptrSN)rz str | Pathr{rdrzdict[str, Any]rrrY) Nr)rFFr)rtorch.nn.Moduler6z torch.devicerrrrrrr0z bool | strrr)Z __future__r functoolsrr3rorer contextlibrcopyrrpathlibrtypingrnumpyrgr'torch.distributed distributedrtorch.nnrtorch.nn.functional functionalr8 ultralyticsr r<r r r r rrrrrultralytics.utils.checksrultralytics.utils.cpurultralytics.utils.patchesrr& TORCH_1_10 TORCH_1_11r2ru TORCH_2_1 TORCH_2_4TORCHVISION_0_10TORCHVISION_0_11TORCHVISION_0_13TORCHVISION_0_18rmr#r/r4 lru_cacher@rHrrrrrrrrrrr+r>rIrOrTr r`rornrrrrrrrrr.r-r"rsd# % #   3)0 - 1 =( 3 =( 3 =( 3 - 1 - 1 - 1  !4h? !4h? !4h? !4h? }]I6FNN B  M M 0:  7 7 NN ^B&D(D* Z6 I D'TD ?." t ^( V4+A9A9H:z$2Sl33r M M M M M  M  MMr-