
     `i8                        d Z ddlmZmZ ddlZddlmZ ddlmZ ddlm	Z	 ddl
mZ dd	lmZ dd
lmZ ddlmZ  G d dej                  Z G d dej                  Z G d dej                  Z G d dej                  Z G d dej                  Ze G d de                      Z ed           G d de                      ZddgZdS )zrPyTorch UperNet model. Based on OpenMMLab's implementation, found in https://github.com/open-mmlab/mmsegmentation.    )OptionalUnionN)nn)CrossEntropyLoss   )SemanticSegmenterOutput)PreTrainedModel)auto_docstring)load_backbone   )UperNetConfigc                        e Zd ZdZ	 	 	 ddededeeeeef         f         deeeeef         ef         d	ed
eeeeef         f         ddf fdZ	de
j        de
j        fdZ xZS )UperNetConvModulez
    A convolutional block that bundles conv/norm/activation layers. This block simplifies the usage of convolution
    layers, which are commonly used with a norm layer (e.g., BatchNorm) and activation layer (e.g., ReLU).
    r   Fr   in_channelsout_channelskernel_sizepaddingbiasdilationreturnNc                     t                                                       t          j        ||||||          | _        t          j        |          | _        t          j                    | _        d S )N)r   r   r   r   r   r   )	super__init__r   Conv2dconvBatchNorm2d
batch_normReLU
activation)selfr   r   r   r   r   r   	__class__s          /home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/transformers/models/upernet/modeling_upernet.pyr   zUperNetConvModule.__init__$   si     	I#%#
 
 
	 .66'))    inputc                     |                      |          }|                     |          }|                     |          }|S N)r   r   r   )r    r$   outputs      r"   forwardzUperNetConvModule.forward9   s:    5!!((((r#   )r   Fr   )__name__
__module____qualname____doc__intr   tuplestrboolr   torchTensorr(   __classcell__r!   s   @r"   r   r      s          5601$ $$ $ 3c3h/0	$
 sE#s(OS01$ $ U38_,-$ 
$ $ $ $ $ $*U\ el        r#   r   c                   T     e Zd Zdedededdf fdZdej        dej        fdZ xZS )	UperNetPyramidPoolingBlock
pool_scaler   channelsr   Nc                    t                                                       t          j        |          t	          ||d          g| _        t          | j                  D ](\  }}|                     t          |          |           )d S )Nr   r   )	r   r   r   AdaptiveAvgPool2dr   layers	enumerate
add_moduler/   )r    r7   r   r8   ilayerr!   s         r"   r   z#UperNetPyramidPoolingBlock.__init__B   s     ,,k8CCC
 "$+.. 	+ 	+HAuOOCFFE****	+ 	+r#   r$   c                 4    |}| j         D ]} ||          }|S r&   )r<   )r    r$   hidden_stater@   s       r"   r(   z"UperNetPyramidPoolingBlock.forwardK   s/    [ 	/ 	/E 5..LLr#   )	r)   r*   r+   r-   r   r1   r2   r(   r3   r4   s   @r"   r6   r6   A   s        +3 +S +C +D + + + + + +U\ el        r#   r6   c            
       x     e Zd ZdZdeedf         dedededdf
 fd	Zd
ej	        de
ej	                 fdZ xZS )UperNetPyramidPoolingModulea}  
    Pyramid Pooling Module (PPM) used in PSPNet.

    Args:
        pool_scales (`tuple[int]`):
            Pooling scales used in Pooling Pyramid Module.
        in_channels (`int`):
            Input channels.
        channels (`int`):
            Channels after modules, before conv_seg.
        align_corners (`bool`):
            align_corners argument of F.interpolate.
    pool_scales.r   r8   align_cornersr   Nc                 V   t                                                       || _        || _        || _        || _        g | _        t          |          D ]T\  }}t          |||          }| j        	                    |           | 
                    t          |          |           Ud S )N)r7   r   r8   )r   r   rE   rF   r   r8   blocksr=   r6   appendr>   r/   )	r    rE   r   r8   rF   r?   r7   blockr!   s	           r"   r   z$UperNetPyramidPoolingModule.__init__a   s    &*& &{33 	+ 	+MAz.*R]hpqqqEKu%%%OOCFFE****	+ 	+r#   xc                     g }| j         D ]d} ||          }t          j                            ||                                dd          d| j                  }|                    |           e|S )N   bilinearsizemoderF   )rH   r   
functionalinterpolaterP   rF   rI   )r    rK   ppm_outsppmppm_outupsampled_ppm_outs         r"   r(   z#UperNetPyramidPoolingModule.forwardm   s{    ; 	/ 	/Cc!ffG " 9 9affhhqrrl4K] !: ! ! OO-....r#   )r)   r*   r+   r,   r.   r-   r0   r   r1   r2   listr(   r3   r4   s   @r"   rD   rD   R   s         
+E#s(O 
+# 
+QT 
+ei 
+nr 
+ 
+ 
+ 
+ 
+ 
+ $u|*<        r#   rD   c                   L     e Zd ZdZ fdZd Zdej        dej        fdZ xZ	S )UperNetHeadz
    Unified Perceptual Parsing for Scene Understanding. This head is the implementation of
    [UPerNet](https://huggingface.co/papers/1807.10221).
    c                    t                                                       || _        |j        | _        || _        |j        | _        d| _        t          j	        | j        |j
        d          | _        t          | j        | j        d         | j        | j                  | _        t          | j        d         t          | j                  | j        z  z   | j        dd          | _        t          j                    | _        t          j                    | _        | j        d d         D ]j}t          || j        d          }t          | j        | j        dd          }| j                            |           | j                            |           kt          t          | j                  | j        z  | j        dd          | _        d S )NFr   r:   )rF   r   r   r   )r   r   configrE   r   hidden_sizer8   rF   r   r   
num_labels
classifierrD   psp_modulesr   len
bottleneck
ModuleListlateral_convs	fpn_convsrI   fpn_bottleneck)r    r^   r   l_convfpn_convr!   s        r"   r   zUperNetHead.__init__~   s   !-&*")DM63DRSTTT 7R M,	
 
 
 ,R 3t'7#8#84=#HHM	
 
 
  ]__+CRC0 	, 	,K&{DMqQQQF(ST^_```H%%f---N!!(++++/ !!DM1M	
 
 
r#   c                     |d         }|g}|                     |                     |                     t          j        |d          }|                     |          }|S )Nr\   r   dim)extendrb   r1   catrd   )r    inputsrK   psp_outsr'   s        r"   psp_forwardzUperNetHead.psp_forward   s\    2J3((++,,,9X1---**r#   encoder_hidden_statesr   c                 B    fdt           j                  D                                                                           t	                    }t          |dz
  dd          D ]Z}|dz
           j        dd          }|dz
           t          j        	                    |         |d j
                  z   |dz
  <   [ fdt          |dz
            D             }|                    d                    t          |dz
  dd          D ]F}t          j        	                    ||         |d         j        dd          d j
                  ||<   Gt          j        |d	          }                     |          }                     |          }|S )
Nc                 8    g | ]\  }} ||                   S  rv   ).0r?   lateral_convrs   s      r"   
<listcomp>z'UperNetHead.forward.<locals>.<listcomp>   s-    pppq,LL!6q!9::pppr#   r   r   r\   rM   rN   rO   c                 H    g | ]} j         |         |                   S rv   )rg   )rw   r?   lateralsr    s     r"   ry   z'UperNetHead.forward.<locals>.<listcomp>   s/    \\\q%DN1%hqk22\\\r#   rl   )r=   rf   rI   rr   rc   rangeshaper   rR   rS   rF   r1   ro   rh   ra   )r    rs   used_backbone_levelsr?   
prev_shapefpn_outsr'   r{   s   ``     @r"   r(   zUperNetHead.forward   s   ppppR[\`\nRoRoppp(()>??@@@  #8}}+a/B77 	 	A!!a%.qrr2J&q1uo0I0I*:TM_ 1J 1 1 HQUOO
 ]\\\\EBVYZBZ<[<[\\\%%%+a/B77 	 	A-33(1+"3ABB"7jX\Xj 4  HQKK 9X1---$$X..((r#   )
r)   r*   r+   r,   r   rr   r1   r2   r(   r3   r4   s   @r"   rZ   rZ   x   sx         
%
 %
 %
 %
 %
N  U\ el        r#   rZ   c                   |     e Zd ZdZ	 ddededeeeeef         f         dd	f fd
Zdej	        dej	        fdZ
 xZS )UperNetFCNHeada  
    Fully Convolution Networks for Semantic Segmentation. This head is the implementation of
    [FCNNet](https://huggingface.co/papers/1411.4038>).

    Args:
        config:
            Configuration.
        in_channels (int):
            Number of input channels.
        kernel_size (int):
            The kernel size for convs in the head. Default: 3.
        dilation (int):
            The dilation rate for convs in the head. Default: 1.
    rM   r   r   in_indexr   r   r   Nc           
         t                                                       || _        |j        ||         n|j        | _        |j        | _        |j        | _        |j	        | _
        || _        |dz  |z  }g }|                    t          | j        | j        |||                     t          | j        dz
            D ]3}|                    t          | j        | j        |||                     4| j        dk    rt          j                    | _        nt          j        | | _        | j
        r-t          | j        | j        z   | j        ||dz            | _        t          j        | j        |j        d          | _        d S )NrM   )r   r   r   r   r   r]   r:   )r   r   r^   auxiliary_in_channelsr   auxiliary_channelsr8   auxiliary_num_convs	num_convsauxiliary_concat_inputconcat_inputr   rI   r   r|   r   Identityconvs
Sequentialconv_catr   r`   ra   )
r    r^   r   r   r   r   conv_paddingr   r?   r!   s
            r"   r   zUperNetFCNHead.__init__   s    	%+%A%IK!!vOk 	 13"9 #q(H4 $-[R^iq  	
 	
 	

 t~)** 	 	ALL!M4=kS_jr     
 >QDJJ.DJ 	- 4=0$-[bmqrbr  DM )DM63DRSTTTr#   rs   c                     || j                  }|                     |          }| j        r+|                     t	          j        ||gd                    }|                     |          }|S )Nr   rl   )r   r   r   r   r1   ro   ra   )r    rs   hidden_statesr'   s       r"   r(   zUperNetFCNHead.forward  sf    -dm<M** 	N]]59mV-D!#L#L#LMMF((r#   )rM   r   r   )r)   r*   r+   r,   r-   r   r.   r   r1   r2   r(   r3   r4   s   @r"   r   r      s           uv$U $U-0$UCF$UV[\_afgjlogoap\pVq$U	$U $U $U $U $U $ULU\ el        r#   r   c                   (    e Zd ZU eed<   dZg Zd ZdS )UperNetPreTrainedModelr^   pixel_valuesc                    t          |t          j                  rT|j        j                            d| j        j                   |j         |j        j        	                                 d S d S t          |t          j
                  r?|j        j                            d           |j        j        	                                 d S d S )Ng        )meanstdg      ?)
isinstancer   r   weightdatanormal_r^   initializer_ranger   zero_r   fill_)r    modules     r"   _init_weightsz$UperNetPreTrainedModel._init_weights  s    fbi(( 	%M&&CT[5R&SSS{& &&((((( '&// 	%M$$S)))K""$$$$$	% 	%r#   N)r)   r*   r+   r   __annotations__main_input_name_no_split_modulesr   rv   r#   r"   r   r     s<         $O% % % % %r#   r   zW
    UperNet framework leveraging any vision backbone e.g. for ADE20k, CityScapes.
    )custom_introc                        e Zd Z fdZe	 	 	 	 	 d
deej                 dee         dee         deej                 dee         de	e
ef         fd	            Z xZS )UperNetForSemanticSegmentationc                 ,   t                                          |           t          |          | _        t	          || j        j                  | _        |j        rt          || j        j                  nd | _	        | 
                                 d S )N)r   )r   r   r   backbonerZ   r8   decode_headuse_auxiliary_headr   auxiliary_head	post_init)r    r^   r!   s     r"   r   z'UperNetForSemanticSegmentation.__init__"  s       %f-- 'v4=;QRRRJPJcmN6t}/EFFFFim 	
 	r#   Nr   output_attentionsoutput_hidden_stateslabelsreturn_dictr   c                 6   || j         j        dk    rt          d          ||n| j         j        }||n| j         j        }||n| j         j        }| j                            |||          }|j        }| 	                    |          }t          j                            ||j        dd         dd          }d}	| j        E|                     |          }	t          j                            |	|j        dd         dd          }	d}
|Ft          | j         j        	          } |||          }
|	 ||	|          }|
| j         j        |z  z  }
|s)|r|f|dd         z   }n|f|dd         z   }|
|
f|z   n|S t%          |
||j        |j        
          S )a  
        labels (`torch.LongTensor` of shape `(batch_size, height, width)`, *optional*):
            Ground truth semantic segmentation maps for computing the loss. Indices should be in `[0, ...,
            config.num_labels - 1]`. If `config.num_labels > 1`, a classification loss is computed (Cross-Entropy).

        Examples:
        ```python
        >>> from transformers import AutoImageProcessor, UperNetForSemanticSegmentation
        >>> from PIL import Image
        >>> from huggingface_hub import hf_hub_download

        >>> image_processor = AutoImageProcessor.from_pretrained("openmmlab/upernet-convnext-tiny")
        >>> model = UperNetForSemanticSegmentation.from_pretrained("openmmlab/upernet-convnext-tiny")

        >>> filepath = hf_hub_download(
        ...     repo_id="hf-internal-testing/fixtures_ade20k", filename="ADE_val_00000001.jpg", repo_type="dataset"
        ... )
        >>> image = Image.open(filepath).convert("RGB")

        >>> inputs = image_processor(images=image, return_tensors="pt")

        >>> outputs = model(**inputs)

        >>> logits = outputs.logits  # shape (batch_size, num_labels, height, width)
        >>> list(logits.shape)
        [1, 150, 512, 512]
        ```Nr   z/The number of labels should be greater than one)r   r   rM   rN   FrO   )ignore_index)losslogitsr   
attentions)r^   r`   
ValueErroruse_return_dictr   r   r   forward_with_filtered_kwargsfeature_mapsr   r   rR   rS   r}   r   r   loss_ignore_indexauxiliary_loss_weightr   r   r   )r    r   r   r   r   r   outputsfeaturesr   auxiliary_logitsr   loss_fctauxiliary_lossr'   s                 r"   r(   z&UperNetForSemanticSegmentation.forward0  s   H $+"8A"="=NOOO%0%<kk$+B]$8$D  $+Jj 	 2C1N--TXT_Tq-<</CWh = 
 
 '!!(++**68J1228NU_ot*uu*#228<<!}88 |'9!""'=J^c  9     'T[5RSSSH8FF++D+!)*:F!C!C9NJJ 	F# 1 WQRR[0 WQRR[0)-)9TGf$$vE&!/)	
 
 
 	
r#   )NNNNN)r)   r*   r+   r   r
   r   r1   r2   r0   r   r.   r   r(   r3   r4   s   @r"   r   r     s              04,0/3)-&*P
 P
u|,P
 $D>P
 'tn	P

 &P
 d^P
 
u--	.P
 P
 P
 ^P
 P
 P
 P
 P
r#   r   )r,   typingr   r   r1   r   torch.nnr   modeling_outputsr   modeling_utilsr	   utilsr
   utils.backbone_utilsr   configuration_upernetr   Moduler   r6   rD   rZ   r   r   r   __all__rv   r#   r"   <module>r      s5   y x " " " " " " " "        % % % % % % 7 7 7 7 7 7 - - - - - - # # # # # # 1 1 1 1 1 1 0 0 0 0 0 0         	      F       "# # # # #") # # #LQ Q Q Q Q") Q Q Qh= = = = =RY = = =@ % % % % %_ % % %   
`
 `
 `
 `
 `
%; `
 `
 
`
F ,-E
Fr#   