
    ڧg                     >   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                            d            G d dej                  Ze j                            d            G d de          ZdS )    N)nnTensor   )_log_api_usage_onceFư>Tinputp
block_sizeinplaceepstrainingreturnc                    t           j                                        s2t           j                                        st	          t
                     |dk     s|dk    rt          d| d          | j        dk    rt          d| j         d          |r|dk    r| S |                                 \  }}}}	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        
          }|                    |
           t          j        ||dz  gdz  d          }t          j        |d||f|dz            }d	|z
  }|                                ||                                z   z  }|r)|                     |                              |           n| |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/html/ai-engine/env/lib/python3.11/site-packages/torchvision/ops/drop_block.pyr$   r$   	   s   & 9!!## *EI,@,@,B,B *L)))3ww!c''TPQTTTUUUzQWuzWWWXXX qCxxJAq!QZA&&JUQYJMq:~/Aa*nWXFX.YZ[EKAq:~11z>A3EFekbgbnoooE	UE%*/*Q.a888ELvJ
;S]gkl]lmmmEIEkkmmsUYY[['89O 0

5/////L    c                    t           j                                        s2t           j                                        st	          t
                     |dk     s|dk    rt          d| d          | j        dk    rt          d| j         d          |r|dk    r| S |                                 \  }}}}	}
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        
          }|                    |           t          j        ||dz  gdz  d          }t          j        |d|||f|dz            }d	|z
  }|                                ||                                z   z  }|r)|                     |                              |           n| |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/   r0   )r   r	   r
   r   r   r   r1   r2   Dr3   r4   r5   r6   r7   s                 r8   r>   r>   7   s0   & 9!!## *EI,@,@,B,B *L)))3ww!c''TPQTTTUUUzQWuzWWWXXX qCxxJJLLMAq!QZAq))JUQY]
A1z>A3E!j.[\J\2]abeoaorsas2tuvEK	
Aq:~!1z>A#5q:~7IJRWR]fkfr  E 
UE%*/*Q.a888ELij*j-Q[eij[j  E IEkkmmsUYY[['89O 0

5/////Lr9   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`.
    Fr   r	   r
   r   r   r   Nc                     t                                                       || _        || _        || _        || _        d S N)super__init__r	   r
   r   r   selfr	   r
   r   r   	__class__s        r8   rF   zDropBlock2d.__init__q   s9    $r9   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   rH   r   s     r8   forwardzDropBlock2d.forwardy   (     E464?DL$(TXTabbbr9   c                 T    | j         j         d| j         d| j         d| j         d}|S )Nz(p=z, block_size=z
, inplace=))rI   __name__r	   r
   r   )rH   ss     r8   __repr__zDropBlock2d.__repr__   s:    ~&jj46jjjj[_[gjjjr9   Fr   )rQ   
__module____qualname____doc__floatintboolrF   r   rM   strrS   __classcell__rI   s   @r8   rB   rB   l   s          % S 4 e `d      cV c c c c c#        r9   rB   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`.
    Fr   r	   r
   r   r   r   Nc                 P    t                                          ||||           d S rD   )rE   rF   rG   s        r8   rF   zDropBlock3d.__init__   s'    J55555r9   r   c                 \    t          || j        | j        | j        | j        | j                  S rK   )r>   r	   r
   r   r   r   rL   s     r8   rM   zDropBlock3d.forward   rN   r9   rT   )rQ   rU   rV   rW   rX   rY   rZ   rF   r   rM   r\   r]   s   @r8   r_   r_      s         6 6% 6S 64 6e 6`d 6 6 6 6 6 6cV c c c c c c c c cr9   r_   )Fr   T)r    torch.fxtorch.nn.functionalr   
functionalr+   r   utilsr   rX   rY   rZ   r$   r>   fxwrapModulerB   r_    r9   r8   <module>rj      s                      ' ' ' ' ' ' ko+ +++),+7;+JO+cg++ + + +^ ko/ ///),/7;/JO/cg// / / /d n       ")   8 n   c c c c c+ c c c c cr9   