o eiO@sdZddlZddlZddlmZddlmZddlmZddl m Z m Z m Z ddl mZdd lmZmZd d lmZeeZd ed efddZd.deeBdefddZGdddejZGdddejZGdddejZ GdddejZ!GdddejZ"Gdd d ejZ#Gd!d"d"ejZ$Gd#d$d$ejZ%eGd%d&d&eZ&eGd'd(d(e&Z'ed)d*Gd+d,d,e&Z(gd-Z)dS)/zPyTorch EfficientNet model.N)nn)initialization)ACT2FN)BaseModelOutputWithNoAttention(BaseModelOutputWithPoolingAndNoAttention$ImageClassifierOutputWithNoAttention)PreTrainedModel)auto_docstringlogging)EfficientNetConfigconfig num_channelscCsJ|j}||j9}t|t||d||}|d|kr!||7}t|S)z< Round number of filters based on depth multiplier. g?) depth_divisorwidth_coefficientmaxint)rrdivisornew_dimrt/home/ubuntu/transcripts/venv/lib/python3.10/site-packages/transformers/models/efficientnet/modeling_efficientnet.py round_filters$s   rT kernel_sizeadjustcCsnt|tr ||f}|dd|ddf}|r)|dd|d|dd|dfS|d|d|d|dfS)aJ Utility function to get the tuple padding value for the depthwise convolution. Args: kernel_size (`int` or `tuple`): Kernel size of the convolution layers. adjust (`bool`, *optional*, defaults to `True`): Adjusts padding value to apply to right and bottom sides of the input. rrr ) isinstancer)rrcorrectrrr correct_pad3s $rcs<eZdZdZdeffdd ZdejdejfddZZ S) EfficientNetEmbeddingszL A module that corresponds to the stem module of the original work. rcshtt|d|_tjdd|_tj|j|jddddd|_ tj |j|j |j d |_ t|j|_dS) N )rr rr paddingrrvalidFrstrider"bias)epsmomentum)super__init__rout_dimr ZeroPad2dr"Conv2dr convolution BatchNorm2dbatch_norm_epsbatch_norm_momentum batchnormr hidden_act activationselfr __class__rrr*Ls  zEfficientNetEmbeddings.__init__ pixel_valuesreturncCs,||}||}||}||}|SN)r"r.r2r4)r6r9featuresrrrforwardWs    zEfficientNetEmbeddings.forward) __name__ __module__ __qualname____doc__r r*torchTensorr= __classcell__rrr7rrGs rcs,eZdZ       dfdd ZZS) EfficientNetDepthwiseConv2dr rrTzerosc s*||} tj|| |||||||d dS)N) in_channels out_channelsrr%r"dilationgroupsr& padding_mode)r)r*) r6rGdepth_multiplierrr%r"rIr&rKrHr7rrr*as  z$EfficientNetDepthwiseConv2d.__init__)r rr rr TrF)r>r?r@r*rDrrr7rrE`srEcsHeZdZdZdedededeffdd Zdejd ej fd d Z Z S) EfficientNetExpansionLayerz_ This corresponds to the expansion phase of each block in the original implementation. rin_dimr+r%csBttj||dddd|_tj||jd|_t|j |_ dS)Nr sameFrGrHrr"r&) num_featuresr') r)r*rr- expand_convr/r0 expand_bnrr3 expand_act)r6rrNr+r%r7rrr*s z#EfficientNetExpansionLayer.__init__ hidden_statesr:cCs"||}||}||}|Sr;)rRrSrTr6rUrrrr=s   z"EfficientNetExpansionLayer.forward) r>r?r@rAr rr*rB FloatTensorrCr=rDrrr7rrMzs rMc sLeZdZdZdededededef fdd Zd ej d ej fd d Z Z S) EfficientNetDepthwiseLayerzk This corresponds to the depthwise convolution phase of each block in the original implementation. rrNr%radjust_paddingcsvt||_|jdkrdnd}t||d}tj|d|_t||||dd|_tj ||j |j d|_ t |j|_dS) Nrr#rO)rr!Fr$rQr'r()r)r*r%rrr,depthwise_conv_padrEdepthwise_convr/r0r1depthwise_normrr3 depthwise_act)r6rrNr%rrYconv_padr"r7rrr*s    z#EfficientNetDepthwiseLayer.__init__rUr:cCs6|jdkr ||}||}||}||}|S)Nr)r%r[r\r]r^rVrrrr=s     z"EfficientNetDepthwiseLayer.forward r>r?r@rAr rboolr*rBrWrCr=rDrrr7rrXsrXc sJeZdZdZd dedededeffdd Zd ej d ej fd d Z Z S)EfficientNetSqueezeExciteLayerzl This corresponds to the Squeeze and Excitement phase of each block in the original implementation. FrrN expand_dimexpandcst|r |n||_tdt||j|_tjdd|_ tj |j|jddd|_ tj |j|jddd|_ t |j|_t|_dS)Nr ) output_sizerO)rGrHrr")r)r*dimrrsqueeze_expansion_ratiodim_serAdaptiveAvgPool2dsqueezer-reducerdrr3 act_reduceSigmoid act_expand)r6rrNrcrdr7rrr*s$  z'EfficientNetSqueezeExciteLayer.__init__rUr:cCsF|}||}||}||}||}||}t||}|Sr;)rjrkrlrdrnrBmul)r6rUinputsrrrr=s      z&EfficientNetSqueezeExciteLayer.forward)Fr`rrr7rrbs rbc sVeZdZdZdedededededef fdd Zd e j d e j d e j fd dZ Z S)EfficientNetFinalBlockLayerz[ This corresponds to the final phase of each block in the original implementation. rrNr+r% drop_rateid_skipcsXt|dko | |_tj||dddd|_tj||j|jd|_ tj |d|_ dS)Nr rOFrPrZp) r)r* apply_dropoutrr- project_convr/r0r1 project_bnDropoutdropout)r6rrNr+r%rrrsr7rrr*s  z$EfficientNetFinalBlockLayer.__init__ embeddingsrUr:cCs0||}||}|jr||}||}|Sr;)rwrxrvrz)r6r{rUrrrr=s   z#EfficientNetFinalBlockLayer.forwardr>r?r@rAr rfloatrar*rBrWrCr=rDrrr7rrqs $rqcs\eZdZdZdededededededed ed effd d Zd e j de j fddZ Z S)EfficientNetBlocka This corresponds to the expansion and depthwise convolution phase of each block in the original implementation. Args: config ([`EfficientNetConfig`]): Model configuration class. in_dim (`int`): Number of input channels. out_dim (`int`): Number of output channels. stride (`int`): Stride size to be used in convolution layers. expand_ratio (`int`): Expand ratio to set the output dimensions for the expansion and squeeze-excite layers. kernel_size (`int`): Kernel size for the depthwise convolution layer. drop_rate (`float`): Dropout rate to be used in the final phase of each block. id_skip (`bool`): Whether to apply dropout and sum the final hidden states with the input embeddings during the final phase of each block. Set to `True` for the first block of each stage. adjust_padding (`bool`): Whether to apply padding to only right and bottom side of the input kernel before the depthwise convolution operation, set to `True` for inputs with odd input sizes. rrNr+r% expand_ratiorrrrsrYc st||_|jdk|_||} |jrt||| |d|_t||jr%| n|||| d|_t||| |jd|_ t ||jr>| n|||||d|_ dS)Nr )rrNr+r%)rrNr%rrY)rrNrcrd)rrNr+r%rrrs) r)r*rrdrM expansionrXr\rbsqueeze_exciterq projection) r6rrNr+r%rrrrrsrY expand_in_dimr7rrr*s4      zEfficientNetBlock.__init__rUr:cCs<|}|jdkr ||}||}||}|||}|S)Nr )rrr\rr)r6rUr{rrrr=Gs     zEfficientNetBlock.forwardr|rrr7rr~s,  )r~c sPeZdZdZdeffdd Z  ddejded Bd ed Bd e fd d Z Z S)EfficientNetEncoderz Forward propagates the embeddings through each EfficientNet block. Args: config ([`EfficientNetConfig`]): Model configuration class. rc snt|_|j_fddt|j}tfdd|jD}d}g}t|D]c}t ||j|}t ||j |}|j |} |j |} |j |} t|j|D]8} | dk} | dkradn| } | dkri|n|}||jv}|j||}t|||| | | || |d }|||d7}qUq+t|_tj|t |ddd d d _tj|j|j|jd _t|j_dS) Ncsttj|Sr;)rmathceildepth_coefficient)repeats)r6rr round_repeatsbsz3EfficientNetEncoder.__init__..round_repeatsc3s|]}|VqdSr;r).0n)rrr gsz/EfficientNetEncoder.__init__..rr ) rrNr+r%rrrrrsrYirOFrPrZ)r)r*rrlenrGsumnum_block_repeatsrangerrHstrides kernel_sizes expand_ratiosdepthwise_paddingdrop_connect_rater~appendr ModuleListblocksr-top_convr/ hidden_dimr0r1top_bnrr3top_activation)r6rnum_base_blocks num_blockscurr_block_numrirNr+r%rrjrsrYrrblockr7)rr6rr*]s\           zEfficientNetEncoder.__init__FTrUoutput_hidden_statesN return_dictr:cCst|r|fnd}|jD] }||}|r||f7}q ||}||}||}|s4tdd||fDSt||dS)Ncss|] }|dur|VqdSr;r)rvrrrrsz.EfficientNetEncoder.forward..)last_hidden_staterU)rrrrtupler)r6rUrrall_hidden_statesrrrrr=s     zEfficientNetEncoder.forward)FT) r>r?r@rAr r*rBrWrarr=rDrrr7rrTs:rc@s@eZdZUeed<dZdZdZdgZe de j fddZ d S) EfficientNetPreTrainedModelr efficientnetr9)imager~modulecCst|tjtjtjfr=tj|jd|jj d|j dur!t |j t |dddur?t |j t|jt |jdSdSdS)zInitialize the weightsg)meanstdN running_mean)rrLinearr-r/initnormal_weightrinitializer_ranger&zeros_getattrrones_ running_varnum_batches_tracked)r6rrrr _init_weightss    z)EfficientNetPreTrainedModel._init_weightsN)r>r?r@r __annotations__base_model_prefixmain_input_nameinput_modalities_no_split_modulesrBno_gradrModulerrrrrrs rc sZeZdZdeffdd Ze   d dejdBdedBdedBde e Bfd d Z Z S) EfficientNetModelrcs~t|||_t||_t||_|jdkr"tj |j dd|_ n|jdkr1tj |j dd|_ nt d|j|dS)NrT) ceil_moderz2config.pooling must be one of ['mean', 'max'] got )r)r*rrr{rencoder pooling_typer AvgPool2drpooler MaxPool2d ValueErrorpooling post_initr5r7rrr*s      zEfficientNetModel.__init__Nr9rrr:c Ks|dur|n|jj}|dur|n|jj}|durtd||}|j|||d}|d}||}||jdd}|sH||f|ddSt |||j dS)Nz You have to specify pixel_valuesrrrrr )r pooler_outputrU) rruse_return_dictrr{rrreshapeshaperrU) r6r9rrkwargsembedding_outputencoder_outputsr pooled_outputrrrr=s*   zEfficientNetModel.forward)NNN) r>r?r@r r*r rBrWrarrr=rDrrr7rrsrz EfficientNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for ImageNet. ) custom_introc s`eZdZfddZe    d dejdBdejdBdedBdedBde e Bf d d Z Z S) "EfficientNetForImageClassificationcsdt||j|_||_t||_tj|jd|_ |jdkr't |j |jnt |_ |dS)Nrtr)r)r* num_labelsrrrrry dropout_raterzrrIdentity classifierrr5r7rrr*s  $ z+EfficientNetForImageClassification.__init__Nr9labelsrrr:c Ks|dur|n|jj}|j|||d}|r|jn|d}||}||}d} |dur3||||j} |sI|f|dd} | durG| f| S| St| ||jdS)a labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*): Labels for computing the image classification/regression loss. Indices should be in `[0, ..., config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If `config.num_labels > 1` a classification loss is computed (Cross-Entropy). Nrr r)losslogitsrU) rrrrrzr loss_functionrrU) r6r9rrrroutputsrrroutputrrrr=s   z*EfficientNetForImageClassification.forward)NNNN) r>r?r@r*r rBrW LongTensorrarrr=rDrrr7rrs$  r)rrr)T)*rArrBrrr activationsrmodeling_outputsrrrmodeling_utilsr utilsr r configuration_efficientnetr get_loggerr>loggerrrrrarrrr-rErMrXrbrqr~rrrr__all__rrrrs<       ''!QZ9 3