sg]dZddlZddlmZmZmZddlZddlZddlmZddl m Z m Z m Z ddl mZddlmZmZmZdd lmZdd lmZmZmZmZd d lmZej8eZd ZdZ gdZ!dZ"dZ#dZ$dZ%dede&fdZ'd1dee&efde(fdZ)GddejTZ+GddejXZ-GddejTZ.Gdd ejTZ/Gd!d"ejTZ0Gd#d$ejTZ1Gd%d&ejTZ2Gd'd(ejTZ3Gd)d*eZ4ed+e$Gd,d-e4Z5ed.e$Gd/d0e4Z6y)2zPyTorch EfficientNet model.N)OptionalTupleUnion)nn)BCEWithLogitsLossCrossEntropyLossMSELoss)ACT2FN)BaseModelOutputWithNoAttention(BaseModelOutputWithPoolingAndNoAttention$ImageClassifierOutputWithNoAttention)PreTrainedModel)add_code_sample_docstringsadd_start_docstrings%add_start_docstrings_to_model_forwardlogging)EfficientNetConfigrzgoogle/efficientnet-b7)rirztabby, tabby cataN This model is a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass. Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and behavior. Parameters: config ([`EfficientNetConfig`]): Model configuration class with all the parameters of the model. Initializing with a config file does not load the weights associated with the model, only the configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights. aB Args: pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`): Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See [`AutoImageProcessor.__call__`] for details. output_hidden_states (`bool`, *optional*): Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for more detail. return_dict (`bool`, *optional*): Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple. config num_channelsc|j}||jz}t|t||dz z|z|z}|d|zkr||z }t|S)z< Round number of filters based on depth multiplier. g?) depth_divisorwidth_coefficientmaxint)rrdivisornew_dims i/var/www/html/venv/lib/python3.12/site-packages/transformers/models/efficientnet/modeling_efficientnet.py round_filtersr"Psf""GF,,,L'3|gk9:gEOPG|##7 w< kernel_sizeadjustct|tr||f}|ddz|ddzf}|r|ddz |d|ddz |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)r$r%corrects r! correct_padr)_s}+s#"K0 1~"KNa$78G  Q GAJNGAJGG GAJ GAJ??r#c`eZdZdZdeffd ZdejdejfdZxZ S)EfficientNetEmbeddingszL A module that corresponds to the stem module of the original work. rct|t|d|_t j d|_t j|j|jdddd|_ t j|j|j|j |_ t|j|_y) N )rrrrpaddingr rvalidFr$strider/bias)epsmomentum)super__init__r"out_dimr ZeroPad2dr/Conv2dr convolution BatchNorm2dbatch_norm_epsbatch_norm_momentum batchnormr hidden_act activationselfr __class__s r!r7zEfficientNetEmbeddings.__init__xs $VR0 ||L9 99   1QPW^c  &:O:OZ`ZtZtu !2!23r# pixel_valuesreturnc|j|}|j|}|j|}|j|}|SN)r/r;r?rA)rCrEfeaturess r!forwardzEfficientNetEmbeddings.forwardsA<< -##H->>(+??8,r#) __name__ __module__ __qualname____doc__rr7torchTensorrJ __classcell__rDs@r!r+r+ss0 41 4ELLU\\r#r+c.eZdZ dfd ZxZS)EfficientNetDepthwiseConv2dc @||z} t ||| ||||||| y)N) in_channels out_channelsr$r2r/dilationgroupsr3 padding_mode)r6r7) rCrVdepth_multiplierr$r2r/rXr3rZrWrDs r!r7z$EfficientNetDepthwiseConv2d.__init__s=#%55  #%#%  r#)rr rrrTzeros)rKrLrMr7rQrRs@r!rTrTs$   r#rTcleZdZdZdedededeffd Zdejdejfd Z xZ S) EfficientNetExpansionLayerz_ This corresponds to the expansion phase of each block in the original implementation. rin_dimr8r2ct|tj||ddd|_tj ||j |_t|j|_ y)NrsameFrVrWr$r/r3) num_featuresr4) r6r7rr: expand_convr<r= expand_bnr r@ expand_act)rCrr_r8r2rDs r!r7z#EfficientNetExpansionLayer.__init__sZ 99   W&BWBWX !2!23r# hidden_statesrFcl|j|}|j|}|j|}|SrH)rdrerfrCrgs r!rJz"EfficientNetExpansionLayer.forwards4((7 }5  6 r#) rKrLrMrNrrr7rO FloatTensorrPrJrQrRs@r!r^r^sH 41 43 4 4VY 4U%6%65<<r#r^c peZdZdZdededededef fd Zdejd ejfd Z xZ S) EfficientNetDepthwiseLayerzk This corresponds to the depthwise convolution phase of each block in the original implementation. rr_r2r$adjust_paddingcbt|||_|jdk(rdnd}t||}t j ||_t||||d|_t j||j|j|_ t|j|_y) Nrr0ra)r%r.Fr1rcr4r5)r6r7r2r)rr9depthwise_conv_padrTdepthwise_convr<r=r>depthwise_normr r@ depthwise_act) rCrr_r2r$rmconv_padr/rDs r!r7z#EfficientNetDepthwiseLayer.__init__s  "kkQ.7Fk.A"$,,w"?9  FHSX !nnV%:%:VE_E_ $F$5$56r#rgrFc|jdk(r|j|}|j|}|j|}|j |}|S)Nr)r2rprqrrrsris r!rJz"EfficientNetDepthwiseLayer.forwardsT ;;!  33MBM++M: ++M: **=9 r# rKrLrMrNrrboolr7rOrjrPrJrQrRs@r!rlrlsZ7"77 7  7  7, U%6%6 5<< r#rlc neZdZdZd dedededeffd Zdejdejfd Z xZ S) EfficientNetSqueezeExciteLayerzl This corresponds to the Squeeze and Excitement phase of each block in the original implementation. rr_ expand_dimexpandct||r|n||_tdt ||j z|_tjd|_ tj|j|j dd|_ tj|j |jdd|_ t|j|_tj |_y)Nr) output_sizera)rVrWr$r/)r6r7dimrrsqueeze_expansion_ratiodim_serAdaptiveAvgPool2dsqueezer:reducer{r r@ act_reduceSigmoid act_expand)rCrr_rzr{rDs r!r7z'EfficientNetSqueezeExciteLayer.__init__s !':V!S&*H*H!HIJ ++: ii   ii    !!2!23**,r#rgrFc|}|j|}|j|}|j|}|j|}|j |}t j ||}|SrH)rrrr{rrOmul)rCrginputss r!rJz&EfficientNetSqueezeExciteLayer.forwardsc ]3  M2  6  M2  6  &-8 r#)FrvrRs@r!ryrysH'1'3'C'Y]'* U%6%6 5<< r#ryc eZdZdZdedededededef fd Zd e jd e jd e jfd Z xZ S) EfficientNetFinalBlockLayerz[ This corresponds to the final phase of each block in the original implementation. rr_r8r2 drop_rateid_skipct||dk(xr| |_tj||ddd|_tj ||j|j|_ tj||_ y)NrraFrbrop) r6r7 apply_dropoutrr: project_convr<r=r> project_bnDropoutdropout)rCrr_r8r2rrrDs r!r7z$EfficientNetFinalBlockLayer.__init__sz #q[8[II   .. f&;&;fF`F` zzI. r# embeddingsrgrFc|j|}|j|}|jr|j|}||z}|SrH)rrrr)rCrrgs r!rJz#EfficientNetFinalBlockLayer.forward$sG))-8  6    LL7M)J6Mr#rKrLrMrNrrfloatrwr7rOrjrPrJrQrRs@r!rrsj/(/25/@C/MP/]b/mq/"%"3"3EDUDUZ_ZfZfr#rceZdZdZdededededededed ed effd Zd e jd e jfdZ xZ 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. rr_r8r2 expand_ratior$rrrmc tt |||_|jdk7rdnd|_||z} |jrt ||| ||_t ||jr| n|||| |_t||| |j|_ t||jr| n||||||_ y)NrTF)rr_r8r2)rr_r2r$rm)rr_rzr{)rr_r8r2rr) r6r7rr{r^ expansionrlrqrysqueeze_exciter projection) rCrr_r8r2rr$rrrm expand_in_dimrDs r!r7zEfficientNetBlock.__init__Js ("//14d% - ;;7fmFDN9$(KK=V#)  =&]4;; 6$(KK=V  r#rgrFc|}|jdk7r|j|}|j|}|j|}|j ||}|S)Nr)rrrqrr)rCrgrs r!rJzEfficientNetBlock.forwardss["    ! NN=9M++M: ++M:  MB r#rrRs@r!rr/s4' "' '  '  '  ' ' ' ' ' R U%6%6 5<< r#rc feZdZdZdeffd Z d dejdee dee de fdZ xZ S) EfficientNetEncoderz Forward propogates the embeddings through each EfficientNet block. Args: config ([`EfficientNetConfig`]): Model configuration class. rc t|_|j_fdt |j }t fd|jD}d}g}t|D]}t||j |}t||j|}|j|} |j|} |j|} t|j|D]k} | dk(rdnd} | dkDrdn| } | dkDr|n|}||jvrdnd}|j|z|z }t!|||| | | || | }|j#||dz }mt%j&|_t%j*t|ddd d _t%j.|j0|j2|j4 _t8|j:_y) NcZttjj|zSrH)rmathceildepth_coefficient)repeatsrCs r! round_repeatsz3EfficientNetEncoder.__init__..round_repeatss"tyy!7!7'!ABC Cr#c3.K|] }|ywrH).0nrs r! z/EfficientNetEncoder.__init__..sLaq)LsrTFr) rr_r8r2r$rrrrmirarbro)r6r7rrlenrVsumnum_block_repeatsranger"rWstrides kernel_sizes expand_ratiosdepthwise_paddingdrop_connect_raterappendr ModuleListblocksr:top_convr< hidden_dimr=r>top_bnr r@top_activation)rCrnum_base_blocks num_blockscurr_block_numrir_r8r2r$rjrrmrblockrrDs` @r!r7zEfficientNetEncoder.__init__s  !'!9!9 Df001L63K3KLL ' $A"66+=+=a+@AF#FF,?,?,BCG^^A&F --a0K!//2L=)A)A!)DEF $"#q&$e!e$%Ev*8F.sXq!-Xs)last_hidden_staterg)rrrrtupler )rCrgrrall_hidden_statesrs r!rJzEfficientNetEncoder.forwards 1E],$[[ 6E!-0M#!m%55! 6  m4  M2 ++M: X]4E$FXX X-++  r#)FT) rKrLrMrNrr7rOrjrrwr rJrQrRs@r!rrsW58158t05&*  (( 'tn d^  (  r#rc&eZdZdZeZdZdZgZdZ y)EfficientNetPreTrainedModelz An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained models. efficientnetrEct|tjtjfrm|jj j d|jj|j%|jj jyyt|tjrJ|jj j|jj jdyy)zInitialize the weightsg)meanstdNg?) r'rLinearr:weightdatanormal_rinitializer_ranger3zero_ LayerNormfill_)rCmodules r! _init_weightsz)EfficientNetPreTrainedModel._init_weightss fryy"))4 5 MM   & &CT[[5R5R & S{{&   &&('  - KK   " " $ MM   $ $S ).r#N) rKrLrMrNr config_classbase_model_prefixmain_input_name_no_split_modulesrrr#r!rrs$ &L&$O *r#rzUThe bare EfficientNet model outputting raw features without any specific head on top.c eZdZdeffd Zeeeee e de  d de jdeedeedeee ffd ZxZS) EfficientNetModelrct||||_t||_t ||_|jdk(r'tj|jd|_ nN|jdk(r'tj|jd|_ ntd|j|jy)NrT) ceil_moderz2config.pooling must be one of ['mean', 'max'] got )r6r7rr+rrencoder pooling_typer AvgPool2drpooler MaxPool2d ValueErrorpooling post_initrBs r!r7zEfficientNetModel.__init__s   08*62    & (,,v'8'8DIDK  E ),,v'8'8DIDKQRXR`R`Qabc c r#vision) checkpoint output_typermodalityexpected_outputrErrrFc~||n|jj}||n|jj}| td|j |}|j |||}|d}|j |}|j|jdd}|s ||f|ddzSt|||jS)Nz You have to specify pixel_valuesrrrrr)r pooler_outputrg) rruse_return_dictrrrrreshapeshaper rg)rCrErrembedding_outputencoder_outputsr pooled_outputs r!rJzEfficientNetModel.forwards%9$D $++JjJj &1%> ? " J" r#rz EfficientNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for ImageNet. ceZdZfdZeeeeee e  d de jde e jde ede edeeeff dZxZS) "EfficientNetForImageClassificationct|||j|_||_t ||_t j|j|_ |jdkDr*t j|j|jnt j|_ |jy)Nrr)r6r7 num_labelsrrrrr dropout_raterrrIdentity classifierrrBs r!r7z+EfficientNetForImageClassification.__init__=s   ++ -f5zzF$7$78 KO??]^K^"))F$5$5tGdfdododq r#)rrrrrElabelsrrrFc:||n|jj}|j|||}|r |jn|d}|j |}|j |}d}||jj |jdk(rd|j_nl|jdkDrL|jtjk(s|jtjk(rd|j_nd|j_|jj dk(rIt} |jdk(r&| |j|j}n| ||}n|jj dk(r=t} | |jd|j|jd}n,|jj dk(rt!} | ||}|s|f|ddz} ||f| zS| St#|||j$ S) 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 regressionsingle_label_classificationmulti_label_classificationr)losslogitsrg)rrrrrr problem_typerdtyperOlongrr rrviewrrrg) rCrErrroutputsrrrloss_fctoutputs r!rJz*EfficientNetForImageClassification.forwardIs(&1%r&s" )) AA! . ;   H %'/'31  ! , C @U3:.@@(RYY2 ")) 44$$N$RYY$N"))BN NbW "))W t*/*0[ < 3< < ~! H )DH H r#