
    i                     >   d dl Z d dlZ d dlmc mZ d dl mZmZ ddlmZ 	 ddede	de
ded	e	d
edefdZ	 ddede	de
ded	e	d
edefdZe j                  j                  d        G d dej                         Ze j                  j                  d        G d de      Zy)    N)nnTensor   )_log_api_usage_onceinputp
block_sizeinplaceepstrainingreturnc                    t         j                  j                         s-t         j                  j                         st	        t
               |dk  s|dkD  rt        d| d      | j                  dk7  rt        d| j                   d      |r|dk(  r| S | j                         \  }}}}	t        ||	|      }|dz  d	k(  rt        d
| d      ||z  |	z  |dz  ||z
  dz   |	|z
  dz   z  z  z  }
t        j                  ||||z
  dz   |	|z
  dz   f| j                  | j                        }|j                  |
       t        j                  ||dz  gdz  d	      }t        j                   |d||f|dz        }d|z
  }|j#                         ||j%                         z   z  }|r"| j'                  |      j'                  |       | S | |z  |z  } | S )a  
    Implements DropBlock2d from `"DropBlock: A regularization method for convolutional networks"
    <https://arxiv.org/abs/1810.12890>`.

    Args:
        input (Tensor[N, C, H, W]): The input tensor or 4-dimensions with the first one
                    being its batch i.e. a batch with ``N`` rows.
        p (float): Probability of an element to be dropped.
        block_size (int): Size of the block to drop.
        inplace (bool): If set to ``True``, will do this operation in-place. Default: ``False``.
        eps (float): A value added to the denominator for numerical stability. Default: 1e-6.
        training (bool): apply dropblock if is ``True``. Default: ``True``.

    Returns:
        Tensor[N, C, H, W]: The randomly zeroed tensor after dropblock.
                  ?4drop probability has to be between 0 and 1, but got .   z#input should be 4 dimensional. Got  dimensions.r   r   block size should be odd. Got  which is even.   dtypedevicevalue)r   r   stridekernel_sizepadding)torchjitis_scripting
is_tracingr   drop_block2d
ValueErrorndimsizeminemptyr   r   
bernoulli_Fpad
max_pool2dnumelsummul_)r   r   r	   r
   r   r   NCHWgammanoisenormalize_scales                T/var/www/html/engine/venv/lib/python3.12/site-packages/torchvision/ops/drop_block.pyr%   r%   	   s   & 99!!#EII,@,@,BL)3w!c'OPQsRSTUUzzQ>uzzl,WXXqCxJAq!QZA&JA~9*_UVV UQYJMq:~/Aa*nWXFX.YZ[EKKAq:~11z>A3EFekkbgbnbnoE	UEE%*/*Q.a8ELLvJ
;S]gkl]lmEIEkkmsUYY['89O

5/ L /L    c                    t         j                  j                         s-t         j                  j                         st	        t
               |dk  s|dkD  rt        d| d      | j                  dk7  rt        d| j                   d      |r|dk(  r| S | j                         \  }}}}	}
t        |||	|
      }|dz  d	k(  rt        d
| d      ||z  |	z  |
z  |dz  ||z
  dz   |	|z
  dz   z  |
|z
  dz   z  z  z  }t        j                  ||||z
  dz   |	|z
  dz   |
|z
  dz   f| j                  | j                        }|j                  |       t        j                  ||dz  gdz  d	      }t        j                   |d|||f|dz        }d|z
  }|j#                         ||j%                         z   z  }|r"| j'                  |      j'                  |       | S | |z  |z  } | S )a  
    Implements DropBlock3d from `"DropBlock: A regularization method for convolutional networks"
    <https://arxiv.org/abs/1810.12890>`.

    Args:
        input (Tensor[N, C, D, H, W]): The input tensor or 5-dimensions with the first one
                    being its batch i.e. a batch with ``N`` rows.
        p (float): Probability of an element to be dropped.
        block_size (int): Size of the block to drop.
        inplace (bool): If set to ``True``, will do this operation in-place. Default: ``False``.
        eps (float): A value added to the denominator for numerical stability. Default: 1e-6.
        training (bool): apply dropblock if is ``True``. Default: ``True``.

    Returns:
        Tensor[N, C, D, H, W]: The randomly zeroed tensor after dropblock.
    r   r   r   r      z#input should be 5 dimensional. Got r   r   r   r   r      r   r      r   )r   r   r   r   )r!   r"   r#   r$   r   drop_block3dr&   r'   r(   r)   r*   r   r   r+   r,   r-   
max_pool3dr/   r0   r1   )r   r   r	   r
   r   r   r2   r3   Dr4   r5   r6   r7   r8   s                 r9   r?   r?   :   s
   & 99!!#EII,@,@,BL)3w!c'OPQsRSTUUzzQ>uzzl,WXXqCxJJLMAq!QZAq)JA~9*_UVV UQY]
A1z>A3E!j.[\J\2]abeoaorsas2tuvEKK	
Aq:~!1z>A#5q:~7IJRWR]R]fkfrfrE 
UEE%*/*Q.a8ELLij*j-Q[eij[jE IEkkmsUYY['89O

5/ L /Lr:   r%   c                   V     e Zd ZdZddededededdf
 fdZd	edefd
Z	de
fdZ xZS )DropBlock2dz#
    See :func:`drop_block2d`.
    r   r	   r
   r   r   Nc                 Z    t         |           || _        || _        || _        || _        y N)super__init__r   r	   r
   r   selfr   r	   r
   r   	__class__s        r9   rG   zDropBlock2d.__init__w   s*    $r:   r   c                     t        || j                  | j                  | j                  | j                  | j
                        S z
        Args:
            input (Tensor): Input feature map on which some areas will be randomly
                dropped.
        Returns:
            Tensor: The tensor after DropBlock layer.
        )r%   r   r	   r
   r   r   rI   r   s     r9   forwardzDropBlock2d.forward   0     E4664??DLL$((TXTaTabbr:   c                     | j                   j                   d| j                   d| j                   d| j                   d}|S )Nz(p=z, block_size=z
, inplace=))rJ   __name__r   r	   r
   )rI   ss     r9   __repr__zDropBlock2d.__repr__   sC    ~~&&'s466(-?PPZ[_[g[gZhhijr:   Fư>)rR   
__module____qualname____doc__floatintboolrG   r   rN   strrT   __classcell__rJ   s   @r9   rC   rC   r   sS    % S 4 e `d cV c c# r:   rC   r?   c                   J     e Zd ZdZddededededdf
 fdZd	edefd
Z	 xZ
S )DropBlock3dz#
    See :func:`drop_block3d`.
    r   r	   r
   r   r   Nc                 *    t         |   ||||       y rE   )rF   rG   rH   s        r9   rG   zDropBlock3d.__init__   s    J5r:   r   c                     t        || j                  | j                  | j                  | j                  | j
                        S rL   )r?   r   r	   r
   r   r   rM   s     r9   rN   zDropBlock3d.forward   rO   r:   rU   )rR   rW   rX   rY   rZ   r[   r\   rG   r   rN   r^   r_   s   @r9   ra   ra      sG    6% 6S 64 6e 6`d 6cV c cr:   ra   )FrV   T)r!   torch.fxtorch.nn.functionalr   
functionalr,   r   utilsr   rZ   r[   r\   r%   r?   fxwrapModulerC   ra    r:   r9   <module>rl      s         ' ko...),.7;.JO.cg..d ko222),27;2JO2cg22j n ")) 8 n c+ cr:   