
    kh                     >   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                 r   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        ||	|      }||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      dtypedevicer   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                V/var/www/teggl/fontify/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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        |||	|
      }||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   drop_block3dr$   r%   r&   r'   r(   r   r   r)   r*   r+   
max_pool3dr-   r.   r/   )r   r   r	   r
   r   r   r0   r1   Dr2   r3   r4   r5   r6   s                 r7   r=   r=   7   s   & 99!!#EII,@,@,BL)3w!c'OPQsRSTUUzzQ>uzzl,WXXqCxJJLMAq!QZAq)J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 /Lr8   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        r7   rE   zDropBlock2d.__init__q   s*    $r8   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   rG   r   s     r7   forwardzDropBlock2d.forwardy   0     E4664??DLL$((TXTaTabbr8   c                     | j                   j                   d| j                   d| j                   d| j                   d}|S )Nz(p=z, block_size=z
, inplace=))rH   __name__r   r	   r
   )rG   ss     r7   __repr__zDropBlock2d.__repr__   sC    ~~&&'s466(-?PPZ[_[g[gZhhijr8   Fư>)rP   
__module____qualname____doc__floatintboolrE   r   rL   strrR   __classcell__rH   s   @r7   rA   rA   l   sS    % S 4 e `d cV c c# r8   rA   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 rC   )rD   rE   rF   s        r7   rE   zDropBlock3d.__init__   s    J5r8   r   c                     t        || j                  | j                  | j                  | j                  | j
                        S rJ   )r=   r   r	   r
   r   r   rK   s     r7   rL   zDropBlock3d.forward   rM   r8   rS   )rP   rU   rV   rW   rX   rY   rZ   rE   r   rL   r\   r]   s   @r7   r_   r_      sG    6% 6S 64 6e 6`d 6cV c cr8   r_   )FrT   T)r   torch.fxtorch.nn.functionalr   
functionalr*   r   utilsr   rX   rY   rZ   r#   r=   fxwrapModulerA   r_    r8   r7   <module>rj      s         ' ko+++),+7;+JO+cg++^ ko///),/7;/JO/cg//d n ")) 8 n c+ cr8   