
    j>A                     :   U d dl mZ d dlmZ d dl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mZ dd
lmZ ddlmZmZ ddlmZmZ g dZddddddddddddddddZeeeeef         f         ed<    G d dej                   Z! G d dej"                  Z# G d deej                   Z$de$ej         z  de$fd Z%	 	 d.d"ed#e&d$ee&gej         f         d%e'e         d&e&d'e'e         dz  d(ede$fd)Z(d/d#e&d(ede$fd+Z)d/d#e&d(ede$fd,Z*d/d#e&d(ede$fd-Z+dS )0    )Callable)AnyN)nn)
functional)IntermediateLayerGetter)
CLASS_NAME   )textnet_basetextnet_smalltextnet_tinyFASTConvLayer)_bf16_to_float32load_pretrained_params   )_FASTFASTPostProcessor)FAST	fast_tiny
fast_small	fast_basereparameterize)r	      r   )gK7?gQ?gNbX9?)gL7A`?gj+?g|?5^?zLhttps://doctr-static.mindee.com/models?id=v0.8.1/fast_tiny-1acac421.pt&src=0)input_shapemeanstdurlzMhttps://doctr-static.mindee.com/models?id=v0.8.1/fast_small-10952cc1.pt&src=0zLhttps://doctr-static.mindee.com/models?id=v0.8.1/fast_base-688a8b34.pt&src=0)r   r   r   default_cfgsc                        e Zd ZdZ	 ddededdf fdZdej        d	ej        dej        fd
Zdej        dej        fdZ	 xZ
S )FastNeckzNeck of the FAST architecture, composed of a series of 3x3 convolutions and upsampling layers.

    Args:
        in_channels: number of input channels
        out_channels: number of output channels
       in_channelsout_channelsreturnNc                     t                                                       t          j        fddD                       | _        d S )Nc                 :    g | ]}t          |z  d           S )r	   kernel_sizer   ).0scaler"   r#   s     f/var/www/html/Carbon-Document/venv/lib/python3.11/site-packages/doctr/models/detection/fast/pytorch.py
<listcomp>z%FastNeck.__init__.<locals>.<listcomp>=   s:     (
 (
 (
PUM+-|KKK(
 (
 (
    )r            )super__init__r   
ModuleList	reduction)selfr"   r#   	__class__s    ``r+   r2   zFastNeck.__init__7   s_    
 	 (
 (
 (
 (
 (
Ye(
 (
 (
  r-   xyc                 J    t          j        ||j        dd          d          S )Nbilinearsizemode)Finterpolateshape)r5   r7   r8   s      r+   	_upsamplezFastNeck._upsampleA   s#    }QQWRSS\
CCCCr-   c                      |\  }}}d t           j        |||f          D             \  }}} fd|||fD             \  }}}t          j        |||fd          }|S )Nc                 *    g | ]\  }} ||          S  rE   )r)   r4   fs      r+   r,   z$FastNeck.forward.<locals>.<listcomp>F   s$    aaa<9a))A,,aaar-   c                 <    g | ]}                     |          S rE   )rB   )r)   rF   f1r5   s     r+   r,   z$FastNeck.forward.<locals>.<listcomp>G   s'    BBBdnnQ++BBBr-   r   )zipr4   torchcat)r5   r7   f2f3f4rF   rH   s   `     @r+   forwardzFastNeck.forwardD   s    BBaa3t~PRTVXZ\^O_;`;`aaaBBBBBBBb"b\BBB
BIr2r2&**r-   )r!   )__name__
__module____qualname____doc__intr2   rJ   TensorrB   rO   __classcell__r6   s   @r+   r    r    /   s              
	     D5< DEL DU\ D D D D %,        r-   r    c                   >     e Zd ZdZ	 	 ddededededd	f
 fd
Z xZS )FastHeadzHead of the FAST architecture

    Args:
        in_channels: number of input channels
        num_classes: number of output classes
        out_channels: number of output channels
        dropout: dropout probability
    r!   皙?r"   num_classesr#   dropoutr$   Nc                     t          ||d          t          j        |          t          j        ||dd          g} t	                      j        |  d S )Nr	   r'   r   F)r(   bias)r   r   DropoutConv2dr1   r2   )r5   r"   r[   r#   r\   _layersr6   s         r+   r2   zFastHead.__init__V   s]     +|CCCJwIlKQUKKK$

 	'""""r-   )r!   rZ   )rP   rQ   rR   rS   rT   floatr2   rV   rW   s   @r+   rY   rY   L   s           # ## # 	#
 # 
# # # # # # # # # #r-   rY   c                   :    e Zd ZdZddddddi egfdededed	ed
ededede	e
ef         dee
         ddf fdZde
deddfdZ	 	 	 ddej        deej                 dz  dedede	e
ej        f         f
dZ	 ddej        deej                 dedej        fdZ xZS ) r   a  FAST as described in `"FAST: Faster Arbitrarily-Shaped Text Detector with Minimalist Kernel Representation"
    <https://arxiv.org/pdf/2111.02394.pdf>`_.

    Args:
        feat extractor: the backbone serving as feature extractor
        bin_thresh: threshold for binarization
        box_thresh: minimal objectness score to consider a box
        dropout_prob: dropout probability
        pooling_size: size of the pooling layer
        assume_straight_pages: if True, fit straight bounding boxes only
        exportable: onnx exportable returns only logits
        cfg: the configuration dict of the model
        class_names: list of class names
    rZ   r/   TFfeat_extractor
bin_thresh
box_threshdropout_probpooling_sizeassume_straight_pages
exportablecfgclass_namesr$   Nc
                    t                                                       |	| _        t          | j                  }
|| _        || _        || _        || _        | j        j        }| j        	                                | _        t          j                    5  |                     t          j        d                    }d |                                D             }d d d            n# 1 swxY w Y   |r| j                                        | _        t          |d         |d                   | _        t#          |d         |
|d         |          | _        t'          |||          | _        t+          j        |dz  dz   d|dz  dz            | _        |                                 D ]\  }}|                    d	          rt5          |t*          j                  rRt*          j                            |j        j        d
d           |j         |j         j        !                                 t5          |t*          j"                  r=|j        j        #                    d           |j         j        !                                 d S )N)r   r	       rn   c                 .    g | ]\  }}|j         d          S )r   )rA   )r)   _vs      r+   r,   z!FAST.__init__.<locals>.<listcomp>   s"     D D D1 D D Dr-   r   r   )ri   re   rf   r.   )r(   stridepaddingzfeat_extractor.fan_outrelu)r>   nonlinearityg      ?)$r1   r2   rl   lenrk   rj   ri   rd   trainingevalrJ   no_gradzerositemstrainr    neckrY   	prob_headr   postprocessorr   	MaxPool2dpoolingnamed_modules
startswith
isinstancer`   initkaiming_normal_weightdatar^   zero_BatchNorm2dfill_)r5   rd   re   rf   rg   rh   ri   rj   rk   rl   r[   _is_trainingoutfeat_out_channelsnmr6   s                   r+   r2   zFAST.__init__u   s    	&t/00$%:",*3"16688]__ 	E 	E%%ek.&A&ABBC D D		 D D D	E 	E 	E 	E 	E 	E 	E 	E 	E 	E 	E 	E 	E 	E 	E  	>"&"5";";"="=D .q13DQ3GHH	!"3B"7FWXYFZ\hii /"7J[e
 
 

 |0AA0EaZfjkZkpqYqrrr&&(( 
	$ 
	$DAq||-.. !RY'' $''ITZ'[[[6%FK%%'''Ar~.. $##C(((!!###
	$ 
	$s   AC((C,/C,path_or_urlkwargsc                 "    t          | |fi | dS )zLoad pretrained parameters onto the model

        Args:
            path_or_url: the path or URL to the model parameters (checkpoint)
            **kwargs: additional arguments to be passed to `doctr.models.utils.load_pretrained_params`
        N)r   )r5   r   r   s      r+   from_pretrainedzFAST.from_pretrained   s"     	t[;;F;;;;;r-   r7   targetreturn_model_outputreturn_predsc                                           |          fdt          t                              D                                            }t	          j                             |          |j        dd          d          }i } j        r||d<   |S |s||r4t          t          j                             |                              }|r||d<   ||r[t          j        j        dt          j        dt           t"          t$          t&          f                  f fd	            }	 |	|          |d
<   |                     ||          }
|
|d<   |S )Nc                 :    g | ]}t          |                   S rE   str)r)   idxfeatss     r+   r,   z FAST.forward.<locals>.<listcomp>   s#    >>>Ss3xx>>>r-   r:   r;   r<   logitsout_mapprob_mapr$   c                     fd                     |                                                                                     d                                                    D             S )Nc                 T    g | ]$}t          t          j        |                    %S rE   )dictrI   rl   )r)   predsr5   s     r+   r,   z6FAST.forward.<locals>._postprocess.<locals>.<listcomp>   s>        T-u5566  r-   )r   r.   r	   r   )r   detachcpupermutenumpy)r   r5   s    r+   _postprocessz"FAST.forward.<locals>._postprocess   sm       !%!3!3HOO4E4E4I4I4K4K4S4ST`4a4a4g4g4i4i!j!j   r-   r   loss)rd   rangerx   r   r?   r@   r   rA   rj   r   rJ   sigmoidr   compilerdisablerU   listr   r   r   compute_loss)r5   r7   r   r   r   feat_concatr   r   r   r   r   r   s   `          @r+   rO   zFAST.forward   sr    ##A&&>>>>E#e**,=,=>>>ii&&t~~k::T^___ ? 	"CMJ 	M&.L.'dll66J6J(K(KLLH 	&%C	N>\>^#u| T#s(^8L      $# (<11CL$$VV44DCK
r-   ư>r   epsc                    |                      ||j        dd                   }t          j        |d                   t          j        |d                   }}t          j        |d                                       |j                  }|                    |j                  |                    |j                  }}dt          j        dt          j        dt          j        dt          j        fd	t          | j                  dk    r@t          j	        |d
          }t          j	        | 
                    |          d
          }	n;t          j        |          }t          j        | 
                    |                    }	t          j        fdt          |	||          D             d                                          }
|
|	z  |z                      d          }|
|	|z   z                      d          }dd|z  ||z   z  z
                                  dz  }||z  }
|
|z  |z                      d          }|
||z   z                      d          }dd|z  ||z   z  z
                                  }||z   S )al  Compute fast loss, 2 x Dice loss where the text kernel loss is scaled by 0.5.

        Args:
            out_map: output feature map of the model of shape (N, num_classes, H, W)
            target: list of dictionary where each dict has a `boxes` and a `flags` entry
            eps: epsilon factor in dice loss

        Returns:
            A loss tensor
        r   Nr   r.   scoregtmaskr$   c           	      N   g }t          |j        d                   D ]O}t          t          j        ||         dk                        t          t          j        ||         dk    ||         dk    z                      z
  }t          t          j        ||         dk                        }t          t          |dz  |                    }|dk    s|dk    r|                    ||                    t          j        | |         ||         dk                        \  }}||dz
            }	| |         |	k    ||         dk    z  ||         dk    z  }
|                    |
           Qt          j        |          	                    d          
                                S )Nr         ?r	   r   )r   rA   rT   rJ   summinappendsortstack	unsqueezerb   )r   r   r   masks	class_idxpos_numneg_numneg_score_sortedrp   	thresholdselected_masks              r+   ohem_samplez&FAST.compute_loss.<locals>.ohem_sample   s   E"28A;// , ,	ei9(;<<==Ir)}s2tI#7MNOOA A  ei9(<==>>c'A+w7788a<<7a<<LLi111&+j%	2B2i=TWCW2X1X&Y&Y# !-gk::	"'	"2i"?ByMTWDW!X]abk]lor]r s]++++;u%%//2288:::r-   )dimc                 2    g | ]\  }}} |||          S rE   rE   )r)   r   r   r   r   s       r+   r,   z%FAST.compute_loss.<locals>.<listcomp>  s-    eeeoeR[[D))eeer-   )r   r.   r	   r   )build_targetrA   rJ   
from_numpytodevicerU   rx   rl   softmaxr   r   rK   rI   rb   r   r   )r5   r   r   r   targets
seg_targetseg_maskshrunken_kernelkernelsr   selected_masksintercardinality	text_losskernel_lossr   s                  @r+   r   zFAST.compute_loss   sh     ##FGM!"",=>>$/
;;U=MgVWj=Y=YH
*71:6699'.II)}}W^<<hkk'.>Y>YH
	;u| 	; 	;U\ 	;V[Vb 	; 	; 	; 	;* t  1$$mG333G}T\\'%:%:BBBHHmG,,G}T\\'%:%:;;H eeeeXz[cAdAdeeegh
 

%'' 	  (*Z7<<YGG%J)>?DDYOOUkC&788>>@@3F	 $h.')O;@@KK%?)BCHHSS1u9c(9::@@BB;&&r-   )NFF)r   )rP   rQ   rR   rS   r   r   rb   rT   boolr   r   r   r   r2   r   rJ   rU   npndarrayrO   r   rV   rW   s   @r+   r   r   e   s        $  !&*  ",6$ 6$/6$ 6$ 	6$
 6$ 6$  $6$ 6$ #s(^6$ #Y6$ 
6$ 6$ 6$ 6$ 6$ 6$p<3 <# <$ < < < < +/$)") )<) RZ 4') "	)
 ) 
c5<	 ) ) ) )^ 	@' @'@' RZ @' 	@'
 
@' @' @' @' @' @' @' @'r-   r   modelr$   c           
         d}d}|                                  D ]&}t          |d          r|                                 '|                                 D ]6\  }}t	          |t
          j                  r|#|j        }|j        |j        nt          j
        |j                  }|j        t          j        |j        |j        z             z  }t          j        ||                    |j        dddg          z            |_        t          j        ||j        z
  |z  |j        z             |_        || j        |<   t          j                    | j        |<   d}t	          |t
          j                  r|}|}'t+          |           8| S )zFuse batchnorm and conv layers and reparameterize the model

    Args:
        model: the FAST model to reparameterize

    Returns:
        the reparameterized model
    Nreparameterize_layerr   )moduleshasattrr   named_childrenr   r   r   r   r^   rJ   
zeros_likerunning_meansqrtrunning_varr   	Parameterreshaper#   _modulesIdentityr`   r   )	r   	last_convlast_conv_namemodulenamechildconv_wconv_bfactors	            r+   r   r   $  s    IN--// * *6122 	*'')))++-- " "eeR^,, 	" %F'0~'AY^^uGWX]XjGkGkF\EJu/@59/L$M$MMF!|FV^^YE[]^`acdDe5f5f,fggI\6E4F+F&*PSXS]*]^^IN-6EN>*#%;==EN4 IIry)) 	"I!NN5!!!!Lr-   Tarch
pretrainedbackbone_fnfeat_layerspretrained_backboneignore_keysr   c                    |o| }t           ||          d t          |          D                       }|                    dd           s+t          |                              dt          g          |d<   nt          |d                   |d<   t          |fdt          |          i|}|r]|d         t          |                              dt          g          k    r|nd }	|                    t          |          d         |	           |S )Nc                 4    i | ]\  }}|t          |          S rE   r   )r)   r   
layer_names      r+   
<dictcomp>z_fast.<locals>.<dictcomp>Y  s$    LLL/#zSXXLLLr-   rl   rk   r   )r   )r   	enumerategetr   r   sortedr   r   )
r   r   r   r   r   r   r   rd   r   _ignore_keyss
             r+   _fastr  K  s%    .@j. -'((LLY{5K5KLLL N
 ::mT** > ,T 2 6 6}zl S S} &vm'< = =}BB\$%7B6BBE S "-0L4F4J4J=[eZf4g4gggKKmq 	 	l407\RRRLr-   Fc                 6    t          d| t          g dfddgi|S )ao  FAST as described in `"FAST: Faster Arbitrarily-Shaped Text Detector with Minimalist Kernel Representation"
    <https://arxiv.org/pdf/2111.02394.pdf>`_, using a tiny TextNet backbone.

    >>> import torch
    >>> from doctr.models import fast_tiny
    >>> model = fast_tiny(pretrained=True)
    >>> input_tensor = torch.rand((1, 3, 1024, 1024), dtype=torch.float32)
    >>> out = model(input_tensor)

    Args:
        pretrained (bool): If True, returns a model pre-trained on our text detection dataset
        **kwargs: keyword arguments of the DBNet architecture

    Returns:
        text detection architecture
    r   3456r   prob_head.2.weight)r  r   r   r   s     r+   r   r   n  D    " 	 
 **   r-   c                 6    t          d| t          g dfddgi|S )ar  FAST as described in `"FAST: Faster Arbitrarily-Shaped Text Detector with Minimalist Kernel Representation"
    <https://arxiv.org/pdf/2111.02394.pdf>`_, using a small TextNet backbone.

    >>> import torch
    >>> from doctr.models import fast_small
    >>> model = fast_small(pretrained=True)
    >>> input_tensor = torch.rand((1, 3, 1024, 1024), dtype=torch.float32)
    >>> out = model(input_tensor)

    Args:
        pretrained (bool): If True, returns a model pre-trained on our text detection dataset
        **kwargs: keyword arguments of the DBNet architecture

    Returns:
        text detection architecture
    r   r  r   r	  )r  r   r
  s     r+   r   r     sD    " 	 
 **   r-   c                 6    t          d| t          g dfddgi|S )ao  FAST as described in `"FAST: Faster Arbitrarily-Shaped Text Detector with Minimalist Kernel Representation"
    <https://arxiv.org/pdf/2111.02394.pdf>`_, using a base TextNet backbone.

    >>> import torch
    >>> from doctr.models import fast_base
    >>> model = fast_base(pretrained=True)
    >>> input_tensor = torch.rand((1, 3, 1024, 1024), dtype=torch.float32)
    >>> out = model(input_tensor)

    Args:
        pretrained (bool): If True, returns a model pre-trained on our text detection dataset
        **kwargs: keyword arguments of the DBNet architecture

    Returns:
        text detection architecture
    r   r  r   r	  )r  r
   r
  s     r+   r   r     r  r-   )TN)F),collections.abcr   typingr   r   r   rJ   r   torch.nnr   r?   torchvision.models._utilsr   doctr.file_utilsr   classificationr
   r   r   modules.layersr   utilsr   r   baser   r   __all__r   r   r   __annotations__Moduler    
SequentialrY   r   r   r   r   r  r   r   r   rE   r-   r+   <module>r     sC   % $ $ $ $ $ $                  $ $ $ $ $ $ = = = = = = ' ' ' ' ' ' G G G G G G G G G G + + + + + + = = = = = = = = * * * * * * * *
L
L
L
 '%%]	  '%%^	  '%%]	 + +d3S#X&'   ,    ry   :# # # # #r} # # #2|' |' |' |' |'5") |' |' |'~$$* $t $ $ $ $X !%$(   
   4&")+,  c	 
   cT!    
       F $ # $    6 4 3 4    6 $ # $      r-   