|hddlZddlZddlZddlZddlmZddlmZddlZddl 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@mAZAmBZBmCZCmDZDmEZEddlFmGZGmHZHmIZImJZJmKZKmLZLddlMmNZNmOZOmPZPddlQmRZRmSZSmTZTmUZUmVZVmWZWdd lXmYZYdd lZm[Z[dd l\m]Z]dd l^m_Z_m`Z`maZambZbmcZcmdZdmeZemfZfGd dejjZhGddehZiGddeiZjGddeiZkGddeiZlGddehZmGddeiZnGddeiZoGddeiZpGdd epekZqGd!d"ejjZsejd/d#ZuGd$d%ZvGd&d'ejZxd0d(Zyd1d)Zzd1d*Z{d2d+Z|d,Z}d-Z~d.Zy)3N)deepcopy)Path)check_class_names)8AIFIC1C2C2PSAC3C3TRELAN1OBBPSASPPSPPELANSPPFA2C2fAConvADown Bottleneck BottleneckCSPC2fC2fAttnC2fCIBC2fPSAC3GhostC3k2C3xCBFuseCBLinearClassifyConcatConvConv2 ConvTransposeDetectDWConvDWConvTranspose2dFocusGhostBottleneck GhostConvHGBlockHGStemImagePoolingAttnIndexLRPCHeadPoseRepC3RepConv RepNCSPELAN4RepVGGDW ResNetLayer RTDETRDecoderSCDownSegment TorchVision WorldDetect YOLOEDetect YOLOESegment v10Detect)DEFAULT_CFG_DICTDEFAULT_CFG_KEYSLOGGERYAMLcolorstremojis)check_requirements check_suffix check_yaml) E2EDetectLossv8ClassificationLossv8DetectionLoss 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) BaseModelau Base 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.Module): 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 Conv2d and BatchNorm2d layers 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)a0 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 S/var/www/html/test/engine/venv/lib/python3.12/site-packages/ultralytics/nn/tasks.pyforwardzBaseModel.forward{sD a 499Q000 0t||A////cP|r|j|S|j||||S)a Perform 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 feature vectors/embeddings to return. Returns: (torch.Tensor): The last output of the model. )_predict_augment _predict_once)r_r`profile visualizeaugmentembeds rcr^zBaseModel.predicts/ ((+ +!!!Wi??recNggg}}}| 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)a Perform 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 feature vectors/embeddings to return. Returns: (torch.Tensor): The last output of the model. Nsave_dirrrrrrdim frozensetmaxmodelfr[int_profile_one_layerappendisaverOtypetorchnn functionaladaptive_avg_pool2dsqueezeunbindcat) r_r`rirjrlydt embeddingsmax_idxmjs rcrhzBaseModel._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.)r@warning __class____name__rh)r_r`s rcrgzBaseModel._predict_augments;~~&&'(4 5 !!!$$rec  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)a8 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. rNrnF)inputsverbosegeA dz time (ms)z>10s GFLOPsparamsz modulez10.2f10.0f -z Total)thop ImportErrorrxr[listricopyrWranger|r@infonprsum) r_rr`rrcflopst_s rcr{zBaseModel._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 rcrz%BaseModel.is_fused.. s=:a$=s)tuplerr__dict__itemsrr)r_threshrs @rcrzBaseModel.is_fusedsDJ!2!2!8!8!:J J=dlln==FFrec 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 that the model will be trained on. )detailedrimgsz)rT)r_rrrs rcrzBaseModel.infos$7%PPrect||}|jd}t|trE||j |_||j |_||j|_|S)a Apply a function to all tensors in the model that are not parameters or registered buffers. Args: fn (function): The function to apply to the model. Returns: (BaseModel): An updated BaseModel object. rn)super_applyrxr[r%strideanchorsstrides)r_fnrrs rcrzBaseModel._applysaw~b! JJrN  v !((|AH199 AI199 AI rec 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) z Load 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. rxF)strictzmodel.0.conv.weightNrrz Transferred /z items from pretrained weights) r[r\float state_dictrSload_state_dictlenshapeminr@rrx)r_weightsrrxcsd updated_csdlen_updated_csd first_convrc1c2hwcc1cc2chcws rcloadzBaseModel.load.sA%/w$= 7kkm&&(%c4??+<=  [7k** __& [ (Z:-E%j177LBAq":44 Cb"Qw27Rs2s|B36z?3B383L :&ssCRCx01$  KK,&7qTZZ=R=R=T9U8VVtu v rect|dd|j|_||j|dn|}|j||S) Compute loss. Args: batch (dict): Batch to compute loss on. preds (torch.Tensor | List[torch.Tensor], optional): Predictions. criterionNimg)getattrinit_criterionrrdr_batchpredss rcr]zBaseModel.lossHsL 4d + 3!002DN.3m U5\*~~eU++rectd)z0Initialize the loss criterion for the BaseModel.z4compute_loss() needs to be implemented by task heads)NotImplementedErrorr_s rcrzBaseModel.init_criterionVs!"XYYre)FFFN)FFNT)r)FTir)r __module__ __qualname____doc__rdr^rhrgr{rrrrrr]r __classcell__rs@rcrYrYasK20$@$>%I4 D G Q(w4 ,ZrerYcLeZdZdZdfd ZfdZeddZdZdZ xZ S) DetectionModela\ YOLO 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("yolo11n.yaml", ch=3, nc=80) >>> results = model.predict(image_tensor) c Z 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 _t#jddd_jd t t&rd}j _ fd}jj)d _t-j.|t-j0d|||Dcgc]}||j2dz c} _ j4_jj7 j9nt-j:dg_t=|r&jt jdyycc}wcc}w)aZ Initialize 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=rrinplaceTrnend2endFcjrj|dStttt t frj|dSj|S)z_Perform a forward pass through the model, handling different Detect subclass types accordingly.one2manyr)rrdr[r8r<r0r )r`rr_s rc_forwardz)DetectionModel.__init__.._forwardsV<<<<?:66-7G\SWY\;]-^t||Aq)sdhdpdpqrdssrerr N)r__init__r[r\yaml_model_loadyamlr@rr parse_modelrrxr~rnamesgetrrrr%evaltrainingrtensorzerosrrtrain bias_initTensorrR) r_cfgrrrr}sr r`rrs ` @rcr zDetectionModel.__init__xs! %c40Coc6J 99Z  #A &) 3 NN] +8DIIj !! $Q '!# * " $' KK3DIIdO3DIbTR S DIIdO +HTYY,?BPW X DI).tyy)?@AaA3i@ yy}}Y5 tzz"~y%@  JJrN a A AI t JJOO AJ||hu{{STVXZ[]^G_>`$aQ_$abAH((DK JJ    KKM,,t,DK 4  IIK KKO 7A$%bs  J#3J(c :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) z Perform augmentations on input image x and return augmented inference and train outputs. Args: x (torch.Tensor): Input image tensor. Returns: (torch.Tensor): Augmented inference output. rFrzLModel does not support 'augment=True', reverting to single-scale prediction.r N)rrg(\?gq= ףp?)NN)gsrrn)rrrr@rrhrziprUfliprzrrwrr^ _descale_predr|_clip_augmentedrr) r_r`img_sizerryrsifixiyirs rcrgzDetectionModel._predict_augments 4E *dnn.E.EIY.Y NNi j%%a( (7723<   !Qi FB166":B3t{{?P;QRB$Q'B##BB9B HHRL     #yyB%%rec|ddddfxx|zcc<|jddd|j|dz f|\}}}}|dk(r |d|z }n |dk(r|d|z }tj||||f|S)a De-scale predictions following augmented inference (inverse operation). Args: p (torch.Tensor): Predictions tensor. flips (int): Flip type (0=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. Nrrrrr)splitrrr) pflipsscaler#rtr`rwhclss rcr!zDetectionModel._descale_preds !RaR%EAq!''#,*: ;SA 1b# A: aA aZ aAyy!QC#..recz|jdjtdtD}d}|djd|ztdt|Dz}|ddd| f|d<|djd|ztfdt|Dz}|dd|df|d<|S) z Clip YOLO augmented inference tails. Args: y (List[torch.Tensor]): List of detection tensors. Returns: (List[torch.Tensor]): Clipped detection tensors. rnc3&K|] }d|z ywr)Nrrr`s rcrz1DetectionModel._clip_augmented..s(1(rrrc3&K|] }d|z ywr2rr3s rcrz1DetectionModel._clip_augmented..s'?1'?r4.Nc34K|]}ddz |z zyw)r)rrNr)rr`nls rcrz1DetectionModel._clip_augmented..s(MqrAvz):(Ms)rxr7rrr)r_rger}r7s @rcr"zDetectionModel._clip_augmentedsZZ^   (eBi( (  qTZZ^q C'?eAh'?$? ?tC1"H~! rU[[_ !S(ME!H(M%M M"c12g"recHt|ddr t|St|S)z5Initialize the loss criterion for the DetectionModel.rF)rrGrIrs rcrzDetectionModel.init_criterions#&-dIu&E}T"`?[_K``re)z yolo11n.yamlrNT)rr) rrrrr rg staticmethodr!r"rrrs@rcrr[s286p&2//,&arerc*eZdZdZdfd ZdZxZS)OBBModela YOLO 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("yolo11n-obb.yaml", ch=3, nc=80) >>> results = model.predict(image_tensor) c,t|||||y)aL Initialize 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. rrrrNrr r_rrrrrs rcr zOBBModel.__init__  SRB@rect|S)z,Initialize the loss criterion for the model.)rJrs rcrzOBBModel.init_criterions re)zyolo11n-obb.yamlrNTrrrrr rrrs@rcr=r=s Arer=c*eZdZdZdfd ZdZxZS)SegmentationModela  YOLO 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("yolo11n-seg.yaml", ch=3, nc=80) >>> results = model.predict(image_tensor) c,t|||||y)aa Initialize 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. r?Nr@rAs rcr zSegmentationModel.__init__+rBrect|S)z8Initialize the loss criterion for the SegmentationModel.)rLrs rcrz SegmentationModel.init_criterion7s !$''re)zyolo11n-seg.yamlrNTrDrs@rcrFrFs A(rerFc*eZdZdZdfd ZdZxZS) PoseModelac 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("yolo11n-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)au Initialize 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=r?N) r[r\ranyrr@rrr )r_rrrdata_kpt_shaperrs rcr zPoseModel.__init__Psz#t$!#&C ~ 4#74K@P;Q#Q KK:3{;K:LL\]k\lm n-C  SRB@rect|S)z0Initialize the loss criterion for the PoseModel.)rKrs rcrzPoseModel.init_criterionbs $re)zyolo11n-pose.yamlrNNNTrDrs@rcrJrJ<s&A$ rerJc@eZdZdZdfd ZdZedZdZxZ S)ClassificationModelat YOLO 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("yolo11n-cls.yaml", ch=3, nc=1000) >>> results = model.predict(image_tensor) cJt||j||||y)ae 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_yamlrAs rcr zClassificationModel.__init__s"  RW-rect|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) a] Set 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.rrr)r[r\rrrr@r ValueErrorrrrxr~rrrrr)r_rrrrr}s rcrTzClassificationModel._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)z Update a TorchVision classification model to class count 'n' if required. Args: model (torch.nn.Module): Model to update. nc (int): New number of classes. rxrnrrN)bias)rrrxnamed_childrenr[r linear out_featuresrrLinear in_featuressetattr SequentialrrindexConv2d out_channels in_channels kernel_sizerrX)rxrnamerr`typesr}s rcreshape_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.)rHrs rcrz"ClassificationModel.init_criterions #%%re)zyolo11n-cls.yamlrNT) rrrrr rTr;rgrrrs@rcrRrRgs+0 .08&rerRc:eZdZdZdfd ZdZddZddZxZS) RTDETRDetectionModelaw RTDETR (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)a7 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. r?Nr@rAs rcr zRTDETRDetectionModel.__init__rBrec6ddlm}||jdS)z;Initialize the loss criterion for the RTDETRDetectionModel.r)RTDETRDetectionLossT)ruse_vfl)ultralytics.models.utils.lossrmr)r_rms rcrz#RTDETRDetectionModel.init_criterionsE"dggt< << *a(@aHH Izz"~ '1!A$' /9^(s ;G G)z rtdetr-l.yamlrNTrFFNFN) rrrrr rr]r^rrs@rcrjrjs. A= , \!rerjcDeZdZdZdfd ZddZddZd dZd dZxZ S) WorldModelau YOLOv8 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)aP Initialize 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. rrPNr?)rrandn txt_feats clip_modelrr rAs rcr zWorldModel.__init__\s:Qb#6 SRB@recp|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_modelrnN) get_text_perrrxr)r_textrrs rc set_classeszWorldModel.set_classesjs2))$eN^)_I 2recddlm}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) aw 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. Returns: (torch.Tensor): Text positional embeddings. rbuild_text_modelrNz clip:ViT-B/32rtrrrsrn)ultralytics.nn.text_modelrrrxrrrrtokenizer* encode_textrrrrreshaper) r_rrrrrrx text_tokentokenrs rcrzWorldModel.get_text_pevs ?djj++-.55t\405E.vNDO#39I/bh9i^^D) DNDTDTUZD[\5U&&u-446\ \$' Na$7IaLUYYyVW=X   SY 0CDD]s&D c| |jn|j|j|j}t |t |k7s|j dj r |j|jddd}|j}ggg} } }| t|ndh}t|} |j D]} | jdk7rMt| jtr|| jn#| jD cgc]} | dk(r|n|| c} }|r|j| || t| t r | ||}nSV #tzz"~'<'<!((R << *a(@aHH) I*'9^s Jct|ds|j|_||j|d|d}|j||S)rrrr)r)rrrrdrs rcr]zWorldModel.losssOt[)!002DN =LLu{9KLLE~~eU++re)zyolov8s-world.yamlrNT)rTrr) rrrrr rrr^r]rrs@rcrrCs$0 A &E0+Z ,rerceZdZdZd fd Zed dZedZdZdZ dZ dZ d d Z dd Z xZS) YOLOEModela YOLOE 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) c,t|||||y)aI 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. r?Nr@rAs rcr zYOLOEModel.__init__rBrecddlm}t|jj j }t |dds|r|d||_|r |jn |d|}|j|}|j|D cgc]!} |j| j#} } t| dk(r| dntj| d} | jd t|| j d } |r| S|j"rJ|jd } t%| t&sJ| j)| Scc} w) 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. without_reprta (bool): Whether to return text embeddings cooperated with reprta module. Returns: (torch.Tensor): Text positional embeddings. rrrNzmobileclip:bltrtrrrsrn)rrrrxrrrrrr*rrrrrrrrr[r;get_tpe) r_rrrwithout_reprtarrrxrrrrs rcrzYOLOEModel.get_text_pes% ?djj++-.55t\405E./?ODO#39IJZci9j^^D) DNDTDTUZD[\5U&&u-446\ \$' Na$7IaLUYYyVW=X %%b#d)Y__R5HI  ==  zz"~$ ,,,||I&&]s&E c|||dS)z Get visual embeddings. Args: img (torch.Tensor): Input image tensor. visual (torch.Tensor): Visual features. Returns: (torch.Tensor): Visual positional embeddings. T)vpe return_vper)r_rvisuals rc get_visual_pezYOLOEModel.get_visual_pesCV55rec |jrJ|jd}t|tsJt |j j }|tjdd|jd|jdj|tjdtt||j|j D|jd_t|j |jD]C\}}t|tj$sJt|tj$sJ|d=|d=Et'||jd_t+||_y)z Set vocabulary for the prompt-free model. Args: vocab (nn.ModuleList): List of vocabulary items. names (List[str]): List of class names. rnrrrrc3ZK|]#\}\}}}t||d|d|dk7%yw)rnr)enabledN)r/)rr}r/pflocs rcrz'YOLOEModel.set_vocab..4s<, !>CS S"R&#b'16 : :, s)+N)rrxr[r;rrrremptyrarr ModuleList enumeratercv3cv2lrpcr_rrrr)r_vocabrrrloc_headcls_heads rc set_vocabzYOLOEModel.set_vocab#s6==  zz"~$ ,,,doo'(// U[[Atyy1499W3E F I I& QR!mm, %.s5$((DHH/M%N,   2#&dhh"9  Hhh 6 66h 6 66     J 2&u- rec|jrJ|jd}t|tsJ|jrJ|j |}|j ||t|jjj}|j|jj|tj}|jD]2}t|tj sJ|j#|d4|S)z Get fused vocabulary layer from the model. Args: names (list): List of class names. Returns: (nn.ModuleList): List of vocabulary modules. rn)rrxr[r;rrrrrrrrrrrrr_r|)r_rrtperrrs rc get_vocabzYOLOEModel.get_vocab@s==  zz"~$ ,,,==  u% $djj++-.55 $''**V$%  'Hh 6 66 LL" & ' rect|jddrJd|jdk(sJ||_t ||jd_t ||_y)z Set 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. rnrz^Prompt-free model does not support setting classes. Please try with Text/Visual prompt models.rN)rrxndimrrrrr)r_rrs rcrzYOLOEModel.set_classesZsa4::b>62 l 2!###J 2&u- rec *g}|"|jdk(sJ|j||"|jdk(sJ|j||s1|jt|dtjdddtj |dS)a Get class positional embeddings. Args: tpe (torch.Tensor, optional): Text positional embeddings. vpe (torch.Tensor, optional): Visual positional embeddings. Returns: (torch.Tensor): Class positional embeddings. rrrrrrrs)rr|rrrr)r_rrall_pes rc get_cls_pezYOLOEModel.get_cls_pejs ?88q= = MM#  ?88q= = MM#  MM'$ekk!R.EF GyyQ''rec ggg} } } |jd} | t|ndh}t|} |jD]4}|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}|||}n||}| j%|j&|j(vr|nd|r#t+||j,|j&||j&|vs| j%t.j0j2j5|dj7dj7d|j&| k(s t/j8t/j:| ddcS|Scc}w) a Perform 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 feature vectors/embeddings to return. vpe (torch.Tensor, optional): Visual positional embeddings. return_vpe (bool): If True, return visual positional embeddings. Returns: (torch.Tensor): Model's output tensor. rNrnrrorqrrrs)rrvrwrxryr[rzr{r;get_vperrrrrrrrrr|r}r~rOrrrrrrrr)r_r`rirjrrkrlrrrrrbrrrcls_pes rcr^zYOLOEModel.predicts&Bz2 GGAJ$)$5 % B4e* IAssby(c2AaccFYZY\Y\8]TUa2g1Q49O8]''1b1![)+.?aii3'?*?#}},,J3=@@! [\]^[_[e[e@f<<?a'188#]]1b"5FaLaD HH!##*Q 5%ayIsse|!!%(("5"5"I"I!V"T"\"\]_"`"h"hik"lm33'> << *a(@aHH1 I2/9^sI7c"t|ds9ddlm}|jdddu}|r||n|j |_|7|j |d|jdd|jdd}|j ||S) rrr) TVPDetectLossvisualsNrrrr)rultralytics.utils.lossrrrrrd)r_rrr visual_prompts rcr]zYOLOEModel.lossst[) <!IIi6dBM4A]40tGZGZG\DN =LLu599[$3OUZU^U^_hjnUoLpE~~eU++re)zyoloe-v8s.yamlrNT)rFF)FFNFNNFr)rrrrr rVrrrrrrr^r]rrs@rcrrsc6 A''B 6 6.:4. (.lq0d,rerc,eZdZdZdfd ZddZxZS) YOLOESegModela0 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)aV Initialize 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. r?Nr@rAs rcr zYOLOESegModel.__init__rBrec"t|ds9ddlm}|jdddu}|r||n|j |_|7|j |d|jdd|jdd}|j ||S) rrr)TVPSegmentLossrNrrr)rrrrrrrd)r_rrrrs rcr]zYOLOESegModel.lossst[) =!IIi6dBM5B^D1H[H[H]DN =LLu599[$3OUZU^U^_hjnUoLpE~~eU++re)zyoloe-v8s-seg.yamlrNTr)rrrrr r]rrs@rcrrs A,rerc*eZdZdZfdZddZxZS)Ensemblea  Ensemble 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.Nr@)r_rs rcr zEnsemble.__init__s rec v|Dcgc]}|||||d}}tj|d}|dfScc}w)a Generate the YOLO network's final layer. 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: y (torch.Tensor): Concatenated predictions from all models. train_out (None): Always None for ensemble inference. rrN)rr)r_r`rkrirjmodulers rcrdzEnsemble.forward sIFJ J6VAw 3A 6 J J IIaO$w Ks6)FFF)rrrrr rdrrs@rcrrs$rerc #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)a Context 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 Note: 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.rr)sys importlibrrrsplitr^rr) r attributesrroldnew old_moduleold_attr new_modulenew_attrs rctemporary_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.Nrr_rarbs rcr zSafeClass.__init__X recy)z/Run SafeClass instance, ignoring all arguments.Nrrs rc__call__zSafeClass.__call__\rreN)rrrrr rrrercrrUsK  rerc"eZdZdZfdZxZS) SafeUnpicklerz>Custom Unpickler that replaces unknown classes with SafeClass.c<d}||vrt|||StS)z Attempt 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)r_rre safe_modulesrs rcrzSafeUnpickler.find_classds,  \ !7%fd3 3 re)rrrrrrrs@rcrrasHrerc rddlm}t|d||} tddddd d d d  5|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|dtdj d|t#j$|d|jd|jdt'|jt|d}Yd}~d}~wwxYw)"a Attempt 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): The file path of the PyTorch model. safe_only (bool): If True, replace unknown classes with SafeClass during loading. Returns: ckpt (dict): The loaded model checkpoint. file (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.v10DetectLoss)rr safe_picklec4t|jSr)rr)file_objs rcz!torch_safe_load..sM(4K4P4P4Rrerb) 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=yolo11n.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=yolo11n.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.rx)ultralytics.utils.downloadsrrErrf ModuleTyper UnpicklerropenrNModuleNotFoundErrorre TypeErrorrC __import__ __version__r@rrDr[r\rx)weight safe_onlyrrrryckptr9s rctorch_safe_loadr~s$CfU+ !& )D/4 *='@); 9L>c8^   <#..}= (5 %#R  $%D%a{CDDD"$U;) <` dD !!` a $ :ODD# < <, 4 66X #F8,mn VV} $%#F8+ST^_fTgTsTsStuCD   h+AFF84//0vvh7e f 166"$U314sGC(7C)C7C C(C CC%!C(( F61B:F11F6c  t t|tr|n|gD]}t|\}}d|vr it|dnd}|j dxs|dj |j}||_||_ t|dt||_ t|dstjdg|_ j#|r*t|dr|j%j'n|j' j)D]O}t|d r||_t|tj,j.s.s"8!x{~~%8s&)zModels differ in class counts )"rr[rrr>rrrrapt_pathrguess_model_taskrrrrrr|rrrrrUpsamplerrr@rr^rzargmaxrwallr) rrrrrrrarxrrrs @rcattempt_load_weightsr%s#zH"7D1Wy b!!$a=IT=Q9"9d<&89W[%1DM55f=CCE  UF,`[ss .!I' I,ct|\}}it|jdi}|jdxs|dj|j }|j Dcic]\}}|t vs||c}}|_||_t|dt||_ t|dstjdg|_|r*t|dr|j!j#n|j#}|j%D]O} t| dr|| _t)| tj*j,srrrrr?rar rr!rrrrrrrrrr[rr"r) rrrrrrarxrrrs rcattempt_load_one_weightr'sA#6*LD& ? ?488L"#= ?D XXe_ -W 1 1& 9 ? ? AE$(::<I41a18H3H!Q$IEJEM(8(?@EJ 5( #||TF+ #'GE6,BEJJL    E]]_, 1i AI 588,, -gaAY6Z'+A $ , $;!Js 1E;E;cNddl}d}td}fddD\}}}fddD\} } } |rQjd } | s5t|j d} t j d | d || \} } }|r9t|t_ |r#t jtd d ||r)t jddddddddddddddgggd}}} thttttt t"t$t&t(t*t,t.t0t2t4t6t8t:t<t>t@tBtDtFtHtJtLjNjPtRtTtVtXtZt\t^}tt0t2t4t6t8tDtFtHtJtTtVt(t\t*t^h}taddzD]\\}}dvrtctLjNddn2d vr"tcted!jfd"dn titaD]e\}}tk|tlstojptr5|tuvr tu|n|jw||<dddg|d#kDrtyt{|| zd#n|x}}|vr|d}}||k7rt}t||| zd$}tDurft}td#|d%z| zd$d#<td%d#kDr+tyt{td%|d%zd&z| zd#nd%d%<||gd#d|vrjd%|d#}t8ur d'} d(vrdd<t^urd'} d)vrjd*t\urd'}ntur |gnttthvr8|dd#}}}|||gd%dturjd+|d#}nturdrd#nd#d+z}n~tLjNjur|gnZturtfd,|D}n<tttttttttth vr{j|Dcgc]}| c}tusturt}td%|| zd$d%<tttttthvr|_Tntur$jd#|Dcgc]}| c}n[turd}|}||gd#dn?tur |d}n.ttthvrd}|}gd#dn|}|d#kDr/tMjNjfd-t|Dn}tmd$d.jd/d}td0|jD|_^||c|__|_`|_a|rDt jdtm|d|d|jd1d|dtmd|jfd2tk|tr|gn|D| j|dk(rgj|tMjNj| t|fS#1swYxYwcc}wcc}w)3a@ Parse 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: model (torch.nn.Sequential): PyTorch model. save (list): Sorted list of output layers. rNTinfc3@K|]}j|ywrrrr`ds rcrzparse_model..9sHAquuQxHs)r activationscalesc3BK|]}j|dyw)g?Nr+r,s rcrzparse_model..:shquuQ}hs)depth_multiplewidth_multiplerLr-z'no model scale passed. Assuming scale='z'.z activation:rrr z>3fromz>20nrz>10rrz<45 argumentsz<30rnrrznn.rztorchvision.ops. torchvisionrrrr Fmlxlx)Tg333333?r)c3(K|] }| ywrr)rr`rs rcrzparse_model..s&qRU&c3(K|] } ywrr)rrrars rcrzparse_model..s">1d8">r<r z __main__.c3<K|]}|jywr)numelr3s rcrzparse_model..s7!AGGI7src34K|]}|dk7s |zyw)rnNr)rr`r}s rcrzparse_model..sQabAEQs  )castrrrkeysr@rrr" default_actrrBrvr r$r*rr)rrrr r&r(rrrrrr3r rrrrr r rrrConvTranspose2dr'rr1rr7rrrrropsglobalsr[str contextlibsuppressrVlocals literal_evalrwroundrMrrzinsertextendrr,r+r5 BatchNorm2dr!rr%r:r;r8r<r0r r-r=r|legacyr6rrr9r.r_rreplacerrr}ryrsorted)r-rrrArP max_channelsractr/depthwidthrLr-layersr~r base_modulesrepeat_modulesryr4ran_rcmr`m_rrar}rs`` @@@rcrr's#FHS>R]^aQbcd B2r"v"DF# # #  #   #  #  #  #  #  #  #  #  #  #  #  # !# " ## $ %# & '# ( )# * +# , -# . /# 0 1# 2 3# 4 5# 6 HH $ $7# 8 9# : ;# < =# > ?# @ A# B C# D E# %LL                N&(* & (ABR?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 ) [+w dCQacl m   KK*1A* +G|qL0(T!Wl)Ce)KQOQV['<sKK! -  KK1-aBqE- . (]aBAB&T!"X&D &[AbEB )[%01 1aBABT!"X;DABCDq5UXX ">U1X"> ?aQUh F1RL b 17r}}77AbdBG  KK1R&Q RGBEE%=1S'#d)TWY Z Q:a+=QC1QQ b 6B " eRf 88   ' 55STTT+ .s*.^ ^ ^" ^ ct|}|jddDvretjdd|j}t j d|jd|d|j ||jz}tjdd t|}t|d xs t|}tj|}t||d <t||d <|S)z Load a YOLOv8 model from a YAML file. Args: path (str | Path): Path to the YAML file. Returns: (dict): Model dictionary. c3:K|]}dD] }d||dyw))r8yolov6Nrr,s rcrz"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)hardr- yaml_file) rstemresubr@r with_namerrGrFrArguess_model_scale)pathnew_stem unified_pathrer-s rcrrs :D yyFgFF662L$))LQRVR[R[Q\\`ai`jjklm~~h456617CIFLfcr/classify classifierrvdetectsegmentposeobbN)lower)rrs rccfg2taskz"guess_model_task..cfg2task sV KOB  % % ' 7 7 q= > ; : reN)z model.argszmodel.model.argszmodel.model.model.argsr)z model.yamlzmodel.model.yamlzmodel.model.model.yamlryrvrzr{rxz-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[r\rHrI ExceptionrrModulerrr8r<r r0r r%r:r;r=rGrrfpartsr@r)rxr}r`rs rcr!r!s %   + #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; rP)F)NTFr)rHpicklergrfrrpathlibrrtorch.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=ultralytics.utilsr>r?r@rArBrCultralytics.utils.checksrDrErFrrGrHrIrJrKrLultralytics.utils.opsrMultralytics.utils.patchesrNultralytics.utils.plottingrOultralytics.utils.torch_utilsrPrQrRrSrTrUrVrWrrYrr=rFrJrRrjrrrrrcontextmanagerrrr rrr%r'rrrjr!rrercrs  8999999999999999ta`QQ10<   wZwZtZaYZaz~D((D( ( V]&)]&@y>yxE,E,Pw,w,t-,J 1-,`)uxx"")^ -%-%`   F$$:Od.b#Lp6f 0  Dre