FiddlZddlZddlZddlZddlmZddlmZddlZddl m Z ddl m Z ddl mZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZIddlJmKZKmLZLmMZMmNZNmOZOmPZPddlQmRZRmSZSmTZTddlUmVZVmWZWmXZXmYZYmZZZm[Z[m\Z\dd l]m^Z^dd l_m`Z`dd lambZbdd lcmdZdmeZemfZfmgZgmhZhmiZimjZjmkZkGd dejjZmGddemZnGddenZoGddenZpGddenZqGddemZrGddenZsGddenZtGddenZuGdd euepZvGd!d"ejjZxejd.d#ZzGd$d%Z{Gd&d'ejZ}d/d(Z~d0d)Zd1d*Zd+Zd,Zd-Zy)2N)deepcopy)Path)check_class_names)<AIFIC1C2C2PSAC3C3TRELAN1OBBOBB26PSASPPSPPELANSPPFA2C2fAConvADown Bottleneck BottleneckCSPC2fC2fAttnC2fCIBC2fPSAC3GhostC3k2C3xCBFuseCBLinearClassifyConcatConvConv2 ConvTransposeDetectDWConvDWConvTranspose2dFocusGhostBottleneck GhostConvHGBlockHGStemImagePoolingAttnIndexLRPCHeadPosePose26RepC3RepConv RepNCSPELAN4RepVGGDW ResNetLayer RTDETRDecoderSCDownSegment Segment26 TorchVision WorldDetect YOLOEDetect YOLOESegmentYOLOESegment26 v10Detect)DEFAULT_CFG_DICTLOGGERWINDOWSYAMLcolorstremojis)check_requirements check_suffix check_yaml)E2ELoss PoseLoss26v8ClassificationLossv8DetectionLoss v8OBBLoss v8PoseLossv8SegmentationLoss)make_divisible) torch_load)feature_visualization)fuse_conv_and_bnfuse_deconv_and_bninitialize_weightsintersect_dicts model_info scale_imgsmart_inference_mode time_synccreZdZdZdZddZddZdZdZddZ ddZ dd Z fd Z dd Z dd Zd ZxZS) BaseModelaBase class for all YOLO models in the Ultralytics family. This class provides common functionality for YOLO models including forward pass handling, model fusion, information display, and weight loading capabilities. Attributes: model (torch.nn.Sequential): The neural network model. save (list): List of layer indices to save outputs from. stride (torch.Tensor): Model stride values. Methods: forward: Perform forward pass for training or inference. predict: Perform inference on input tensor. fuse: Fuse Conv/BatchNorm layers and reparameterize for optimization. info: Print model information. load: Load weights into the model. loss: Compute loss for training. Examples: Create a BaseModel instance >>> model = BaseModel() >>> model.info() # Display model information czt|tr|j|g|i|S|j|g|i|S)a'Perform forward pass of the model for either training or inference. If x is a dict, calculates and returns the loss for training. Otherwise, returns predictions for inference. Args: x (torch.Tensor | dict): Input tensor for inference, or dict with image tensor and labels for training. *args (Any): Variable length argument list. **kwargs (Any): Arbitrary keyword arguments. Returns: (torch.Tensor): Loss if x is a dict (training), or network predictions (inference). ) isinstancedictlosspredict)selfxargskwargss V/var/www/pod-logistic/pod-ai/venv/lib/python3.12/site-packages/ultralytics/nn/tasks.pyforwardzBaseModel.forwardsD a 499Q000 0t||A////cP|r|j|S|j||||S)aPerform a forward pass through the network. Args: x (torch.Tensor): The input tensor to the model. profile (bool): Print the computation time of each layer if True. visualize (bool): Save the feature maps of the model if True. augment (bool): Augment image during prediction. embed (list, optional): A list of layer indices to return embeddings from. Returns: (torch.Tensor): The last output of the model. )_predict_augment _predict_once)rdreprofile visualizeaugmentembeds rhrczBaseModel.predicts/ ((+ +!!!Wi??rjcNggg}}}| t|ndh}t|}|jD]n} | jdk7rMt | jt r|| jn#| jD cgc]} | dk(r|n|| c} }|r|j | ||| |}|j| j|jvr|nd|r#t|| j| j|| j|vs|jtjjj|dj!dj!d| j|k(sDtj"tj$|ddcS|Scc} w)aPerform a forward pass through the network. Args: x (torch.Tensor): The input tensor to the model. profile (bool): Print the computation time of each layer if True. visualize (bool): Save the feature maps of the model if True. embed (list, optional): A list of layer indices to return embeddings from. Returns: (torch.Tensor): The last output of the model. Nsave_dirrwrwrdim frozensetmaxmodelfr`int_profile_one_layerappendisaverTtypetorchnn functionaladaptive_avg_pool2dsqueezeunbindcat) rdrernrorqydt embeddingsmax_idxmjs rhrmzBaseModel._predict_onces[Bz2$)$5 % B4e* IAssby(c2AaccFYZY\Y\8]TUa2g1Q49O8]''1b1!A HH!##*Q 5%ayIsse|!!%(("5"5"I"I!V"T"\"\]_"`"h"hik"lm33'> << *a(@aHH I9^s8F"c|tj|jjd|j |S)zFPerform augmentations on input image x and return augmented inference.zR does not support 'augment=True' prediction. Reverting to single-scale prediction.)rCwarning __class____name__rm)rdres rhrlzBaseModel._predict_augments;~~&&'(4 5 !!!$$rjc  ddl}||jdk(xrt|t}|r0|j ||r|j n|gdddz dznd}t}tdD]}||r|j n||jt|z d z||jdk(r!tjd d d d d d dd dtj|ddd |dd |jdd|j|r+tjt|dd dd d dd dyy#t$rd}YTwxYw)a/Profile the computation time and FLOPs of a single layer of the model on a given input. Args: m (torch.nn.Module): The layer to be profiled. x (torch.Tensor): The input data to the layer. dt (list): A list to store the computation time of the layer. rNrsF)inputsverbosegeA dz time (ms)z>10s GFLOPsparamsz modulez10.2f10.0f -z Total)thop ImportErrorr}r`listrncopyr\rangerrCinfonprsum) rdrrerrcflopst_s rhrzBaseModel._profile_one_layersV   B  7Jq$$7^b QA1'=u MaPSVVYZZhi Kr $A !affh # $ 9;?c)*  1  KK;t,Aht_Aht_HU V r"venAeE]!ADDz%BaseModel.is_fused.. sJAfk1Js c36K|]}t|ywN)r`)rrrs rhrz%BaseModel.is_fused.. s=:a$=s)tuplerr__dict__itemsrr)rdthreshrs @rhrzBaseModel.is_fusedsDJ!2!2!8!8!:J J=dlln==FFrjc t||||S)a#Print model information. Args: detailed (bool): If True, prints out detailed information about the model. verbose (bool): If True, prints out the model information. imgsz (int): The size of the image used for computing model information. )detailedrimgsz)rY)rdrrrs rhrzBaseModel.info s$7%PPrjct||}|jd}t|trE||j |_||j |_||j|_|S)aApply a function to all tensors in the model, including Detect head attributes like stride and anchors. Args: fn (function): The function to apply to the model. Returns: (BaseModel): An updated BaseModel object. rs)super_applyr}r`r&strideanchorsstridesrdfnrrs rhrzBaseModel._applysaw~b! JJrN  v !((|AH199 AI199 AI rjc dt|tr|dn|}|jj}t ||j}|j |dt |}d}|j}||vrm||vri||j\} } } } ||j\} }}}|| k(r<|| k(r7t| | t| |} } ||d| d| f||d| d| f<|dz }|r>tjd|dt |jjd yy) zLoad weights into the model. Args: weights (dict | torch.nn.Module): The pre-trained weights to be loaded. verbose (bool, optional): Whether to log the transfer progress. r}F)strictzmodel.0.conv.weightNrwz Transferred /z items from pretrained weights) r`rafloat state_dictrXload_state_dictlenshapeminrCrr})rdweightsrr}csd updated_csdlen_updated_csd first_convrc1c2hwcc1cc2chcws rhloadzBaseModel.load*sA%/w$= 7kkm&&(%c4??+<=  [7k** __& [ (Z:-E%j177LBAq":44 Cb"Qw27Rs2s|B36z?3B383L :&ssCRCx01$  KK,&7qTZZ=R=R=T9U8VVtu v rjct|dd|j|_||j|d}|j||S)Compute loss. Args: batch (dict): Batch to compute loss on. preds (torch.Tensor | list[torch.Tensor], optional): Predictions. criterionNimg)rinit_criterionrrirdbatchpredss rhrbzBaseModel.lossCsK 4d + 3!002DN =LLu.E~~eU++rjctd)z0Initialize the loss criterion for the BaseModel.z4compute_loss() needs to be implemented by task heads)NotImplementedErrorrds rhrzBaseModel.init_criterionQs!"XYYrj)FFFN)FFNT)r)FTir)r __module__ __qualname____doc__rircrmrlrrrrrrrbr __classcell__rs@rhr^r^fsK00"@"<%I2B GQ&w2 ,Zrjr^ceZdZdZd fd ZedZejdZdZfdZ e d dZ dZ d Z xZS) DetectionModelaWYOLO detection model. This class implements the YOLO detection architecture, handling model initialization, forward pass, augmented inference, and loss computation for object detection tasks. Attributes: yaml (dict): Model configuration dictionary. model (torch.nn.Sequential): The neural network model. save (list): List of layer indices to save outputs from. names (dict): Class names dictionary. inplace (bool): Whether to use inplace operations. end2end (bool): Whether the model uses end-to-end detection. stride (torch.Tensor): Model stride values. Methods: __init__: Initialize the YOLO detection model. _predict_augment: Perform augmented inference. _descale_pred: De-scale predictions following augmented inference. _clip_augmented: Clip YOLO augmented inference tails. init_criterion: Initialize the loss criterion. Examples: Initialize a detection model >>> model = DetectionModel("yolo26n.yaml", ch=3, nc=80) >>> results = model.predict(image_tensor) c t t|tr|n t |_j ddddk(r*t jddj ddd<|j d<|rI|j dk7r7t jd j dd ||j d<ttj || \_ _ tj dDcic]}||c}_j jd d _jd}t|t"rd}j |_fd}jj%d |_t)j*|t)j,d|||D cgc]} || j.dz c} |_|j0_jj3|j5nt)j6dg_t9|r&jt jdyycc}wcc} w)aQInitialize the YOLO detection model with the given config and parameters. Args: cfg (str | dict): Model configuration file path or dictionary. ch (int): Number of input channels. nc (int, optional): Number of classes. verbose (bool): Whether to display model information. backbonerrSilencezYOLOv9 `Silence` module is deprecated in favor of torch.nn.Identity. Please delete local *.pt file and re-download the latest model checkpoint.z nn.IdentitychannelsncOverriding model.yaml nc= with nc=rrinplaceTrscRj|}jr|d}|dS)z_Perform a forward pass through the model, handling different Detect subclass types accordingly.one2manyfeats)rir)reoutputrds rh_forwardz)DetectionModel.__init__.._forwards+a<<#J/Fg&rjrw N)r__init__r`rayaml_model_loadyamlrCrr parse_modelrr}rrnamesgetrr&evaltrainingrtensorzerosrrtrain bias_initTensorrW) rdcfgrrrrrsr rers ` rhrzDetectionModel.__init__rs %c40Coc6J 99Z  #A &) 3 NN] +8DIIj !! $Q '!# * " $' KK3DIIdO3DIbTR S DIIdO +HTYY,?BPW X DI).tyy)?@AaA3i@ yy}}Y5  JJrN a A AI ' JJOO AJ||hu{{STVXZ[]^G_>`$aQ_$abAH((DK JJ    KKM,,t,DK 4  IIK KKO 7A$%bs  JJc6t|jdddS)z? D!Q   rjc :t|dds|jjdk7r&tjd|j |S|j dd}gd}gd}g}t||D]~\}}t|r|j|n||t|jj }t |9|d } |j| |||} |j!| |j#|}t%j&|d dfS) aPerform augmentations on input image x and return augmented inference and train outputs. Args: x (torch.Tensor): Input image tensor. Returns: (tuple[torch.Tensor, None]): Augmented inference output and None for train output. rFrzLModel does not support 'augment=True', reverting to single-scale prediction.r N)rwg(\?gq= ףp?)NN)gsrrs)rrrrCrrmrziprZfliprrr|rrc _descale_predr_clip_augmentedrr) rdreimg_sizerr~rsifixiyirs rhrlzDetectionModel._predict_augments 4E *dnn.E.EIY.Y NNi j%%a( (7723<   !Qi FB166":B3t{{?P;QRB$Q'B##BB9B HHRL     #yyB%%rjc|ddddfxx|zcc<|jddd|j|dz f|\}}}}|dk(r |d|z }n |dk(r|d|z }tj||||f|S)aDe-scale predictions following augmented inference (inverse operation). Args: p (torch.Tensor): Predictions tensor. flips (int | None): Flip type (None=none, 2=ud, 3=lr). scale (float): Scale factor. img_size (tuple): Original image size (height, width). dim (int): Dimension to split at. Returns: (torch.Tensor): De-scaled predictions. Nrwrrr()splitrrr) pflipsscaler.ryrerwhclss rhr,zDetectionModel._descale_preds !RaR%EAq!''#,*: ;SA 1b# A: aA aZ aAyy!QC#..rjcz|jdjtdtD}d}|djd|ztdt|Dz}|ddd| f|d<|djd|ztfdt|Dz}|dd|df|d<|S) zClip YOLO augmented inference tails. Args: y (list[torch.Tensor]): List of detection tensors. Returns: (list[torch.Tensor]): Clipped detection tensors. rsc3&K|] }d|z ywr4Nrrres rhrz1DetectionModel._clip_augmented..s(1(rwrc3&K|] }d|z ywr=rr>s rhrz1DetectionModel._clip_augmented..s'?1'?r?.Nc34K|]}ddz |z zyw)r4rwNr)rrenls rhrz1DetectionModel._clip_augmented..s(MqrAvz):(Ms)r}rBrrr)rdrgerrBs @rhr-zDetectionModel._clip_augmentedsZZ^   (eBi( (  qTZZ^q C'?eAh'?$? ?tC1"H~! rU[[_ !S(ME!H(M%M M"c12g"rjcHt|ddr t|St|S)z5Initialize the loss criterion for the DetectionModel.rF)rrKrNrs rhrzDetectionModel.init_criterions" 'i ?wt}Z_UYEZZrj)z yolo26n.yamlr(NT)rw)rrrrrpropertyrsetterr!rl staticmethodr,r-rrrs@rhrrVsc65n99 ^^**  &0//*$[rjrc*eZdZdZdfd ZdZxZS)OBBModelaYOLO Oriented Bounding Box (OBB) model. This class extends DetectionModel to handle oriented bounding box detection tasks, providing specialized loss computation for rotated object detection. Methods: __init__: Initialize YOLO OBB model. init_criterion: Initialize the loss criterion for OBB detection. Examples: Initialize an OBB model >>> model = OBBModel("yolo26n-obb.yaml", ch=3, nc=80) >>> results = model.predict(image_tensor) c,t|||||y)aCInitialize YOLO OBB model with given config and parameters. Args: cfg (str | dict): Model configuration file path or dictionary. ch (int): Number of input channels. nc (int, optional): Number of classes. verbose (bool): Whether to display model information. rrrrNrrrdrrrrrs rhrzOBBModel.__init__ SRB@rjcRt|ddrt|tSt|S)z,Initialize the loss criterion for the model.rF)rrKrOrs rhrzOBBModel.init_criterion s&+24E+JwtY'_PYZ^P__rj)zyolo26n-obb.yamlr(NTrrrrrrrrs@rhrJrJs  A`rjrJc*eZdZdZdfd ZdZxZS)SegmentationModelaYOLO segmentation model. This class extends DetectionModel to handle instance segmentation tasks, providing specialized loss computation for pixel-level object detection and segmentation. Methods: __init__: Initialize YOLO segmentation model. init_criterion: Initialize the loss criterion for segmentation. Examples: Initialize a segmentation model >>> model = SegmentationModel("yolo26n-seg.yaml", ch=3, nc=80) >>> results = model.predict(image_tensor) c,t|||||y)aXInitialize Ultralytics YOLO segmentation model with given config and parameters. Args: cfg (str | dict): Model configuration file path or dictionary. ch (int): Number of input channels. nc (int, optional): Number of classes. verbose (bool): Whether to display model information. rLNrMrNs rhrzSegmentationModel.__init__5rOrjcRt|ddrt|tSt|S)z8Initialize the loss criterion for the SegmentationModel.rF)rrKrQrs rhrz SegmentationModel.init_criterion@s'4;D)U4Swt/0qYklpYqqrj)zyolo26n-seg.yamlr(NTrQrs@rhrSrS%s  ArrjrSc*eZdZdZdfd ZdZxZS) PoseModela^YOLO pose model. This class extends DetectionModel to handle human pose estimation tasks, providing specialized loss computation for keypoint detection and pose estimation. Attributes: kpt_shape (tuple): Shape of keypoints data (num_keypoints, num_dimensions). Methods: __init__: Initialize YOLO pose model. init_criterion: Initialize the loss criterion for pose estimation. Examples: Initialize a pose model >>> model = PoseModel("yolo26n-pose.yaml", ch=3, nc=1, data_kpt_shape=(17, 3)) >>> results = model.predict(image_tensor) ct|ts t|}t|r=t |t |dk7r#t j d|dd|||d<t|!||||y)alInitialize Ultralytics YOLO Pose model. Args: cfg (str | dict): Model configuration file path or dictionary. ch (int): Number of input channels. nc (int, optional): Number of classes. data_kpt_shape (tuple): Shape of keypoints data. verbose (bool): Whether to display model information. kpt_shapez Overriding model.yaml kpt_shape=z with kpt_shape=rLN) r`raranyrrCrrr)rdrrrdata_kpt_shaperrs rhrzPoseModel.__init__Xsz#t$!#&C ~ 4#74K@P;Q#Q KK:3{;K:LL\]k\lm n-C  SRB@rjcRt|ddrt|tSt|S)z0Initialize the loss criterion for the PoseModel.rF)rrKrLrPrs rhrzPoseModel.init_criterionis&,3D)U,KwtZ(aQ[\`Qaarj)zyolo26n-pose.yamlr(NNNTrQrs@rhrWrWEs$A"brjrWc@eZdZdZdfd ZdZedZdZxZ S)ClassificationModelaoYOLO classification model. This class implements the YOLO classification architecture for image classification tasks, providing model initialization, configuration, and output reshaping capabilities. Attributes: yaml (dict): Model configuration dictionary. model (torch.nn.Sequential): The neural network model. stride (torch.Tensor): Model stride values. names (dict): Class names dictionary. Methods: __init__: Initialize ClassificationModel. _from_yaml: Set model configurations and define architecture. reshape_outputs: Update model to specified class count. init_criterion: Initialize the loss criterion. Examples: Initialize a classification model >>> model = ClassificationModel("yolo26n-cls.yaml", ch=3, nc=1000) >>> results = model.predict(image_tensor) cJt||j||||y)a\Initialize ClassificationModel with YAML, channels, number of classes, verbose flag. Args: cfg (str | dict): Model configuration file path or dictionary. ch (int): Number of input channels. nc (int, optional): Number of classes. verbose (bool): Whether to display model information. N)rr _from_yamlrNs rhrzClassificationModel.__init__s"  RW-rjct|tr|n t||_|jj d|x}|jd<|rJ||jdk7r8t j d|jdd|||jd<n)|s'|jj dds tdtt|j||\|_ |_ tjdg|_t|jdDcic]}||c}|_|j ycc}w) aTSet Ultralytics YOLO model configurations and define the model architecture. Args: cfg (str | dict): Model configuration file path or dictionary. ch (int): Number of input channels. nc (int, optional): Number of classes. verbose (bool): Whether to display model information. rrrrNzFnc not specified. Must specify nc in model.yaml or function arguments.rrw)r`rarrrrCr ValueErrorrrr}rrrrrr)rdrrrrrs rhrazClassificationModel._from_yamls&c40Coc6J &*YY]]:r%BBTYYz " " $' KK3DIIdO3DIbTR S DIIdODIIMM$5ef f +HTYY,?BPW X DIllA3' ).tyy)?@AaA3i@  As& E cftt|dr |jn|jd\}}t |t rT|j j|k7r:tjj|j j||_yyt |tjjrF|j|k7r6t||tjj|j|yyt |tjjr|Dcgc] }t|}}tjj|vrt|dz |dddj!tjjz }||j|k7r1tjj||j|||<yytjj"|vrt|dz |dddj!tjj"z }||j$|k7r^tjj#||j&|||j(||j*||j,du||<yyyycc}w)zUpdate a TorchVision classification model to class count 'nc' if required. Args: model (torch.nn.Module): Model to update. nc (int): New number of classes. r}rsrwN)bias)rrr}named_childrenr`r!linear out_featuresrrLinear in_featuresr% SequentialrrindexConv2d out_channels in_channels kernel_sizerre)r}rnamerretypesrs rhreshape_outputsz#ClassificationModel.reshape_outputss wug'> EYY[\]_`a a "xx$$* 88??188+?+?D+ 588?? +~~#tUXX__Q]]B%GH$ 588.. /&'(T!W(E(xx%'JNU4R4[%6%6uxx%GGQ4$$* 88??1Q4+;+;R@AaD+E)JNU4R4[%6%6uxx%GGQ4$$* 88??!(("ad.>.>! RSTURVR[R[cgRg+AaD+* 0(s/J.ctS)z:Initialize the loss criterion for the ClassificationModel.)rMrs rhrz"ClassificationModel.init_criterions #%%rj)zyolo26n-cls.yamlr(NT) rrrrrrarHrsrrrs@rhr_r_ns+. ..6&rjr_cDeZdZdZdfd ZfdZdZddZd dZxZ S) RTDETRDetectionModelarRTDETR (Real-time DEtection and Tracking using Transformers) Detection Model class. This class is responsible for constructing the RTDETR architecture, defining loss functions, and facilitating both the training and inference processes. RTDETR is an object detection and tracking model that extends from the DetectionModel base class. Attributes: nc (int): Number of classes for detection. criterion (RTDETRDetectionLoss): Loss function for training. Methods: __init__: Initialize the RTDETRDetectionModel. init_criterion: Initialize the loss criterion. loss: Compute loss for training. predict: Perform forward pass through the model. Examples: Initialize an RTDETR model >>> model = RTDETRDetectionModel("rtdetr-l.yaml", ch=3, nc=80) >>> results = model.predict(image_tensor) c,t|||||y)a.Initialize the RTDETRDetectionModel. Args: cfg (str | dict): Configuration file name or path. ch (int): Number of input channels. nc (int, optional): Number of classes. verbose (bool): Print additional information during initialization. rLNrMrNs rhrzRTDETRDetectionModel.__init__rOrjct||}|jd}||j|_||j|_|S)a Apply a function to all tensors in the model, including decoder anchors and valid mask. Args: fn (function): The function to apply to the model. Returns: (RTDETRDetectionModel): An updated RTDETRDetectionModel object. rs)rrr}r valid_maskrs rhrzRTDETRDetectionModel._applysDw~b! JJrNqyyM !,,'  rjc6ddlm}||jdS)z;Initialize the loss criterion for the RTDETRDetectionModel.r)RTDETRDetectionLossT)ruse_vfl)ultralytics.models.utils.lossr{r)rdr{s rhrz#RTDETRDetectionModel.init_criterionsE"dggt< << *a(@aHH Izz"~ '1!A$' /9^(s ;G G)z rtdetr-l.yamlr(NTrFFNFN) rrrrrrrrbrcrrs@rhrvrvs#, A = , \ rjrvcDeZdZdZdfd ZddZddZd dZd dZxZ S) WorldModelapYOLOv8 World Model. This class implements the YOLOv8 World model for open-vocabulary object detection, supporting text-based class specification and CLIP model integration for zero-shot detection capabilities. Attributes: txt_feats (torch.Tensor): Text feature embeddings for classes. clip_model (torch.nn.Module): CLIP model for text encoding. Methods: __init__: Initialize YOLOv8 world model. set_classes: Set classes for offline inference. get_text_pe: Get text positional embeddings. predict: Perform forward pass with text features. loss: Compute loss with text features. Examples: Initialize a world model >>> model = WorldModel("yolov8s-world.yaml", ch=3, nc=80) >>> model.set_classes(["person", "car", "bicycle"]) >>> results = model.predict(image_tensor) cztjd|xsdd|_d|_t|||||y)aGInitialize YOLOv8 world model with given config and parameters. Args: cfg (str | dict): Model configuration file path or dictionary. ch (int): Number of input channels. nc (int, optional): Number of classes. verbose (bool): Whether to display model information. rwPNrL)rrandn txt_feats clip_modelrrrNs rhrzWorldModel.__init__js:Qb#6 SRB@rjcp|j||||_t||jd_y)a$Set classes in advance so that model could do offline-inference without clip model. Args: text (list[str]): List of class names. batch (int): Batch size for processing text tokens. cache_clip_model (bool): Whether to cache the CLIP model. )rcache_clip_modelrsN) get_text_perrr}r)rdtextrrs rh set_classeszWorldModel.set_classesws2))$eN^)_I 2rjcddlm}t|jj j }t |dds|r|d||_|r |jn |d|}|j|}|j|Dcgc]!}|j|j#} }t| dk(r| dntj| d} | jd t|| j d Scc}w) aOGet text positional embeddings using the CLIP model. Args: text (list[str]): List of class names. batch (int): Batch size for processing text tokens. cache_clip_model (bool): Whether to cache the CLIP model. Returns: (torch.Tensor): Text positional embeddings. rbuild_text_modelrNz clip:ViT-B/32rrwrxrs)ultralytics.nn.text_modelrnextr} parametersrrrtokenizer5 encode_textrrrrreshaper) rdrrrrrr} text_tokentokenrs rhrzWorldModel.get_text_pes ?djj++-.55t\405E.vNDO#39I/bh9i^^D) DNDTDTUZD[\5U&&u-446\ \$' Na$7IaLUYYyVW=X   SY 0CDD]s&D c&| |jn|j|j|j}|jd|jdk7s|j dj r |j|jddd}|j}ggg} } }| t|ndh}t|} |j D]} | jdk7rMt| jtr|| jn#| jD cgc]} | dk(r|n|| c} }|r|j| || t| tr | ||}n << *a(@aHH) I*'9^sJct|ds|j|_||j|d|d}|j||S)rrrr)r)rrrrirs rhrbzWorldModel.losssOt[)!002DN =LLu{9KLLE~~eU++rj)zyolov8s-world.yamlr(NT)rTrr) rrrrrrrrcrbrrs@rhrrRs$. A &E.*X ,rjrceZdZdZd fd Zed dZedZdZdZ dZ dZ d d Z dd Z xZS) YOLOEModelaYOLOE detection model. This class implements the YOLOE architecture for efficient object detection with text and visual prompts, supporting both prompt-based and prompt-free inference modes. Attributes: pe (torch.Tensor): Prompt embeddings for classes. clip_model (torch.nn.Module): CLIP model for text encoding. Methods: __init__: Initialize YOLOE model. get_text_pe: Get text positional embeddings. get_visual_pe: Get visual embeddings. set_vocab: Set vocabulary for prompt-free model. get_vocab: Get fused vocabulary layer. set_classes: Set classes for offline inference. get_cls_pe: Get class positional embeddings. predict: Perform forward pass with prompts. loss: Compute loss with prompts. Examples: Initialize a YOLOE model >>> model = YOLOEModel("yoloe-v8s.yaml", ch=3, nc=80) >>> results = model.predict(image_tensor, tpe=text_embeddings) cnt||||||jjdd|_y)a@Initialize YOLOE model with given config and parameters. Args: cfg (str | dict): Model configuration file path or dictionary. ch (int): Number of input channels. nc (int, optional): Number of classes. verbose (bool): Whether to display model information. rL text_modelmobileclip:bltN)rrrrrrNs rhrzYOLOEModel.__init__s2 SRB@))-- 6FGrjcddlm}t|jj j }t |dds|r|t |dd||_|r |jn|t |dd|}|j|}|j|D cgc]!} |j| j#} } t| dk(r| dntj| d } | jd t|| j d } |r| S|jd } t#| t$sJ| j'| Scc} w) aGet text positional embeddings using the CLIP model. Args: text (list[str]): List of class names. batch (int): Batch size for processing text tokens. cache_clip_model (bool): Whether to cache the CLIP model. without_reprta (bool): Whether to return text embeddings without reprta module processing. Returns: (torch.Tensor): Text positional embeddings. rrrNrrrrwrxrs)rrrr}rrrrrr5rrrrrrrr`r>get_tpe) rdrrrwithout_reprtarrr}rrrr&s rhrzYOLOEModel.get_text_pes5 ?djj++-.55t\405E.wt\K[/\eklDO  OO!'$ >N"OX^_  ^^D) DNDTDTUZD[\5U&&u-446\ \$' Na$7IaLUYYyVW=X %%b#d)Y__R5HI  zz"~$ ,,,||I&&]s$&Ec|||dS)zGet visual positional embeddings. Args: img (torch.Tensor): Input image tensor. visual (torch.Tensor): Visual features. Returns: (torch.Tensor): Visual positional embeddings. T)vpe return_vper)rdrvisuals rh get_visual_pezYOLOEModel.get_visual_pesCV55rjc <|jrJ|jd}t|tsJt |j j }|tjdd|jd|jdj|t|d|j}t|d|j}tjdt!t#|||D|jd_t#|j|jD]C\}}t|tj&sJt|tj&sJ|d=|d=Et)||jd_t-||_y) zSet vocabulary for the prompt-free model. Args: vocab (nn.ModuleList): List of vocabulary items. names (list[str]): List of class names. rsrwr(r one2one_cv3 one2one_cv2c3ZK|]#\}\}}}t||d|d|dk7%yw)rsr)enabledN)r0)rrr:pflocs rhrz'YOLOEModel.set_vocab..?s9, ?Pq.3CHS"R&#b'16 : :, s)+N)rr}r`r>rrrremptyrfrrcv3cv2r ModuleList enumerater*lrpcrkrrrr) rdvocabrr&rrrloc_headcls_heads rh set_vocabzYOLOEModel.set_vocab,sV==  zz"~$ ,,,doo'(// U[[Atyy1499W3E F I I& QRdM4884dM4884!mm, T]^abgilnq^rTs,   2#&dhh"9  Hhh 6 66h 6 66     J 2&u- rjc8|jrJ|jd}t|tsJ|jrJ|j |}|j ||t|jjj}|j|jj|t|d|j}tj }|D]2}t|tj"sJ|j%|d4|S)zGet fused vocabulary layer from the model. Args: names (list[str]): List of class names. Returns: (nn.ModuleList): List of vocabulary modules. rsr)rr}r`r>rrrrrrrperrrrrrkr)rdrr&tperrrrs rh get_vocabzYOLOEModel.get_vocabJs==  zz"~$ ,,,==  u% $djj++-.55 $''**V$%dM4884  'Hh 6 66 LL" & ' rjct|jddrJd|jdk(sJ||_t ||jd_t ||_y)zSet classes in advance so that model could do offline-inference without clip model. Args: names (list[str]): List of class names. embeddings (torch.Tensor): Embeddings tensor. rsrz^Prompt-free model does not support setting classes. Please try with Text/Visual prompt models.r(N)rr}ndimrrrrr)rdrrs rhrzYOLOEModel.set_classesdsa4::b>62 l 2!###J 2&u- rjc *g}|"|jdk(sJ|j||"|jdk(sJ|j||s1|jt|dtjdddtj |dS)a Get class positional embeddings. Args: tpe (torch.Tensor | None): Text positional embeddings. vpe (torch.Tensor | None): Visual positional embeddings. Returns: (torch.Tensor): Class positional embeddings. r(rrwrrrx)rrrrrr)rdrrall_pes rh get_cls_pezYOLOEModel.get_cls_pess ?88q= = MM#  ?88q= = MM#  MM'$ekk!R.EF GyyQ''rjc ggg} } } |jd} | t|ndh}t|} |jD];}|jdk7rMt |jt r| |jn#|jDcgc]}|dk(r|n| |c}}|r|j||| t |tr||j||nd}|r|J|jrJ|cS|j|j||j|dj|dj}|jd| k7s |j r|j#| dd}|j%|||}| j%|j&|j(vr|nd|r#t+||j,|j&||j&|vs| j%t.j0j2j5|dj7dj7d|j&| k(st/j8t/j:| ddcS|Scc}w) aPerform a forward pass through the model. Args: x (torch.Tensor): The input tensor. profile (bool): If True, profile the computation time for each layer. visualize (bool): If True, save feature maps for visualization. tpe (torch.Tensor, optional): Text positional embeddings. augment (bool): If True, perform data augmentation during inference. embed (list, optional): A list of layer indices to return embeddings from. vpe (torch.Tensor, optional): Visual positional embeddings. return_vpe (bool): If True, return visual positional embeddings. Returns: (torch.Tensor): Model's output tensor. rNrsrrtrvrwrx)rr{r|r}r~r`rrr>get_vperrrrrrrrrrrrTrrrrrrrr)rdrernrorrprqrrrrrbrrrcls_pes rhrczYOLOEModel.predicts$Bz2 GGAJ$)$5 % B4e* IAssby(c2AaccFYZY\Y\8]TUa2g1Q49O8]''1b1![)+.?aii3'?*?#}},,J3=@@! [\]^[_[e[e@f<<?a'188#]]1b"5F !A HH!##*Q 5%ayIsse|!!%(("5"5"I"I!V"T"\"\]_"`"h"hik"lm33'> << *a(@aHH/ I0-9^sI>c`t|dsRddlm}|jdddu}|r!t |ddr t ||n||n|j |_|=|j|dd|vrdn|jd d|jdd }|j||S) rrr) TVPDetectLossvisualsNrFrrrr) rultralytics.utils.lossrrrrKrrri)rdrrr visual_prompts rhrbzYOLOEModel.lossst[) <!IIi6dBM!29y%1P}-VcdhVi((* N =LLe %.DEIIk44PIIi.!E ~~eU++rj)zyoloe-v8s.yamlr(NT)rFF)FFNFNNFr)rrrrrr[rrrrrrrcrbrrs@rhrrsc4 H!'!'F 6 6.<4 .(,lq.`,rjrc,eZdZdZdfd ZddZxZS) YOLOESegModela+YOLOE segmentation model. This class extends YOLOEModel to handle instance segmentation tasks with text and visual prompts, providing specialized loss computation for pixel-level object detection and segmentation. Methods: __init__: Initialize YOLOE segmentation model. loss: Compute loss with prompts for segmentation. Examples: Initialize a YOLOE segmentation model >>> model = YOLOESegModel("yoloe-v8s-seg.yaml", ch=3, nc=80) >>> results = model.predict(image_tensor, tpe=text_embeddings) c,t|||||y)aMInitialize YOLOE segmentation model with given config and parameters. Args: cfg (str | dict): Model configuration file path or dictionary. ch (int): Number of input channels. nc (int, optional): Number of classes. verbose (bool): Whether to display model information. rLNrMrNs rhrzYOLOESegModel.__init__rOrjcTt|dsRddlm}|jdddu}|r!t |ddr t ||n||n|j |_|7|j|d|jd d|jdd }|j||S) rrr)TVPSegmentLossrNrFrrr) rrrrrrKrrri)rdrrrrs rhrbzYOLOESegModel.lossst[) =!IIi6dBM!3:$ 52Q~.WefjWk((* N =LLu599[$3OUZU^U^_hjnUoLpE~~eU++rj)zyoloe-v8s-seg.yamlr(NTr)rrrrrrbrrs@rhrrs  A,rjrc*eZdZdZfdZddZxZS)EnsembleaEnsemble of models. This class allows combining multiple YOLO models into an ensemble for improved performance through model averaging or other ensemble techniques. Methods: __init__: Initialize an ensemble of models. forward: Generate predictions from all models in the ensemble. Examples: Create an ensemble of models >>> ensemble = Ensemble() >>> ensemble.append(model1) >>> ensemble.append(model2) >>> results = ensemble(image_tensor) c"t|y)z!Initialize an ensemble of models.NrM)rdrs rhrzEnsemble.__init__s rjc v|Dcgc]}|||||d}}tj|d}|dfScc}w)aRun ensemble forward pass and concatenate predictions from all models. Args: x (torch.Tensor): Input tensor. augment (bool): Whether to augment the input. profile (bool): Whether to profile the model. visualize (bool): Whether to visualize the features. Returns: (torch.Tensor): Concatenated predictions from all models. (None): Always None for ensemble inference. rrN)rr)rdrerprnromodulers rhrizEnsemble.forwardsIFJ J6VAw 3A 6 J J IIaO$w Ks6)FFF)rrrrrrirrs@rhrrs"rjrc #K|i}|i}ddl}ddlm} |jD]R\}}|j dd\}}|j dd\}} t |||t ||| T|jD]\}}|||j|<d|D]}||jvs|j|= y#|D]}||jvs|j|= wxYww)aContext manager for temporarily adding or modifying modules in Python's module cache (`sys.modules`). This function can be used to change the module paths during runtime. It's useful when refactoring code, where you've moved a module from one location to another, but you still want to support the old import paths for backwards compatibility. Args: modules (dict, optional): A dictionary mapping old module paths to new module paths. attributes (dict, optional): A dictionary mapping old module attributes to new module attributes. Examples: >>> with temporary_modules({"old.module": "new.module"}, {"old.module.attribute": "new.module.attribute"}): >>> import old.module # this will now import new.module >>> from old.module import attribute # this will now import new.module.attribute Notes: The changes are only in effect inside the context manager and are undone once the context manager exits. Be aware that directly manipulating `sys.modules` can lead to unpredictable results, especially in larger applications or libraries. Use this function with caution. Nr) import_module.rw)sys importlibrrrsplitr%rr) r attributesrroldnew old_moduleold_attr new_modulenew_attrs rhtemporary_modulesr/s, '%"((* gHC#&::c1#5 J#&::c1#5 J M*-xzAZ\d9e f g   2HC,S1CKK  2  %Cckk!KK$ %7 %Cckk!KK$ %s)C8BC,C8C8C5%C55C8ceZdZdZdZdZy) SafeClasszAA placeholder class to replace unknown classes during unpickling.cy)z6Initialize SafeClass instance, ignoring all arguments.Nrrdrfrgs rhrzSafeClass.__init__b rjcy)z/Run SafeClass instance, ignoring all arguments.Nrrs rh__call__zSafeClass.__call__frrjN)rrrrrr rrjrhrr_sK  rjrc"eZdZdZfdZxZS) SafeUnpicklerz>Custom Unpickler that replaces unknown classes with SafeClass.c<d}||vrt|||StS)zAttempt to find a class, returning SafeClass if not among safe modules. Args: module (str): Module name. name (str): Class name. Returns: (type): Found class or SafeClass. )r collectionszcollections.abcbuiltinsmathnumpy)r find_classr)rdrrq safe_modulesrs rhrzSafeUnpickler.find_classns,  \ !7%fd3 3 rj)rrrrrrrs@rhr r ksHrjr c ddlm}t|d||} tddddd d d d trd dindd i5|rKt j d}t|_d|_ t|d5}t||}dddn t|d}dddt+t,s't%j&d!|d"d#|j.i}||fS#1swYLxYw#1swYPxYw#t$r}|jdk(rttd|d||jdk(r/ttd|dt!dj"d|t%j&|d|jd|jd t)|jt|d}Yd}~d}~wwxYw)$aAttempt to load a PyTorch model with the torch.load() function. If a ModuleNotFoundError is raised, it catches the error, logs a warning message, and attempts to install the missing module via the check_requirements() function. After installation, the function again attempts to load the model using torch.load(). Args: weight (str | Path): The file path of the PyTorch model. safe_only (bool): If True, replace unknown classes with SafeClass during loading. Returns: (dict): The loaded model checkpoint. (str): The loaded filename. Examples: >>> from ultralytics.nn.tasks import torch_safe_load >>> ckpt, file = torch_safe_load("path/to/best.pt", safe_only=True) r)attempt_download_assetz.pt)filesuffixzultralytics.utilszultralytics.models.yolozultralytics.data)zultralytics.yolo.utilszultralytics.yolo.v8zultralytics.yolo.dataztorch.nn.Identityz#ultralytics.nn.tasks.DetectionModelz$ultralytics.utils.loss.E2EDetectLoss)z$ultralytics.nn.modules.block.Silencez*ultralytics.nn.tasks.YOLOv10DetectionModelz$ultralytics.utils.loss.v10DetectLosszpathlib.PosixPathzpathlib.WindowsPath)rr safe_picklec4t|jSr)r r)file_objs rhz!torch_safe_load..sM(4K4P4P4Rrjrb) pickle_moduleNcpu) map_locationmodelsu ERROR ❌️ aw appears to be an Ultralytics YOLOv5 model originally trained with https://github.com/ultralytics/yolov5. This model is NOT forwards compatible with YOLOv8 at https://github.com/ultralytics/ultralytics. Recommend fixes are to train a new model using the latest 'ultralytics' package or to run a command with an official Ultralytics model, i.e. 'yolo predict model=yolo26n.pt'z numpy._corez( requires numpy>=1.26.1, however numpy==rz is installed.z appears to require 'zK', which is not in Ultralytics requirements. AutoInstall will run now for 'z' but this feature will be removed in the future. Recommend fixes are to train a new model using the latest 'ultralytics' package or to run a command with an official Ultralytics model, i.e. 'yolo predict model=yolo26n.pt'z The file 'z' appears to be improperly saved or formatted. For optimal results, use model.save('filename.pt') to correctly save YOLO models.r})ultralytics.utils.downloadsrrIrrDrr ModuleTyper  UnpicklerropenrSModuleNotFoundErrorrq TypeErrorrG __import__ __version__rCrrHr`rar})weight safe_onlyrrrr~ckptrDs rhtorch_safe_loadr,s"CfU+ !& )D54 *='@); 9L>c8^ )*?@/1DE    <$#..}= (5 %#R  $%D%a{CDDD"$U;5 t@tBtDtFtHtJtLtNjPjRtTtVtXtZt\t^t`}tt2t4t6t8t:tFtHtJtLtVtXt*t^t,t`h}tcddzD]\\}} d vrtetNjP d!dn2d" vr"tetgd#jh ddn tk  tcD]e\}}tm|tnstqjrtt5|twvr tw|n|jy||<dddg|d$kDrt{t}|| zd$n|x}} |vr|d}}||k7rtt||| zd%} tFurfttd$|d&z| zd%d$<td&d$kDr+t{t}td&|d&zd'z| zd$nd&d&<||gd$d |vrjd&|d$} t:ur d(}|d)vrdd!< t`urd(}|d*vrjd+ t^urd(}n tur |gnq ttthvr8|dd$}}}|||gd&d tur8jd,|d$}n" turd!rd$nd$d,z}n tNjPjur|gn turtfd-|D}nĉ tttttttttttth vrj| | |Dcgc]}| c}g tus tus tus turttd&|| zd%d&< tttttttttth vr| _Vnމ tur#j|Dcgc]}| c}n tur$jd$|Dcgc]}| c}n tur$jd$|Dcgc]}| c}n[ turd}|}||gd$dn? tur |d}n. ttthvrd}|}gd$dn|}|d$kDr/tOjPj fd.t|Dn }to d%d/jd0d}td1|jD|_c||c|_d|_e|_f|r2t jd|d|d|jd2d|dd|jfd3tm|tr|gn|D|j|dk(rgj|tOjPj|t|fS#1swYVxYwcc}wcc}wcc}wcc}w)4aOParse a YOLO model.yaml dictionary into a PyTorch model. Args: d (dict): Model dictionary. ch (int): Input channels. verbose (bool): Whether to print model details. Returns: (torch.nn.Sequential): PyTorch model. (list): Sorted list of layer indices whose outputs need to be saved. rNTinfc3@K|]}j|ywrrrreds rhrzparse_model..s\Qa\s)r activationscalesrreg_maxc3BK|]}j|dyw)g?Nr:r;s rhrzparse_model..shquuQ}hs)depth_multiplewidth_multiplerYr8z'no model scale passed. Assuming scale='r$z activation:r rz>3fromz>20nrz>10rrz<45 argumentsz<30rsrr&znn.r(ztorchvision.ops. torchvisionrwrrFmlxlx)Tg333333?r4c3(K|] }| ywrr)rrers rhrzparse_model..s&qRU&c3(K|] } ywrr)rrrfrs rhrzparse_model..s">1d8">rMr z __main__.c3<K|]}|jywr)numelr>s rhrzparse_model..s7!AGGI7src34K|]}|dk7s |zyw)rsNr)rrers rhrzparse_model..sQabAEQs  )hastrrriterkeysrCrrr# default_actrrFr{r!r%r+rr*rrrr r'r)rrrrrr5r rrrrr r rrrConvTranspose2dr(rr3rr9rrrrr'opsglobalsr`r2 contextlibsuppressrclocals literal_evalr|roundrRrrinsertextendrr-r,r7 BatchNorm2dr"rr&r=r>r:r;r?r@r1r2r rlegacyrArr.r8r rr<r/rkrreplacerrrr~rsorted)!r<rrrRra max_channelsractr>rr?depthwidthrYr8layersrr base_modulesrepeat_modulesr~rFran_rcmrem_rrfrrs!`` @@@rhrrsFHS>R]^aQbcd B2r"v"DF# # #  #   #  #  #  #  #  #  #  #  #  #  #  # !# " ## $ %# & '# ( )# * +# , -# . /# 0 1# 2 3# 4 5# 6 HH $ $7# 8 9# : ;# < =# > ?# @ A# B C# D E# %LL                N&(* & (ABb?Aq!Tz EHHae $"Q&M266"#?1 dO TDAq!S!((4T-.&(]fhqk@P@PQR@SDGTT T./UU1u9%q)9B UDGBRx#CL$9E$A1EG|(T!Wla6G)H5)PRSTQ^bcd^ehi^ic%DG\Q5F"5L(M"NQV"VXYZostuovwQ&T!"X&DN" Aq!DyE>"DGEzD=KK ,F{ $YqE>D>D )VW-. .AQaBBB*ab*DG| Aq! +  Gaa1B %((&& &qE7D &[&A&&B )    KK'1+=aBqE+=> ?G|qL0ANa>FY(T!Wl)Ce)KQOQV['9lN\`bhjmotuu! )^ KK*1A* + " " KK1-aBqE- . -  KK1-aBqE- . (]aBAB&T!"X&D &[AbEB )[%01 1aBABT!"X;DABCDq5UXX ">U1X"> ?aQUh F1RL b 17r}}77AbdBG  KK1R&S "Ru R#wtclS T Q:a+=QC1QQ b 6B " EbF 88   ' 55sTTl,> +--s$.`* `, `1 > `6 * `; `) ct|}|jddDvretjdd|j}t j d|jd|d|j ||jz}tjdd t|}t|d xs t|}tj|}t||d <t||d <|S)zLoad a YOLO model from a YAML file. Args: path (str | Path): Path to the YAML file. Returns: (dict): Model dictionary. c3:K|]}dD] }d||dyw))rIyolov6Nrr;s rhrz"yaml_model_load..s(FvF!uQCs!_F_Fsnsmlxz(\d+)([nslmx])6(.+)?$z \1\2-p6\3z8Ultralytics YOLO P6 models now use -p6 suffix. Renaming z to rz(\d+)([nslmx])(.+)?$z\1\3F)hardr8 yaml_file) rstemresubrCr with_namerr2rJrErguess_model_scale)pathnew_stem unified_pathrvr<s rhrrs :D yyFgFF662L$))LQRVR[R[Q\\`ai`jjklm~~h456617CIFLfcr:classify classifierrdetectsegmentposeobbN)lower)rrs rhcfg2taskz"guess_model_task..cfg2tasksV KOB  % % ' 7 7 q= > Q; A: rjN)z model.argszmodel.model.argszmodel.model.model.argsr0)z model.yamlzmodel.model.yamlzmodel.model.model.yamlrrrrrz-segz-clsz-posez-obbzUnable to automatically guess model task, assuming 'task=detect'. Explicitly define task for your model, i.e. 'task=detect', 'segment', 'classify','pose' or 'obb'.)r`rarYrZ ExceptionrrModulerrr:r?r!r1r r&r=r>rAr2rrwpartsrCr)r}rrers rhr4r4s %   + #E? # #%)K 'A$$Y/ 'Awv ' ' 'L )A$$Y/ )Q( ) ) ) A!g|45 Ax(!At$As#A [)LM %#t%U  UZZ 9 #; uzz !Z5;;%>  "f &; uzz !Uekk%9  $ NN l S # #  ' ' ) )s#HH$:H1H!$H. 1H; r])F)NTFr)rYpicklerxrrrrpathlibrrtorch.nnrultralytics.nn.autobackendrultralytics.nn.modulesrrrr r r r r rrrrrrrrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4r5r6r7r8r9r:r;r<r=r>r?r@rAultralytics.utilsrBrCrDrErFrGultralytics.utils.checksrHrIrJrrKrLrMrNrOrPrQultralytics.utils.opsrRultralytics.utils.patchesrSultralytics.utils.plottingrTultralytics.utils.torch_utilsrUrVrWrXrYrZr[r\rr^rrJrSrWr_rvrrrrrcontextmanagerrrr#r r,r6rrr{r4rrjrhrs  8================|XWQQ10<   mZmZ`l[Yl[^`~`@rr@&b&bRY&)Y&xE>EP,,Dz,z,z.,J 1.,b'uxx""'Z ,%,%^   F$$8Tn"J@6F . Crj