
    /j                        d dl mZ d dlmZ d dlmZ d dlZd dlmZ d dl	m
Z
mZmZ ddlmZ  G d d	e          Z G d
 de          ZdS )    )annotations)Path)AnyN)	IS_JETSONLOGGER	is_jetson   )BaseBackendc                  @     e Zd ZdZ	 	 	 dd fdZddZ	 dd dZ xZS )!PyTorchBackendzPyTorch inference backend for native model execution.

    Loads and runs inference with native PyTorch models (.pt checkpoint files) or pre-loaded nn.Module
    instances. Supports model layer fusion, FP16 precision, and NVIDIA Jetson compatibility.
    FTweightstr | Path | nn.Moduledevicetorch.devicefp16boolfuseverbosec                j    || _         || _        t                                          |||           dS )a  Initialize the PyTorch backend.

        Args:
            weight (str | Path | nn.Module): Path to the .pt model file or a pre-loaded nn.Module instance.
            device (torch.device): Device to run inference on (e.g., 'cpu', 'cuda:0').
            fp16 (bool): Whether to use FP16 half-precision inference.
            fuse (bool): Whether to fuse Conv2D + BatchNorm layers for optimization.
            verbose (bool): Whether to print verbose model loading messages.
        N)r   r   super__init__)selfr   r   r   r   r   	__class__s         d/home/longshao/multi-rider-rag/.venv/lib/python3.11/site-packages/ultralytics/nn/backends/pytorch.pyr   zPyTorchBackend.__init__   s5    " 	.....    str | torch.nn.ModulereturnNonec                   ddl m} t          |t          j        j                  r~| j        r\t          |d          rLt          r*t          d          r|
                    | j                  }|                    | j                  }|
                    | j                  }n ||| j        | j                  \  }}t          |d          r|j        | _        t          |d	          r4t          t          |j                                                  d
          nd
| _        t          |d          r|j        j        nt'          |di           | _        t          |d          r|j                            dd          nd| _        | j        r|                                n|                                 |                                D ]	}d|_        
|| _        t'          |dd          | _        dS )zLoad a PyTorch model from a checkpoint file or nn.Module instance.

        Args:
            weight (str | torch.nn.Module): Path to the .pt checkpoint or a pre-loaded module.
        r   )load_checkpointr      )jetpack)r   )r   r   	kpt_shapestride    modulenamesyamlchannels   Fend2endN)ultralytics.nn.tasksr    
isinstancetorchnnModuler   hasattrr   r   tor   r   r#   maxintr$   r&   r'   getattrr(   getr)   r   halffloat
parametersrequires_gradmodelr+   )r   r   r    r;   _ps         r   
load_modelzPyTorchBackend.load_model,   s    	988888feho.. 	Sy ;WVV44 ; 41!5!5!5 4#YYt{33FT\::IIdk**EE&vdk	RRRHE1 5+&& 	-"_DN:A%:R:RZc#el..00112666XZ+25(+C+CdU\''QVX_acIdId
9@9O9OV
z1555UV	4

u{{}}!!## 	$ 	$A#AOO
ui77r   Nimtorch.Tensoraugment	visualizeembedlist | Nonekwargsr   !torch.Tensor | list[torch.Tensor]c                &     | j         |f|||d|S )ay  Run native PyTorch inference with support for augmentation, visualization, and embeddings.

        Args:
            im (torch.Tensor): Input image tensor in BCHW format, normalized to [0, 1].
            augment (bool): Whether to apply test-time augmentation.
            visualize (bool): Whether to visualize intermediate feature maps.
            embed (list | None): List of layer indices to extract embeddings from, or None.
            **kwargs (Any): Additional keyword arguments passed to the model forward method.

        Returns:
            (torch.Tensor | list[torch.Tensor]): Model predictions as tensor(s).
        )rA   rB   rC   r;   )r   r?   rA   rB   rC   rE   s         r   forwardzPyTorchBackend.forwardK   s(     tz"Zg%ZZSYZZZr   )FTT)
r   r   r   r   r   r   r   r   r   r   )r   r   r   r   )FFN)r?   r@   rA   r   rB   r   rC   rD   rE   r   r   rF   __name__
__module____qualname____doc__r   r>   rI   __classcell__r   s   @r   r   r      s          / / / / / / /*8 8 8 8@ fj[ [ [ [ [ [ [ [ [r   r   c                  6     e Zd ZdZdd fd	ZddZddZ xZS )TorchScriptBackenda  PyTorch TorchScript inference backend for serialized model execution.

    Loads and runs inference with TorchScript models (.torchscript files) created via torch.jit.trace or
    torch.jit.script. Supports FP16 precision and embedded metadata extraction.
    Fr   
str | Pathr   r   r   r   c                N    t                                          |||           dS )a  Initialize the TorchScript backend.

        Args:
            weight (str | Path): Path to the .torchscript model file.
            device (torch.device): Device to run inference on (e.g., 'cpu', 'cuda:0').
            fp16 (bool): Whether to use FP16 half-precision inference.
        N)r   r   )r   r   r   r   r   s       r   r   zTorchScriptBackend.__init__d   s'     	.....r   strr   r   c                   ddl }ddl}t          j        d| d           ddi}t          j                            ||| j                  | _        | j	        r| j        
                                n| j                                         |d         r3|                     |                    |d         d 	                     dS dS )
zLoad a TorchScript model from a .torchscript file with optional embedded metadata.

        Args:
            weight (str): Path to the .torchscript model file.
        r   NzLoading z for TorchScript inference...z
config.txt )_extra_filesmap_locationc                D    t          |                                           S )N)dictitems)xs    r   <lambda>z/TorchScriptBackend.load_model.<locals>.<lambda>~   s    \`abahahajaj\k\k r   )object_hook)jsontorchvisionr   infor.   jitloadr   r;   r   r7   r8   apply_metadataloads)r   r   r`   ra   extra_filess        r   r>   zTorchScriptBackend.load_modeln   s     	DvDDDEEE#R(Y^^FSWS^^__
!Y>
DJ,<,<,>,>|$ 	n

;|+DRkRk
 l lmmmmm	n 	nr   r?   r@   rF   c                ,    |                      |          S )zRun TorchScript inference.

        Args:
            im (torch.Tensor): Input image tensor in BCHW format, normalized to [0, 1].

        Returns:
            (torch.Tensor | list[torch.Tensor]): Model predictions as tensor(s).
        rH   )r   r?   s     r   rI   zTorchScriptBackend.forward   s     zz"~~r   )F)r   rS   r   r   r   r   )r   rU   r   r   )r?   r@   r   rF   rJ   rP   s   @r   rR   rR   ]   sx         / / / / / / /n n n n$	 	 	 	 	 	 	 	r   rR   )
__future__r   pathlibr   typingr   r.   torch.nnr/   ultralytics.utilsr   r   r   baser
   r   rR    r   r   <module>rp      s    # " " " " "                    : : : : : : : : : :      J[ J[ J[ J[ J[[ J[ J[ J[Z, , , , , , , , , ,r   