v-j<ddlmZddlmZddlmZddlZddlZddl m Z ddl m Z ddl mZddlmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZm Z dd Z!dddZ"Gdde j#Z$dS)) annotations)Path)AnyN) check_suffix)is_url)AxeleraBackend CoreMLBackend DeepXBackendExecuTorchBackend MNNBackend NCNNBackend ONNXBackendONNXIMXBackendOpenVINOBackend PaddleBackendPyTorchBackend QNNBackend RKNNBackendTensorFlowBackendTensorRTBackendTorchScriptBackend TritonBackendnames list | dictreturndict[int, str]c t|trtt|}t|tr*d|D}t |}t ||kr\t|d|dz dt|dt |dt|dtra|d drFdd l m }m}||d z d fd |D}|S) a8Check class names and convert to dict format if needed. Args: names (list | dict): Class names as list or dict format. Returns: (dict): Class names in dict format with integer keys and string values. Raises: KeyError: If class indices are invalid for the dataset size. cNi|]"\}}t|t|#S)intstr).0kvs Z/var/www/html/banglarbhumi/venv/lib/python3.11/site-packages/ultralytics/nn/autobackend.py z%check_class_names..4s*:::DAqQQ:::z(-class dataset requires class indices 0-rz%, but you have invalid class indices -z defined in your dataset YAML.rn0)ROOTYAMLzcfg/datasets/ImageNet.yamlmapc(i|]\}}||Sr r )r#r$r% names_maps r&r'z%check_class_names..?s#???AQ ! ???r() isinstancelistdict enumerateitemslenmaxkeysKeyErrorminr" startswithultralytics.utilsr+r,load)rnr+r,r/s @r&check_class_namesr>$s%'Yu%%&&% @::EKKMM::: JJ uzz||   ! !YYa!eYYuzz||$$YY'*5::<<'8'8YYY  eAh $ $ @q)<).Ts / / /qA{q{{ / / /r()r;r,ultralytics.utils.checksrBr< Exceptionrange)r?r,rBs r&default_class_namesrLCs   . . . . . . ; ; ; ; ; ;99ZZ--..w7 7    D  / /E#JJ / / //s/4 AAcReZdZdZidedededededede d e d e d e d e d e de de dededeeeeedZejdejddddddfd?fd# Zd@fd( Z dAdBd1ZdCd4ZdDdEd9ZedFdGd<ZdHfd= Z dHfd> Z!xZ"S)I AutoBackenda Handle dynamic backend selection for running inference using Ultralytics YOLO models. The AutoBackend class is designed to provide an abstraction layer for various inference engines. It supports a wide range of formats, each with specific naming conventions as outlined below: Supported Formats and Naming Conventions: | Format | File Suffix | | --------------------- | ----------------- | | PyTorch | *.pt | | TorchScript | *.torchscript | | ONNX Runtime | *.onnx | | ONNX OpenCV DNN | *.onnx (dnn=True) | | OpenVINO | *openvino_model/ | | CoreML | *.mlpackage | | TensorRT | *.engine | | TensorFlow SavedModel | *_saved_model/ | | TensorFlow GraphDef | *.pb | | TensorFlow Lite | *.tflite | | TensorFlow Edge TPU | *_edgetpu.tflite | | PaddlePaddle | *_paddle_model/ | | MNN | *.mnn | | NCNN | *_ncnn_model/ | | IMX | *_imx_model/ | | RKNN | *_rknn_model/ | | Triton Inference | triton://model | | ExecuTorch | *.pte | | Axelera AI | *_axelera_model/ | | DeepX | *_deepx_model/ | | Qualcomm QNN | *_qnn_model/ | Attributes: backend (BaseBackend): The loaded inference backend instance. format (str): The model format (e.g., 'pt', 'onnx', 'engine'). model: The underlying model (nn.Module for PyTorch backends, backend instance otherwise). device (torch.device): The device (CPU or GPU) on which the model is loaded. task (str): The type of task the model performs (detect, segment, semantic, classify, pose, obb). names (dict): A dictionary of class names that the model can detect. stride (int): The model stride, typically 32 for YOLO models. fp16 (bool): Whether the model uses half-precision (FP16) inference. nhwc (bool): Whether the model expects NHWC input format instead of NCHW. Methods: forward: Run inference on an input image. from_numpy: Convert NumPy arrays to tensors on the model device. warmup: Warm up the model with a dummy input. _model_type: Determine the model type from file path. Examples: >>> model = AutoBackend(model="yolo26n.pt", device="cuda") >>> results = model(img) pt torchscriptonnxdnnopenvinoenginecoreml saved_modelpbtfliteedgetpupaddlemnnncnnimxrknntriton) executorchaxeleradeepxqnnz yolo26n.ptcpuFNTmodelstr | torch.nn.Moduledevice torch.deviceboolr?r@fp16fuseverbosec tt|tjrdn|||}||dvz}t|t jrAt j r#|j dkr|dvrt jd}||d} |dkrtd||j vr*dd l m} td |d | d d |dkr || d<|| d<n |dvr|| d<|j ||fi| |_|dv|_||_|jjst)||j_t+|jj|j_dS)afInitialize the AutoBackend for inference. Args: model (str | torch.nn.Module): Path to the model weights file or a module instance. device (torch.device): Device to run the model on. dnn (bool): Use OpenCV DNN module for ONNX inference. data (str | Path, optional): Path to the additional data.yaml file containing class names. fp16 (bool): Enable half-precision inference. Supported only on specific backends. fuse (bool): Fuse Conv2D + BatchNorm layers for optimization. verbose (bool): Enable verbose logging. rO>rOrQrTr_rSrPrd>rOrQrTrZrP)rgrjtfjsz7Ultralytics TF.js inference is not currently supported.rexport_formatszmodel='z9' is not a supported model format. Ultralytics supports: Formatz9 See https://docs.ultralytics.com/modes/predict for help.rkrl>rWrRrXrYrVformat>rWr^rUrXrYrVN)super__init__r0nnModule _model_typetorchrgcuda is_availabletypeNotImplementedError _BACKEND_MAPultralytics.engine.exporterrp TypeErrorbackendnhwcrrrrLr>) selfrergrRr?rjrkrlrrbackend_kwargsrp __class__s r&rtzAutoBackend.__init__s, #E2955W4;K;KESV;W;W WWW vu| , , ) '')) ) u$$OOO\%((F%+D99 V  %&_`` ` * * * B B B B B BL%LL)7)9)9()CLLL  T>>%)N6 "(/N9 % % H H H'-N8 $0t(0II.II ZZ  |! ;!4T!:!:DL .t|/ABB r(namer"rrcd|jvr*t|j|rt|j|St |S)awDelegate attribute access to the backend. This allows AutoBackend to transparently expose backend attributes without explicit copying. Args: name: Attribute name to look up. Returns: The attribute value from the backend. Raises: AttributeError: If the attribute is not found in backend. r)__dict__hasattrrgetattrrs __getattr__)rrrs r&rzAutoBackend.__getattr__sM  % %'$,*E*E %4<.. .ww""4(((r(im torch.Tensoraugment visualizeembed list | Nonekwargs!torch.Tensor | list[torch.Tensor]c jr|dddd}jjr)|jt jkr|}i}jdkr|||d|}jj |fi|}t|ttfrtjdkrfjdkst|dkrH|djd|djdz d z }d t#|D_t|dkr|dn fd |DS|S) a:Run inference on an AutoBackend model. Args: im (torch.Tensor): The image tensor to perform inference on. augment (bool): Whether to perform data augmentation during inference. visualize (bool): Whether to visualize the output predictions. embed (list, optional): A list of layer indices to return embeddings from. **kwargs (Any): Additional keyword arguments for model configuration. Returns: (torch.Tensor | list[torch.Tensor]): The raw output tensor(s) from the model. rrrO)rrrrHsegmentci|]}|d| SrDr rFs r&r'z'AutoBackend.forward..s @@@a@@@r(c:g|]}|Sr ) from_numpy)r#xrs r& z'AutoBackend.forward..s&=\=\=\UVdooa>P>P=\=\=\r()rpermuterrjdtyperxfloat16halfrrforwardr0r1tupler5rtaskshaperKr) rrrrrrforward_kwargsyncs ` r&rzAutoBackend.forwardsf( 9 (Aq!Q''B <  U]!:!:B ;$  )0ySXcc\bcN DL  6 6~ 6 6 a$ ' ' &4:#%%49 +A+ASVVq[[qTZ]QqTZ]2Q6@@eBii@@@ ,/FFaKK4??1Q4(((=\=\=\=\Z[=\=\=\ \??1%% %r(rnp.ndarray | torch.Tensorct|tjr,tj||jn|S)zConvert a NumPy array to a torch tensor on the model device. Args: x (np.ndarray | torch.Tensor): Input array or tensor. Returns: (torch.Tensor): Tensor on `self.device`. )r0npndarrayrxtensortorg)rrs r&rzAutoBackend.from_numpy!s93=Q 2K2KRu|A!!$+...QRRr(rrrimgsztuple[int, int, int, int]Nonecddlm}|jdvr|jjdks |jdkrt j||jr t jn t j |jd}t|jdkrdnd D]_}| |t j d d d |j }|d d d dfxx|dzcc<||\d Sd Sd S)zWarm up the model by running forward pass(es) with a dummy input. Args: imgsz (tuple[int, int, int, int]): Dummy input shape in (batch, channels, height, width) format. r)non_max_suppression>rWrOrQrTr_rVrPrdr_)rrgrPrrT)rgNr) ultralytics.utils.nmsrrrrgr{rxemptyrjrfloatrKrrand)rrrr_ warmup_boxess r&warmupzAutoBackend.warmup,s >===== ;` ` ` K  % %)@)@e+S5:: \`\ghhhB } < <11!DD 2 2 R   $z!RDKHHH QQQU###uRy0#####L1111 a `)@)@ 2 2r(path/to/model.ptpcddlm}|d}t|s%t|tst ||t |jfd|Ddxxdzcc<dxxd zcc<tfd t|d Dd }d rd }ng|dkrd}n^|dkr|rd}nStsDddl m }||}t|jrt|jr |jdvrd}|S)aTake a path to a model file and return the model format string. Args: p (str): Path to the model file. dnn (bool): Whether to use OpenCV DNN module for ONNX inference. Returns: (str): Model format string (e.g., 'pt', 'onnx', 'engine', 'triton'). Examples: >>> fmt = AutoBackend._model_type("path/to/model.onnx") >>> assert fmt == "onnx" rroSuffixcg|]}|vSr r )r#srs r&rz+AutoBackend._model_type..Ss'''qd'''r(z.mlmodel c32K|]\}}| |VdSNr )r#rGftypess r& z*AutoBackend._model_type..Vs3YYTQPUVWPXYqYYYYYYr(ArgumentNz _qnn.onnxrcr)rOrQrR)urlsplit>grpchttpr_)r~rprr0r"rrrendswithnextr3any urllib.parserrinetlocpathscheme) rrRrpsfrrrurlrrs @@r&rwzAutoBackend._model_type>s ?>>>>> ^  h 'ayy As!3!3 B   Aww|''''B''' aDMM*--- aaL YYYYY~~/?/? /K%L%LYYY[_`` == % % "FF s]]FF v  # FFU " - - - - - -(1++CCJ "DNN "szEU7U7U! r(ct|jdr8t|jjdr|jjt S)z6Set the backend model to evaluation mode if supported.reeval)rrrerrs)rrs r&rzAutoBackend.evalesV 4< ) ) &gdl6H&.Q.Q & L  # # % % %ww||~~r(cnt|}t|jdr}t |jjt jrY|jj|t|jj j |j_ |S)aApply a function to backend.model parameters, buffers, and tensors. This method extends the functionality of the parent class's _apply method by additionally resetting the predictor and updating the device in the model's overrides. It's typically used for operations like moving the model to a different device or changing its precision. Args: fn (Callable): A function to be applied to the model's tensors. This is typically a method like to(), cpu(), cuda(), half(), or float(). Returns: (AutoBackend): The model instance with the function applied and updated attributes. re) rs_applyrrr0rerurvr parametersrg)rfnrs r&rzAutoBackend._applyksww~~b!! 4< ) ) Oj9KRY.W.W O L  % %b ) ) )"&t|'9'D'D'F'F"G"G"NDL  r()rerfrgrhrRrir?r@rjrirkrirlri)rr"rr)FFN) rrrrirrirrrrrr)rrrr)r)rrrr)rF)rr"rRrirr")rrN)#__name__ __module__ __qualname____doc__rrrrrr rrr rrrrr r r rr}rxno_gradrgrtrrrr staticmethodrwrr __classcell__)rs@r&rNrNWsS22h n)   {  O  /  - (  # $ - z   ~  !" -#$(!+L0U]__(4+u|E22"&?C?C?C?C?C?C_?CB)))))),! &&&&&&&&&&P S S S S22222$$$$$\$L r(rN)rrrrr)r?r@rr)% __future__rpathlibrtypingrnumpyrrxtorch.nnrurIrultralytics.utils.downloadsrbackendsr r r r r rrrrrrrrrrrrr>rLrvrNr r(r&rs#""""" 111111......*>00000(fffff")fffffr(