
    rhz)                        d Z ddlmZ ddlmZ ddlZddlmZ ddlmZ ddl	m
Z
mZ dd	lmZ d
dlmZ e ed       G d de
                    Ze G d de             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d       G d de             ZddgZy)zPyTorch ViTMatte model.    )	dataclass)OptionalN)nn   )PreTrainedModel)ModelOutputauto_docstring)load_backbone   )VitMatteConfigz4
    Class for outputs of image matting models.
    )custom_introc                       e Zd ZU dZdZeej                     ed<   dZ	eej                     ed<   dZ
eeej                        ed<   dZeeej                        ed<   y)ImageMattingOutputa  
    loss (`torch.FloatTensor` of shape `(1,)`, *optional*, returned when `labels` is provided):
        Loss.
    alphas (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):
        Estimated alpha values.
    hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`):
        Tuple of `torch.FloatTensor` (one for the output of the embeddings, if the model has an embedding layer, +
        one for the output of each stage) of shape `(batch_size, sequence_length, hidden_size)`. Hidden-states
        (also called feature maps) of the model at the output of each stage.
    Nlossalphashidden_states
attentions)__name__
__module____qualname____doc__r   r   torchFloatTensor__annotations__r   r   tupler        /var/www/html/ai-insurance-compliance-backend/venv/lib/python3.12/site-packages/transformers/models/vitmatte/modeling_vitmatte.pyr   r      sg    	 )-D(5$$
%,*.FHU&&'.8<M8E%"3"345<59Ju00129r   r   c                   D    e Zd ZU eed<   dZdZg Zdej                  fdZ
y)VitMattePreTrainedModelconfigpixel_valuesTmodulec                 2   t        |t        j                  t        j                  f      rm|j                  j
                  j                  d| j                  j                         |j                  %|j                  j
                  j                          y y y )Ng        )meanstd)
isinstancer   Conv2dBatchNorm2dweightdatanormal_r!   initializer_rangebiaszero_)selfr#   s     r   _init_weightsz%VitMattePreTrainedModel._init_weights<   sj    fryy"..9:MM&&CT[[5R5R&S{{&  &&( ' ;r   N)r   r   r   r   r   main_input_namesupports_gradient_checkpointing_no_split_modulesr   Moduler1   r   r   r   r    r    5   s)    $O&*#)BII )r   r    c                   *     e Zd ZdZd fd	Zd Z xZS )VitMatteBasicConv3x3zP
    Basic convolution layers including: Conv3x3, BatchNorm2d, ReLU layers.
    c                     t         |           t        j                  ||d||d      | _        t        j
                  ||j                        | _        t        j                         | _	        y )Nr   F)in_channelsout_channelskernel_sizestridepaddingr.   )eps)
super__init__r   r(   convr)   batch_norm_eps
batch_normReLUrelu)r0   r!   r9   r:   r<   r=   	__class__s         r   r@   zVitMatteBasicConv3x3.__init__H   sW    II#%
	 ..6;P;PQGGI	r   c                 l    | j                  |      }| j                  |      }| j                  |      }|S N)rA   rC   rE   r0   hidden_states     r   forwardzVitMatteBasicConv3x3.forwardU   s2    yy.|4yy.r   )   r   r   r   r   r   r@   rK   __classcell__rF   s   @r   r7   r7   C   s    r   r7   c                   (     e Zd ZdZ fdZd Z xZS )VitMatteConvStreamzc
    Simple ConvStream containing a series of basic conv3x3 layers to extract detail features.
    c                    t         |           d}|j                  |j                  j                  }|j                  }t        j                         | _        |g|z   | _        t        t        | j                        dz
        D ]I  }| j                  |   }| j                  |dz      }| j                  j                  t        |||             K y )N   r   )r?   r@   backbone_confignum_channelsconvstream_hidden_sizesr   
ModuleListconvs
conv_chansrangelenappendr7   )r0   r!   r9   r:   iin_chan_	out_chan_rF   s          r   r@   zVitMatteConvStream.__init__b   s     !!- 00==K55]]_
&-,6s4??+a/0 	QAq)HA.IJJ268YOP	Qr   c                     d|i}|}t        t        | j                              D ]-  } | j                  |   |      }dt        |dz         z   }|||<   / |S )Ndetailed_feature_map_0detailed_feature_map_r   )rZ   r[   rX   str)r0   r"   out_dict
embeddingsr]   name_s         r   rK   zVitMatteConvStream.forwardu   sc    ,l;!
s4::' 	)A&Az2J+c!a%j8E(HUO	)
 r   rM   rO   s   @r   rQ   rQ   ]   s    Q&r   rQ   c                   (     e Zd ZdZ fdZd Z xZS )VitMatteFusionBlockz\
    Simple fusion block to fuse features from ConvStream and Plain Vision Transformer.
    c                 L    t         |           t        |||dd      | _        y )Nr   )r<   r=   )r?   r@   r7   rA   )r0   r!   r9   r:   rF   s       r   r@   zVitMatteFusionBlock.__init__   s$    (lST^_`	r   c                     t         j                  j                  |ddd      }t        j                  ||gd      }| j                  |      }|S )NrL   bilinearF)scale_factormodealign_cornersr   )dim)r   
functionalinterpolater   catrA   )r0   featuresdetailed_feature_mapupscaled_featuresouts        r   rK   zVitMatteFusionBlock.forward   sK    MM55hQU_ot5uii-/@AqIiin
r   rM   rO   s   @r   rh   rh      s    ar   rh   c                   (     e Zd ZdZ fdZd Z xZS )VitMatteHeadzJ
    Simple Matting Head, containing only conv3x3 and conv1x1 layers.
    c                 *   t         |           |j                  d   }d}t        j                  t        j
                  ||ddd      t        j                  |      t        j                  d      t        j
                  |dddd            | _        y )N   r   r   )r;   r<   r=   Tr   )	r?   r@   fusion_hidden_sizesr   
Sequentialr(   r)   rD   matting_convs)r0   r!   r9   mid_channelsrF   s       r   r@   zVitMatteHead.__init__   st    004]]IIk<QqRSTNN<(GGDMIIlA1QJ	
r   c                 (    | j                  |      }|S rH   )r~   rI   s     r   rK   zVitMatteHead.forward   s    )),7r   rM   rO   s   @r   rx   rx      s    
r   rx   c                   (     e Zd ZdZ fdZd Z xZS )VitMatteDetailCaptureModulezG
    Simple and lightweight Detail Capture Module for ViT Matting.
    c           
         t         |           t        |j                        t        |j                        dz   k7  rt        d      || _        t        |      | _        | j                  j                  | _	        t        j                         | _        |j                  g|j                  z   | _        t        t        | j                        dz
        D ]Z  }| j                  j!                  t#        || j                  |   | j                  |dz       z   | j                  |dz                   \ t%        |      | _        y )Nr   z_The length of fusion_hidden_sizes should be equal to the length of convstream_hidden_sizes + 1.)r!   r9   r:   )r?   r@   r[   r|   rV   
ValueErrorr!   rQ   
convstreamrY   r   rW   fusion_blockshidden_sizefusion_channelsrZ   r\   rh   rx   matting_head)r0   r!   r]   rF   s      r   r@   z$VitMatteDetailCaptureModule.__init__   s   v))*c&2P2P.QTU.UUq  ,V4//44]]_ & 2 23f6P6PPs4//0145 	A%%#! $ 4 4Q 7$//APQE(:S S!%!5!5a!e!<	 )0r   c                 6   | j                  |      }t        t        | j                              D ]B  }dt	        t        | j                        |z
  dz
        z   } | j                  |   |||         }D t        j                  | j                  |            }|S )Nrb   r   )r   rZ   r[   r   rc   r   sigmoidr   )r0   rs   r"   detail_featuresr]   detailed_feature_map_namer   s          r   rK   z#VitMatteDetailCaptureModule.forward   s    //,7s4--./ 	cA(?#c$J\J\F]`aFadeFeBf(f%,t))!,XG`7abH	c t00:;r   rM   rO   s   @r   r   r      s    12r   r   zX
    ViTMatte framework leveraging any vision backbone e.g. for ADE20k, CityScapes.
    c                        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   f
d       Z	 xZ
S )	VitMatteForImageMattingc                     t         |   |       || _        t        |      | _        t        |      | _        | j                          y rH   )r?   r@   r!   r
   backboner   decoder	post_init)r0   r!   rF   s     r   r@   z VitMatteForImageMatting.__init__   s;     %f-26: 	r   r"   output_attentionsoutput_hidden_stateslabelsreturn_dictc                    ||n| j                   j                  }||n| j                   j                  }||n| j                   j                  }d}|t	        d      | j
                  j                  |||      }|j                  d   }| j                  ||      }	|s|	f|dd z   }
||f|
z   S |
S t        ||	|j                  |j                        S )a8  
        labels (`torch.LongTensor` of shape `(batch_size, height, width)`, *optional*):
            Ground truth image matting for computing the loss.

        Examples:

        ```python
        >>> from transformers import VitMatteImageProcessor, VitMatteForImageMatting
        >>> import torch
        >>> from PIL import Image
        >>> from huggingface_hub import hf_hub_download

        >>> processor = VitMatteImageProcessor.from_pretrained("hustvl/vitmatte-small-composition-1k")
        >>> model = VitMatteForImageMatting.from_pretrained("hustvl/vitmatte-small-composition-1k")

        >>> filepath = hf_hub_download(
        ...     repo_id="hf-internal-testing/image-matting-fixtures", filename="image.png", repo_type="dataset"
        ... )
        >>> image = Image.open(filepath).convert("RGB")
        >>> filepath = hf_hub_download(
        ...     repo_id="hf-internal-testing/image-matting-fixtures", filename="trimap.png", repo_type="dataset"
        ... )
        >>> trimap = Image.open(filepath).convert("L")

        >>> # prepare image + trimap for the model
        >>> inputs = processor(images=image, trimaps=trimap, return_tensors="pt")

        >>> with torch.no_grad():
        ...     alphas = model(**inputs).alphas
        >>> print(alphas.shape)
        torch.Size([1, 1, 640, 960])
        ```NzTraining is not yet supported)r   r   rz   r   )r   r   r   r   )r!   use_return_dictr   r   NotImplementedErrorr   forward_with_filtered_kwargsfeature_mapsr   r   r   r   )r0   r"   r   r   r   r   r   outputsrs   r   outputs              r   rK   zVitMatteForImageMatting.forward   s    R &1%<k$++B]B]$8$D $++JjJj 	 2C1N-TXT_T_TqTq%&EFF--<</CWh = 
 ''+h5Y,F)-)9TGf$EvE!!//))	
 	
r   )NNNNN)r   r   r   r@   r	   r   r   TensorboolrK   rN   rO   s   @r   r   r      s      04,0/3)-&*B
u||,B
 $D>B
 'tn	B

 &B
 d^B
 B
r   r   )r   dataclassesr   typingr   r   r   modeling_utilsr   utilsr   r	   utils.backbone_utilsr
   configuration_vitmatter   r   r    r5   r7   rQ   rh   rx   r   r   __all__r   r   r   <module>r      s     !    - 0 1 2 
: : :$ 
)o 
) 
)299 4   F")) "299 0&")) &R 
N
5 N

N
b %&?
@r   