j;ddlmZddlmZddlmZddlZddlZddl m Z ddl m Z ddl mZddlmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZdd Z dddZ!Gdde j"Z#dS)) annotations)Path)AnyN) check_suffix)is_url)AxeleraBackend CoreMLBackend DeepXBackendExecuTorchBackend MNNBackend NCNNBackend ONNXBackendONNXIMXBackendOpenVINOBackend PaddleBackendPyTorchBackend 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 ]/var/www/html/Carbon-Document/venv/lib/python3.11/site-packages/ultralytics/nn/autobackend.py z%check_class_names..3s*:::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|]\}}||Srr)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)<).Ss / / /qA{q{{ / / /r')r:r+ultralytics.utils.checksrAr; Exceptionrange)r>r+rAs r%default_class_namesrKBs   . . . . . . ; ; ; ; ; ;99ZZ--..w7 7    D  / /E#JJ / / //s/4 AAcPeZdZdZidedededededede d e d e d e d e d e de de dededeeeedZejdejddddddfd?fd# Zd@fd( Z dAdBd1ZdCd4ZdDdEd9ZedFdGd<ZdHfd= ZdHfd> 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/ | 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, classify, pose). 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) executorchaxeleradeepxz 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. rN>rNrPrSr^rRrOrb>rNrPrSrYrO)rerhtfjsz7Ultralytics 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.rirj>rVrQrWrXrUformat>rVr]rTrWrXrUN)super__init__r/nnModule _model_typetorchrecuda is_availabletypeNotImplementedError _BACKEND_MAPultralytics.engine.exporterrn TypeErrorbackendnhwcrprrKr=) selfrcrerQr>rhrirjrpbackend_kwargsrn __class__s r%rrzAutoBackend.__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__hasattrr~getattrrq __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. rrrN)rrrrGsegmentci|]}|d| SrCrrEs r%r&z'AutoBackend.forward..s @@@a@@@r'c:g|]}|Sr) from_numpy)r"xrs r% z'AutoBackend.forward..s&=\=\=\UVdooa>P>P=\=\=\r')rpermuter~rhdtypervfloat16halfrpforwardr/r0tupler4rtaskshaperJr) 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`. )r/npndarrayrvtensortore)rrs r%rzAutoBackend.from_numpys93=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>rVrNrPrSr^rUrOrbr^)rrerOrrT)reNr) ultralytics.utils.nmsrrpreryrvemptyrhrfloatrJrrand)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 krd }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" rrmSuffixcg|]}|vSrr)r"srs r%rz+AutoBackend._model_type..Ps'''qd'''r'z.mlmodel c32K|]\}}| |VdSNr)r"rFftypess r% z*AutoBackend._model_type..Ss3YYTQPUVWPXYqYYYYYYr'ArgumentNr(rNrPrQ)urlsplit>grpchttpr^)r|rnrr/r!rrrendswithnextr2any urllib.parserrgnetlocpathscheme) rrQrnsfrprurlrrs @@r%ruzAutoBackend._model_type;s ?>>>>> ^  h 'ayy As!3!3 B   Aww|''''B''' aDMM*--- aaL YYYYY~~/?/? /K%L%LYYY[_`` S==FF v  # FFU " - - - - - -(1++CCJ "DNN "szEU7U7U! r'ct|jdr8t|jjdr|jjt S)z6Set the backend model to evaluation mode if supported.rceval)rr~rcrrq)rrs r%rzAutoBackend.eval`sV 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. rc) rq_applyrr~r/rcrsrtr parametersre)rfnrs r%rzAutoBackend._applyfsww~~b!! 4< ) ) Oj9KRY.W.W O L  % %b ) ) )"&t|'9'D'D'F'F"G"G"NDL  r')rcrdrerfrQrgr>r?rhrgrirgrjrg)rr!rr)FFN) rrrrgrrgrrrrrr)rrrr)r)rrrr)rF)rr!rQrgrr!)rrM)"__name__ __module__ __qualname____doc__rrrrrr rrr rrrrr r r r{rvno_gradrerrrrrr staticmethodrurr __classcell__)rs@r%rMrMVsP11f n)   {  O  /  - (  # $ - z   ~  !" -#$(!)L.U]__(4+u|E22"&?C?C?C?C?C?C_?CB)))))),! &&&&&&&&&&P S S S S22222$""""\"H r'rM)rrrrr)r>r?rr)$ __future__rpathlibrtypingrnumpyrrvtorch.nnrsrHrultralytics.utils.downloadsrbackendsr r r r r rrrrrrrrrrrr=rKrtrMrr'r%rs#""""" 111111......(>00000(bbbbb")bbbbbr'