o
    h1                     @   s   d dl Zd dlZd dlmZmZ ddlmZ G dd deZG dd deZ	G d	d
 d
e	Z
G dd de	ZG dd deZG dd deZdS )    N)DatasetIterableDataset   )ModelOutputc                   @   s$   e Zd Zdd Zdd Zdd ZdS )PipelineDatasetc                 C      || _ || _|| _d S Ndatasetprocessparams)selfr
   r   r    r   s/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/transformers/pipelines/pt_utils.py__init__	      
zPipelineDataset.__init__c                 C   
   t | jS r   lenr
   r   r   r   r   __len__      
zPipelineDataset.__len__c                 C   s"   | j | }| j|fi | j}|S r   r	   )r   iitem	processedr   r   r   __getitem__   s   
zPipelineDataset.__getitem__N)__name__
__module____qualname__r   r   r   r   r   r   r   r      s    r   c                   @   s6   e Zd ZdddZdd Zdd Zdd	 Zd
d ZdS )PipelineIteratorNc                 C   s4   || _ || _|| _|dkrd}|| _d| _d| _dS )a  
        Roughly equivalent to

        ```
        for item in loader:
            yield infer(item, **params)
        ```

                Arguments:
                    loader (`torch.utils.data.DataLoader` or `Iterable`):
                        The iterator that will be used to apply `infer` on.
                    infer (any function):
                        The function to apply of each element of `loader`.
                    params (`dict`):
                        The parameters passed to `infer` along with every item
                    loader_batch_size (`int`, *optional*):
                        If specified, the items of `loader` are supposed to come as batch, and are loader_batched here
                        making it roughly behave as


        ```
        for items in loader:
            for i in loader_batch_size:
                item = items[i]
                yield infer(item, **params)
        ```   N)loaderinferr   loader_batch_size_loader_batch_index_loader_batch_datar   r!   r"   r   r#   r   r   r   r      s   
zPipelineIterator.__init__c                 C   r   r   )r   r!   r   r   r   r   r   ?   r   zPipelineIterator.__len__c                 C      t | j| _| S r   iterr!   iteratorr   r   r   r   __iter__B      zPipelineIterator.__iter__c                    s  t  jtjr j j d}ni } j D ]\}}t |trQ| }t |d tjr;t	 fdd|D ||< nt |d t
jrPt	 fdd|D ||< q|dv rt |t	rt |d tjrpt	 fdd|D ||< nt |d t
jrt	 fdd|D ||< q|du rd||< qt | j tjr| j d||< qt | j t
jrt
| j d||< q| j ||< q j|}  jd	7  _|S )
ze
        Return item located at `loader_batch_index` within the current `loader_batch_data`.
        r   c                 3        | ]}| j  d V  qdS r   Nr$   	unsqueeze.0elr   r   r   	<genexpr>U       z5PipelineIterator.loader_batch_item.<locals>.<genexpr>c                 3   "    | ]}t | j d V  qdS r.   npexpand_dimsr$   r1   r   r   r   r4   W        >   
attentionshidden_statespast_key_valuesc                 3   r-   r.   r/   r1   r   r   r   r4   \   r5   c                 3   r6   r.   r7   r1   r   r   r   r4   ^   r:   Nr    )
isinstancer%   torchTensorr$   r0   itemsr   to_tupletupler8   ndarrayr9   	__class__)r   resultloader_batchedkelementr   r   r   loader_batch_itemF   s6   

z"PipelineIterator.loader_batch_itemc                 C   s   | j d ur| j | jk r|  S t| j}| j|fi | j}| jd urtt|tj	r,|}nt|t
r6|d }nt| d }|| }t|trLt|}n|jd }d|  k r\| jk ran n|| _t|t
rj|d n|| _d| _ |  S |S )Nr   )r$   r#   rJ   nextr*   r"   r   r>   r?   r@   rC   listkeysr   shaper%   )r   r   r   first_tensorkeyobserved_batch_sizer   r   r   __next__u   s(   






zPipelineIterator.__next__r   )r   r   r   r   r   r+   rJ   rR   r   r   r   r   r      s    
'/r   c                       s.   e Zd Zd fdd	Zdd Zdd Z  ZS )	PipelineChunkIteratorNc                    s   t  ||| dS )aI  
        Roughly equivalent to

        ```
        for iterator in loader:
            for item in iterator:
                yield infer(item, **params)
        ```

                Arguments:
                    loader (`torch.utils.data.DataLoader` or `Iterable`):
                        The iterator that will be used to apply `infer` on.
                    infer (any function):
                        The function to apply of each element of `loader`.
                    params (`dict`):
                        The parameters passed to `infer` along with every item
        N)superr   r&   rE   r   r   r      s   zPipelineChunkIterator.__init__c                 C   s   t | j| _d | _| S r   )r)   r!   r*   subiteratorr   r   r   r   r+      s   zPipelineChunkIterator.__iter__c                 C   st   | j d u r	 | jt| jfi | j| _ zt| j }W |S  ty9   | jt| jfi | j| _ t| j }Y |S w r   )rV   r"   rK   r*   r   StopIteration)r   r   r   r   r   rR      s   

zPipelineChunkIterator.__next__r   )r   r   r   r   r+   rR   __classcell__r   r   rU   r   rS      s    rS   c                   @   s    e Zd ZdZdd Zdd ZdS )PipelinePackIteratora  
    Roughly equivalent to

    ```
    packed =  []
    for item in loader:
        packed.append(item)
        if item["is_last"]:
            yield packed
            packed = []
    ```

        but it also handles cases where `item` are batched (meaning it's a dict of Tensor with first dimension > 1. In
        that case it does

    ```
    packed =  []
    for batch in loader:
        # item is batched
        for item in batch:
            packed.append(item)
            if item["is_last"]:
                yield packed
                packed = []
    ```

        Arguments:
            loader (`torch.utils.data.DataLoader` or `Iterable`):
                The iterator that will be used to apply `infer` on.
            infer (any function):
                The function to apply of each element of `loader`.
            params (`dict`):
                The parameters passed to `infer` along with every item
            loader_batch_size (`int`, *optional*):
                If specified, the items of `loader` are supposed to come as batch, and are loader_batched here making
                it roughly behave as


    ```
    for items in loader:
        for i in loader_batch_size:
            item = items[i]
            yield infer(item, **params)
    ```c                 C   r'   r   r(   r   r   r   r   r+      r,   zPipelinePackIterator.__iter__c                 C   sT  d}g }| j d ur-| j | jk r-| j | jk r-|  }|d}|| |r'|S | j | jk s|s| jt| jfi | j}| jd urt	|t
jrJ|}nt| d }|| }t	|tr`t|}n|jd }d|  k rp| jk run n|| _|| _d| _ | j | jk r|  }|d}|| |r|S | j | jk sn|}|d}|| |r/|S )NFis_lastr   )r$   r#   rJ   popappendr"   rK   r*   r   r>   r?   r@   rL   rM   r   rN   r%   )r   rZ   accumulatorr   r   rO   rP   rQ   r   r   r   rR      sJ   	









zPipelinePackIterator.__next__N)r   r   r   __doc__r+   rR   r   r   r   r   rY      s    -rY   c                   @   s.   e Zd ZdedefddZdd Zdd Zd	S )

KeyDatasetr
   rP   c                 C   s   || _ || _d S r   r
   rP   )r   r
   rP   r   r   r   r   ,  s   
zKeyDataset.__init__c                 C   r   r   r   r   r   r   r   r   0  r   zKeyDataset.__len__c                 C   s   | j | | j S r   r`   r   r   r   r   r   r   3  s   zKeyDataset.__getitem__Nr   r   r   r   strr   r   r   r   r   r   r   r_   +  s    r_   c                   @   s2   e Zd ZdededefddZdd Zdd	 Zd
S )KeyPairDatasetr
   key1key2c                 C   r   r   r
   re   rf   )r   r
   re   rf   r   r   r   r   8  r   zKeyPairDataset.__init__c                 C   r   r   r   r   r   r   r   r   =  r   zKeyPairDataset.__len__c                 C   s"   | j | | j | j | | j dS )N)text	text_pairrg   ra   r   r   r   r   @  s   "zKeyPairDataset.__getitem__Nrb   r   r   r   r   rd   7  s    rd   )numpyr8   r?   torch.utils.datar   r   utils.genericr   r   r   rS   rY   r_   rd   r   r   r   r   <module>   s     -d