
    qiy*                        d 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	 ddl
mZ dd	lmZ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.    )	dataclassN)nn   )initialization)load_backbone)PreTrainedModel)ModelOutputauto_docstring   )VitMatteConfigz4
    Class for outputs of image matting models.
    )custom_introc                       e Zd ZU dZdZej                  dz  ed<   dZej                  dz  ed<   dZ	e
ej                     dz  ed<   dZe
ej                     dz  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   torchFloatTensor__annotations__r   r   tupler        `/opt/pipecat/venv/lib/python3.12/site-packages/transformers/models/vitmatte/modeling_vitmatte.pyr   r      sg    	 &*D%

d
")'+FE$+59M5**+d2926Je''(4/6r   r   c                   p    e Zd ZU eed<   dZdZdZg Z e	j                         dej                  fd       Zy)VitMattePreTrainedModelconfigpixel_values)imageTmodulec                    t        |t        j                  t        j                  f      rt	        j
                  |j                  d| j                  j                         |j                  t	        j                  |j                         t        |dd       ^t	        j                  |j                         t	        j                  |j                         t	        j                  |j                         y y y )Ng        )meanstdrunning_mean)
isinstancer   Conv2dBatchNorm2dinitnormal_weightr!   initializer_rangebiaszeros_getattrr(   ones_running_varnum_batches_tracked)selfr$   s     r   _init_weightsz%VitMattePreTrainedModel._init_weights<   s    fryy"..9:LLSdkk6S6ST{{&FKK(v~t4@F//0

6--.F667 A	 ;r   N)r   r   r   r   r   main_input_nameinput_modalitiessupports_gradient_checkpointing_no_split_modulesr   no_gradr   Moduler7   r   r   r   r    r    4   sD    $O!&*#U]]_8BII 8 8r   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paddingr0   )eps)
super__init__r   r*   convr+   batch_norm_eps
batch_normReLUrelu)r6   r!   rA   rB   rD   rE   	__class__s         r   rH   zVitMatteBasicConv3x3.__init__M   sW    II#%
	 ..6;P;PQGGI	r   c                 l    | j                  |      }| j                  |      }| j                  |      }|S N)rI   rK   rM   r6   hidden_states     r   forwardzVitMatteBasicConv3x3.forwardZ   s2    yy.|4yy.r   )   r   r   r   r   r   rH   rS   __classcell__rN   s   @r   r?   r?   H   s    r   r?   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   )rG   rH   backbone_confignum_channelsconvstream_hidden_sizesr   
ModuleListconvs
conv_chansrangelenappendr?   )r6   r!   rA   rB   iin_chan_	out_chan_rN   s          r   rH   zVitMatteConvStream.__init__g   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   )rb   rc   r`   str)r6   r"   out_dict
embeddingsre   name_s         r   rS   zVitMatteConvStream.forwardz   sc    ,l;!
s4::' 	)A&Az2J+c!a%j8E(HUO	)
 r   rU   rW   s   @r   rY   rY   b   s    Q&r   rY   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   )rD   rE   )rG   rH   r?   rI   )r6   r!   rA   rB   rN   s       r   rH   zVitMatteFusionBlock.__init__   s$    (lST^_`	r   c                     t         j                  j                  |ddd      }t        j                  ||gd      }| j                  |      }|S )NrT   bilinearF)scale_factormodealign_cornersr   )dim)r   
functionalinterpolater   catrI   )r6   featuresdetailed_feature_mapupscaled_featuresouts        r   rS   zVitMatteFusionBlock.forward   sK    MM55hQU_ot5uii-/@AqIiin
r   rU   rW   s   @r   rp   rp      s    ar   rp   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   )rC   rD   rE   Tr   )	rG   rH   fusion_hidden_sizesr   
Sequentialr*   r+   rL   matting_convs)r6   r!   rA   mid_channelsrN   s       r   rH   zVitMatteHead.__init__   st    004]]IIk<QqRSTNN<(GGDMIIlA1QJ	
r   c                 (    | j                  |      }|S rP   )r   rQ   s     r   rS   zVitMatteHead.forward   s    )),7r   rU   rW   s   @r   r   r      s    
r   r   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!   rA   rB   )rG   rH   rc   r   r^   
ValueErrorr!   rY   
convstreamra   r   r_   fusion_blockshidden_sizefusion_channelsrb   rd   rp   r   matting_head)r6   r!   re   rN   s      r   rH   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 )Nrj   r   )r   rb   rc   r   rk   r   sigmoidr   )r6   r{   r"   detail_featuresre   detailed_feature_map_namer   s          r   rS   z#VitMatteDetailCaptureModule.forward   s    //,7s4--./ 	cA(?#c$J\J\F]`aFadeFeBf(f%,t))!,XG`7abH	c t00:;r   rU   rW   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j                  dz  dedz  dedz  dej                  dz  dedz  f
d       Z xZ	S )
VitMatteForImageMattingc                     t         |   |       || _        t        |      | _        t        |      | _        | j                          y rP   )rG   rH   r!   r   backboner   decoder	post_init)r6   r!   rN   s     r   rH   z VitMatteForImageMatting.__init__   s;     %f-26: 	r   Nr"   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   r   r   )r   r   r   r   )r!   use_return_dictr   r   NotImplementedErrorr   forward_with_filtered_kwargsfeature_mapsr   r   r   r   )r6   r"   r   r   r   r   kwargsr   outputsr{   r   outputs               r   rS   zVitMatteForImageMatting.forward   s    T &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   rH   r
   r   TensorboolrS   rV   rW   s   @r   r   r      s      -1)-,0&*#'C
llT)C
  $;C
 #Tk	C

 t#C
 D[C
 C
r   r   )r   dataclassesr   r   r    r   r,   backbone_utilsr   modeling_utilsr   utilsr	   r
   configuration_vitmatter   r   r    r=   r?   rY   rp   r   r   r   __all__r   r   r   <module>r      s     !   & + - 0 2 
7 7 7$ 8o 8 8&299 4   F")) "299 0&")) &R 
O
5 O

O
d %&?
@r   