U ,-e;{@s*dZddlZddlmZmZmZmZddlZddlZddlm Z ddl m Z ddl m Z mZddlmZdd lmZmZdd lmZmZmZmZmZd d lmZeeZd ZdZ d dddgZ!dgZ"d=ej#e$e%ej#dddZ&Gddde j'Z(Gddde j'Z)Gddde j'Z*Gddde j'Z+Gdd d e j'Z,Gd!d"d"e j'Z-Gd#d$d$e j'Z.Gd%d&d&e j'Z/Gd'd(d(e j'Z0Gd)d*d*eZ1d+Z2d,Z3ed-e2Gd.d/d/e1Z4Gd0d1d1e j'Z5Gd2d3d3e j'Z6Gd4d5d5e j'Z7Gd6d7d7e j'Z8Gd8d9d9e j'Z9ed:e2Gd;d<dz PyTorch GLPN model.N)ListOptionalTupleUnion)nn)ACT2FN)BaseModelOutputDepthEstimatorOutput)PreTrainedModel) find_pruneable_heads_and_indicesprune_linear_layer)add_code_sample_docstringsadd_start_docstrings%add_start_docstrings_to_model_forwardloggingreplace_return_docstrings) GLPNConfigrzvinvino02/glpn-kittiiF)input drop_probtrainingreturncCsd|dks |s|Sd|}|jdfd|jd}|tj||j|jd}||||}|S)aF Drop paths (Stochastic Depth) per sample (when applied in main path of residual blocks). Comment by Ross Wightman: This is the same as the DropConnect impl I created for EfficientNet, etc networks, however, the original name is misleading as 'Drop Connect' is a different form of dropout in a separate paper... See discussion: https://github.com/tensorflow/tpu/issues/494#issuecomment-532968956 ... I've opted for changing the layer and argument names to 'drop path' rather than mix DropConnect as a layer name and use 'survival rate' as the argument. rrr)r)dtypedevice)shapendimtorchZrandrrZfloor_div)rrrZ keep_probrZ random_tensoroutputr#g/var/www/html/Darija-Ai-Train/env/lib/python3.8/site-packages/transformers/models/glpn/modeling_glpn.py drop_path8s r%csPeZdZdZd eeddfdd ZejejdddZ e d d d Z Z S) GLPNDropPathzXDrop paths (Stochastic Depth) per sample (when applied in main path of residual blocks).N)rrcst||_dSN)super__init__r)selfr __class__r#r$r)Ps zGLPNDropPath.__init__ hidden_statesrcCst||j|jSr')r%rr)r*r.r#r#r$forwardTszGLPNDropPath.forward)rcCs d|jS)Nzp={})formatr)r*r#r#r$ extra_reprWszGLPNDropPath.extra_repr)N) __name__ __module__ __qualname____doc__rfloatr)r Tensorr/strr1 __classcell__r#r#r+r$r&Msr&cs(eZdZdZfddZddZZS)GLPNOverlapPatchEmbeddingsz+Construct the overlapping patch embeddings.cs4ttj|||||dd|_t||_dS)N kernel_sizestridepadding)r(r)rConv2dproj LayerNorm layer_norm)r* patch_sizer> num_channels hidden_sizer+r#r$r)_s z#GLPNOverlapPatchEmbeddings.__init__cCs>||}|j\}}}}|ddd}||}|||fS)Nr;r)rArflatten transposerC)r* pixel_values embeddings_heightwidthr#r#r$r/ks   z"GLPNOverlapPatchEmbeddings.forwardr2r3r4r5r)r/r9r#r#r+r$r:\s r:cs2eZdZdZfddZddZd ddZZS) GLPNEfficientSelfAttentionzSegFormer's efficient self-attention mechanism. Employs the sequence reduction process introduced in the [PvT paper](https://arxiv.org/abs/2102.12122).cst||_||_|j|jdkr@td|jd|jdt|j|j|_|j|j|_t |j|j|_ t |j|j|_ t |j|j|_ t |j|_||_|dkrtj||||d|_t||_dS)NrzThe hidden size (z6) is not a multiple of the number of attention heads ()r)r=r>)r(r)rFnum_attention_heads ValueErrorintattention_head_size all_head_sizerLinearquerykeyvalueDropoutZattention_probs_dropout_probdropoutsr_ratior@srrBrCr*configrFrQsequence_reduction_ratior+r#r$r)zs, z#GLPNEfficientSelfAttention.__init__cCs6|dd|j|jf}||}|ddddS)Nrr;rr)sizerQrTviewpermute)r*r.Z new_shaper#r#r$transpose_for_scoress z/GLPNEfficientSelfAttention.transpose_for_scoresFcCs$|||}|jdkrl|j\}}}|ddd||||}||}|||dddd}||}|||} || |} t || dd} | t |j} tjj| dd} || } t | | } | dddd} | dd|jf}| |} |r| | fn| f}|S)Nrrr;radimr)rerWr\rrdreshaper]rCrXrYr matmulrHmathsqrtrTrZ functionalZsoftmaxr[ contiguousrbrUrc)r*r.rLrMoutput_attentionsZ query_layer batch_sizeseq_lenrEZ key_layerZ value_layerZattention_scoresZattention_probsZ context_layerZnew_context_layer_shapeoutputsr#r#r$r/s&       z"GLPNEfficientSelfAttention.forward)F)r2r3r4r5r)rer/r9r#r#r+r$rOvs   rOcs$eZdZfddZddZZS)GLPNSelfOutputcs*tt|||_t|j|_dSr')r(r)rrVdenserZhidden_dropout_probr[)r*r_rFr+r#r$r)s zGLPNSelfOutput.__init__cCs||}||}|Sr')rsr[)r*r.Z input_tensorr#r#r$r/s  zGLPNSelfOutput.forwardr2r3r4r)r/r9r#r#r+r$rrs rrcs.eZdZfddZddZdddZZS) GLPNAttentioncs6tt||||d|_t||d|_t|_dS)N)r_rFrQr`)rF)r(r)rOr*rrr"set pruned_headsr^r+r#r$r)s zGLPNAttention.__init__cCst|dkrdSt||jj|jj|j\}}t|jj||j_t|jj||j_t|jj ||j_ t|j j |dd|j _ |jjt||j_|jj|jj|j_ |j ||_dS)Nrrrg)lenr r*rQrTrxr rWrXrYr"rsrUunion)r*headsindexr#r#r$ prune_headss zGLPNAttention.prune_headsFcCs6|||||}||d|}|f|dd}|S)Nrr)r*r")r*r.rLrMrnZ self_outputsattention_outputrqr#r#r$r/szGLPNAttention.forward)F)r2r3r4r)r}r/r9r#r#r+r$rvs rvcs&eZdZdfdd ZddZZS) GLPNDWConvc s(ttj||dddd|d|_dS)NrrT)biasgroups)r(r)rr@dwconv)r*rhr+r#r$r)s zGLPNDWConv.__init__cCsD|j\}}}|dd||||}||}|ddd}|S)Nrr;)rrHrcrrG)r*r.rLrMrorprEr#r#r$r/s   zGLPNDWConv.forward)rrur#r#r+r$rsrcs&eZdZdfdd ZddZZS) GLPNMixFFNNcslt|p|}t|||_t||_t|jt rDt |j|_ n|j|_ t|||_ t |j|_dSr')r(r)rrVdense1rr isinstanceZ hidden_actr8rintermediate_act_fndense2rZrtr[)r*r_ in_featureshidden_featuresZ out_featuresr+r#r$r) s   zGLPNMixFFN.__init__cCsD||}||||}||}||}||}||}|Sr')rrrr[r)r*r.rLrMr#r#r$r/s     zGLPNMixFFN.forward)NNrur#r#r+r$r s rcs*eZdZdZfddZdddZZS) GLPNLayerzCThis corresponds to the Block class in the original implementation.csntt||_t||||d|_|dkr8t|nt|_ t||_ t ||}t |||d|_ dS)N)rFrQr`r)rr)r(r)rrB layer_norm_1rv attentionr&Identityr% layer_norm_2rSrmlp)r*r_rFrQr%r` mlp_ratioZmlp_hidden_sizer+r#r$r)&s    zGLPNLayer.__init__Fc Csr|j|||||d}|d}|dd}||}||}|||||}||}||} | f|}|S)N)rnrr)rrr%rr) r*r.rLrMrnZself_attention_outputsr~rqZ mlp_outputZ layer_outputr#r#r$r/4s    zGLPNLayer.forward)FrNr#r#r+r$r#s rcs&eZdZfddZdddZZS) GLPNEncoderc sTt|_ddtdjtjD}g}tj D]D}| t j |j ||dkrfjn j|dj|dq>t||_g}d}tj D]}g}|dkr|j|d7}tj|D]>}| tj|j||||j|j|dq| t|qt||_tfddtj D|_dS)NcSsg|] }|qSr#)item).0xr#r#r$ Tsz(GLPNEncoder.__init__..rr)rDr>rErF)rFrQr%r`rcsg|]}tj|qSr#)rrB hidden_sizes)rir_r#r$r|s)r(r)r_r ZlinspaceZdrop_path_ratesumZdepthsrangeZnum_encoder_blocksappendr:Z patch_sizesstridesrErr ModuleListpatch_embeddingsrrQZ sr_ratiosZ mlp_ratiosblockrC) r*r_ZdprrJrblockscurZlayersjr+rr$r)OsH      zGLPNEncoder.__init__FTcCs|rdnd}|rdnd}|jd}|}tt|j|j|jD]\} } | \} } } | |\}}}t| D]0\}}|||||}|d}|rd||df}qd| |}||||ddddd}|r<||f}q<|st dd|||fDSt |||d S) Nr#rrrarr;css|]}|dk r|VqdSr'r#)rvr#r#r$ sz&GLPNEncoder.forward..Zlast_hidden_stater. attentions) r enumerateziprrrCrirdrmtupler )r*rIrnoutput_hidden_states return_dictZall_hidden_statesZall_self_attentionsror.idxrZembedding_layerZ block_layerZ norm_layerrLrMrZblkZ layer_outputsr#r#r$r/s.      zGLPNEncoder.forward)FFTrur#r#r+r$rNs  3rc@s$eZdZdZeZdZdZddZdS)GLPNPreTrainedModelz An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained models. glpnrIcCst|tjtjfr@|jjjd|jjd|j dk r|j j nft|tj r|jjjd|jjd|j dk r|jj|j  n&t|tj r|j j |jjddS)zInitialize the weightsr)meanZstdNg?)rrrVr@weightdataZnormal_r_Zinitializer_rangerZzero_Z EmbeddingZ padding_idxrBZfill_)r*moduler#r#r$ _init_weightss     z!GLPNPreTrainedModel._init_weightsN) r2r3r4r5r config_classZbase_model_prefixZmain_input_namerr#r#r#r$rs raG This model is a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) sub-class. Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and behavior. Parameters: config ([`GLPNConfig`]): 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. aG Args: pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`): Pixel values. Padding will be ignored by default should you provide it. Pixel values can be obtained using [`AutoImageProcessor`]. See [`GLPNImageProcessor.__call__`] for details. output_attentions (`bool`, *optional*): Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned tensors for more detail. 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. zfThe bare GLPN encoder (Mix-Transformer) outputting raw hidden-states without any specific head on top.c sreZdZfddZddZeedee e e de dd e jeeeeeeeee fd d d ZZS) GLPNModelcs(t|||_t||_|dSr')r(r)r_rencoder post_initr*r_r+r#r$r)s  zGLPNModel.__init__cCs*|D]\}}|jj|j|qdS)z Prunes heads of the model. heads_to_prune: dict of {layer_num: list of heads to prune in this layer} See base class PreTrainedModel N)itemsrlayerrr})r*Zheads_to_prunerr{r#r#r$ _prune_headsszGLPNModel._prune_headsz(batch_size, sequence_length)Zvision) checkpoint output_typerZmodalityZexpected_outputN)rIrnrrrcCs~|dk r |n|jj}|dk r |n|jj}|dk r4|n|jj}|j||||d}|d}|sl|f|ddSt||j|jdS)Nrnrrrrr)r_rnruse_return_dictrr r.r)r*rIrnrrZencoder_outputsZsequence_outputr#r#r$r/s$zGLPNModel.forward)NNN)r2r3r4r)rrGLPN_INPUTS_DOCSTRINGr0r_CHECKPOINT_FOR_DOCr _CONFIG_FOR_DOC_EXPECTED_OUTPUT_SHAPEr FloatTensorrboolrrr/r9r#r#r+r$rs(    rcs*eZdZdZdfdd ZddZZS)GLPNSelectiveFeatureFusionz Selective Feature Fusion module, as explained in the [paper](https://arxiv.org/abs/2201.07436) (section 3.4). This module adaptively selects and integrates local and global features by attaining an attention map for each feature. @c stttjt|d|ddddt|t|_ttj|t|dddddtt|dt|_ tjt|dddddd|_ t |_ dS)Nr;rr) in_channels out_channelsr=r>r?) r(r)r Sequentialr@rSZ BatchNorm2dReLUconvolutional_layer1convolutional_layer2convolutional_layer3ZSigmoidsigmoid)r*Z in_channelr+r#r$r)%s&  z#GLPNSelectiveFeatureFusion.__init__cCstj||fdd}||}||}||}||}||dddddddfd||dddddddfd}|S)Nrrgr)r catrrrrZ unsqueeze)r*Zlocal_featuresZglobal_featuresfeaturesZattnZhybrid_featuresr#r#r$r/:s    .z"GLPNSelectiveFeatureFusion.forward)rrNr#r#r+r$rsrcs&eZdZfddZdddZZS)GLPNDecoderStagecsPt||k}|s&tj||ddnt|_t||_tjdddd|_ dS)Nr)r=r;bilinearFZ scale_factormodeZ align_corners) r(r)rr@r convolutionrfusionUpsampleupsample)r*rr should_skipr+r#r$r)Ls   zGLPNDecoderStage.__init__NcCs,||}|dk r|||}||}|Sr')rrr)r* hidden_stateZresidualr#r#r$r/Ss   zGLPNDecoderStage.forward)Nrur#r#r+r$rKs rcs8eZdZfddZeejeejdddZZS) GLPNDecodercs\t|jddd}|jtfdd|D|_d|jd_tjdddd|_ dS) Nracsg|]}t|qSr#)r)rrFrr#r$rgsz(GLPNDecoder.__init__..rr;rFr) r(r)rdecoder_hidden_sizerrstagesrrfinal_upsample)r*r_Zreserved_hidden_sizesr+rr$r)`s  zGLPNDecoder.__init__r-cCsNg}d}t|ddd|jD]\}}|||}||q|||d<|S)Nra)rrrr)r*r.Zstage_hidden_statesZstage_hidden_staterZstager#r#r$r/ns  zGLPNDecoder.forward r2r3r4r)rr r7r/r9r#r#r+r$r_s rcs*eZdZdZdfdd ZddZZS) SiLogLossz Implements the Scale-invariant log scale loss [Eigen et al., 2014](https://arxiv.org/abs/1406.2283). $$L=\frac{1}{n} \sum_{i} d_{i}^{2}-\frac{1}{2 n^{2}}\left(\sum_{i} d_{i}^{2}\right)$$ where $d_{i}=\log y_{i}-\log y_{i}^{*}$. ?cst||_dSr')r(r)lambd)r*rr+r#r$r)s zSiLogLoss.__init__cCsX|dk}t||t||}tt|d|jt|d}|S)Nrr;)detachr logrlpowrr)r*predtargetZ valid_maskZdiff_loglossr#r#r$r/s ,zSiLogLoss.forward)rrNr#r#r+r$rzsrcs4eZdZfddZeejejdddZZS)GLPNDepthEstimationHeadc sRt||_|j}ttj||ddddtjddtj|ddddd|_dS)Nrrr<F)Zinplace) r(r)r_rrrr@rhead)r*r_Zchannelsr+r#r$r)s  z GLPNDepthEstimationHead.__init__r-cCs8||jj}||}t||jj}|jdd}|S)Nrrg)r_Z head_in_indexrr r max_depthZsqueeze)r*r.predicted_depthr#r#r$r/s    zGLPNDepthEstimationHead.forwardrr#r#r+r$rs rz]GLPN Model transformer with a lightweight depth estimation head on top e.g. for KITTI, NYUv2.c sreZdZfddZeedeee dd e j e e j e e e e e e eee jefdddZZS) GLPNForDepthEstimationcs6t|t||_t||_t||_|dSr') r(r)rrrdecoderrrrrr+r#r$r)s     zGLPNForDepthEstimation.__init__zbatch_size, sequence_length)rrN)rIlabelsrnrrrc Cs|dk r |n|jj}|dk r |n|jj}|j||d|d}|rD|jn|d}||}||} d} |dk r|t} | | |} |s|r| f|dd} n| f|dd} | dk r| f| S| St| | |r|jnd|j dS)a labels (`torch.FloatTensor` of shape `(batch_size, height, width)`, *optional*): Ground truth depth estimation maps for computing the loss. Returns: Examples: ```python >>> from transformers import AutoImageProcessor, GLPNForDepthEstimation >>> import torch >>> import numpy as np >>> from PIL import Image >>> import requests >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg" >>> image = Image.open(requests.get(url, stream=True).raw) >>> image_processor = AutoImageProcessor.from_pretrained("vinvino02/glpn-kitti") >>> model = GLPNForDepthEstimation.from_pretrained("vinvino02/glpn-kitti") >>> # prepare image for the model >>> inputs = image_processor(images=image, return_tensors="pt") >>> with torch.no_grad(): ... outputs = model(**inputs) ... predicted_depth = outputs.predicted_depth >>> # interpolate to original size >>> prediction = torch.nn.functional.interpolate( ... predicted_depth.unsqueeze(1), ... size=image.size[::-1], ... mode="bicubic", ... align_corners=False, ... ) >>> # visualize the prediction >>> output = prediction.squeeze().cpu().numpy() >>> formatted = (output * 255 / np.max(output)).astype("uint8") >>> depth = Image.fromarray(formatted) ```NTrrr;)rrr.r) r_rrrr.rrrr r) r*rIrrnrrrqr.outrrZloss_fctr"r#r#r$r/s63    zGLPNForDepthEstimation.forward)NNNN)r2r3r4r)rrr0rr rr rrrrrr7r/r9r#r#r+r$rs  r)rF);r5rktypingrrrrr Ztorch.utils.checkpointrZ activationsrZmodeling_outputsr r Zmodeling_utilsr Z pytorch_utilsr r utilsrrrrrZconfiguration_glpnrZ get_loggerr2loggerrrrZ"GLPN_PRETRAINED_MODEL_ARCHIVE_LISTr7r6rr%Moduler&r:rOrrrvrrrrrZGLPN_START_DOCSTRINGrrrrrrrrr#r#r#r$sZ      R '+X <,