

from ...configuration_utils import PretrainedConfig
from ...utils import logging


_UpperCAmelCase		:   Dict										=       logging.get_logger(__name__)

_UpperCAmelCase		:   Dict										=       {
    """SCUT-DLVCLab/lilt-roberta-en-base""": (
        """https://huggingface.co/SCUT-DLVCLab/lilt-roberta-en-base/resolve/main/config.json"""
    ),
}







class  lowercase				(       lowercase_			):
				__SCREAMING_SNAKE_CASE					: int       			=			'''lilt'''




				def __init__(					self      ,   snake_case=3_0522      ,   snake_case=768      ,   snake_case=12      ,   snake_case=12      ,   snake_case=3072      ,   snake_case="gelu"      ,   snake_case=0.1      ,   snake_case=0.1      ,   snake_case=512      ,   snake_case=2      ,   snake_case=0.02      ,   snake_case=1e-1_2      ,   snake_case=0      ,   snake_case="absolute"      ,   snake_case=None      ,   snake_case=4      ,   snake_case=1024      ,   **snake_case      ,   ):
											super().__init__(pad_token_id=snake_case      ,   **snake_case       )

											snake_case_							=    vocab_size
											snake_case_							=    hidden_size
											snake_case_							=    num_hidden_layers
											snake_case_							=    num_attention_heads
											snake_case_							=    hidden_act
											snake_case_							=    intermediate_size
											snake_case_							=    hidden_dropout_prob
											snake_case_							=    attention_probs_dropout_prob
											snake_case_							=    max_position_embeddings
											snake_case_							=    type_vocab_size
											snake_case_							=    initializer_range
											snake_case_							=    layer_norm_eps
											snake_case_							=    position_embedding_type
											snake_case_							=    classifier_dropout
											snake_case_							=    channel_shrink_ratio
											snake_case_							=    max_ad_position_embeddings







from typing import Optional

import torch
import torch.utils.checkpoint
from torch import Tensor, nn
from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss

from ...activations import ACTaFN
from ...modeling_outputs import (
    BackboneOutput,
    BaseModelOutputWithNoAttention,
    BaseModelOutputWithPoolingAndNoAttention,
    ImageClassifierOutputWithNoAttention,
)
from ...modeling_utils import PreTrainedModel
from ...utils import (
    add_code_sample_docstrings,
    add_start_docstrings,
    add_start_docstrings_to_model_forward,
    logging,
    replace_return_docstrings,
)
from ...utils.backbone_utils import BackboneMixin
from .configuration_resnet import ResNetConfig


_UpperCAmelCase		:   Optional[Any]										=       logging.get_logger(__name__)

# General docstring
_UpperCAmelCase		:   Dict										=       """ResNetConfig"""

# Base docstring
_UpperCAmelCase		:   Optional[int]										=       """microsoft/resnet-50"""
_UpperCAmelCase		:   Optional[Any]										=       [1, 2048, 7, 7]

# Image classification docstring
_UpperCAmelCase		:   Tuple										=       """microsoft/resnet-50"""
_UpperCAmelCase		:   int										=       """tiger cat"""

_UpperCAmelCase		:   Optional[Any]										=       [
    """microsoft/resnet-50""",
    # See all resnet models at https://huggingface.co/models?filter=resnet
]







class  lowercase				(       nn.Module			):




				def __init__(					self      ,   snake_case      ,   snake_case      ,   snake_case = 3      ,   snake_case = 1      ,   snake_case = "relu"       ):
											super().__init__()
											snake_case_							=    nn.Convad(
											    snake_case      ,   snake_case      ,   kernel_size=snake_case      ,   stride=snake_case      ,   padding=kernel_size // 2      ,   bias=snake_case       )
											snake_case_							=    nn.BatchNormad(snake_case       )
											snake_case_							=    ACTaFN[activation] if activation is not None else nn.Identity()




				def     a							(					self      ,   snake_case       ):
											snake_case_							=    self.convolution(snake_case       )
											snake_case_							=    self.normalization(snake_case       )
											snake_case_							=    self.activation(snake_case       )
											return hidden_state







class  lowercase				(       nn.Module			):




				def __init__(					self      ,   snake_case       ):
											super().__init__()
											snake_case_							=    ResNetConvLayer(
											    config.num_channels      ,   config.embedding_size      ,   kernel_size=7      ,   stride=2      ,   activation=config.hidden_act       )
											snake_case_							=    nn.MaxPoolad(kernel_size=3      ,   stride=2      ,   padding=1       )
											snake_case_							=    config.num_channels




				def     a							(					self      ,   snake_case       ):
											snake_case_							=    pixel_values.shape[1]
											if num_channels != self.num_channels:
																		raise ValueError(
																		    'Make sure that the channel dimension of the pixel values match with the one set in the configuration.'       )
											snake_case_							=    self.embedder(snake_case       )
											snake_case_							=    self.pooler(snake_case       )
											return embedding







class  lowercase				(       nn.Module			):




				def __init__(					self      ,   snake_case      ,   snake_case      ,   snake_case = 2       ):
											super().__init__()
											snake_case_							=    nn.Convad(snake_case      ,   snake_case      ,   kernel_size=1      ,   stride=snake_case      ,   bias=snake_case       )
											snake_case_							=    nn.BatchNormad(snake_case       )




				def     a							(					self      ,   snake_case       ):
											snake_case_							=    self.convolution(snake_case       )
											snake_case_							=    self.normalization(snake_case       )
											return hidden_state







class  lowercase				(       nn.Module			):




				def __init__(					self      ,   snake_case      ,   snake_case      ,   snake_case = 1      ,   snake_case = "relu"       ):
											super().__init__()
											snake_case_							=    in_channels != out_channels or stride != 1
											snake_case_							=    (
											    ResNetShortCut(snake_case      ,   snake_case      ,   stride=snake_case       ) if should_apply_shortcut else nn.Identity()
											)
											snake_case_							=    nn.Sequential(
											    ResNetConvLayer(snake_case      ,   snake_case      ,   stride=snake_case       )      ,   ResNetConvLayer(snake_case      ,   snake_case      ,   activation=snake_case       )      ,   )
											snake_case_							=    ACTaFN[activation]




				def     a							(					self      ,   snake_case       ):
											snake_case_							=    hidden_state
											snake_case_							=    self.layer(snake_case       )
											snake_case_							=    self.shortcut(snake_case       )
											hidden_state += residual
											snake_case_							=    self.activation(snake_case       )
											return hidden_state







class  lowercase				(       nn.Module			):




				def __init__(					self      ,   snake_case      ,   snake_case      ,   snake_case = 1      ,   snake_case = "relu"      ,   snake_case = 4       ):
											super().__init__()
											snake_case_							=    in_channels != out_channels or stride != 1
											snake_case_							=    out_channels // reduction
											snake_case_							=    (
											    ResNetShortCut(snake_case      ,   snake_case      ,   stride=snake_case       ) if should_apply_shortcut else nn.Identity()
											)
											snake_case_							=    nn.Sequential(
											    ResNetConvLayer(snake_case      ,   snake_case      ,   kernel_size=1       )      ,   ResNetConvLayer(snake_case      ,   snake_case      ,   stride=snake_case       )      ,   ResNetConvLayer(snake_case      ,   snake_case      ,   kernel_size=1      ,   activation=snake_case       )      ,   )
											snake_case_							=    ACTaFN[activation]




				def     a							(					self      ,   snake_case       ):
											snake_case_							=    hidden_state
											snake_case_							=    self.layer(snake_case       )
											snake_case_							=    self.shortcut(snake_case       )
											hidden_state += residual
											snake_case_							=    self.activation(snake_case       )
											return hidden_state







class  lowercase				(       nn.Module			):




				def __init__(					self      ,   snake_case      ,   snake_case      ,   snake_case      ,   snake_case = 2      ,   snake_case = 2      ,   ):
											super().__init__()

											snake_case_							=    ResNetBottleNeckLayer if config.layer_type == 'bottleneck' else ResNetBasicLayer

											snake_case_							=    nn.Sequential(
											    # downsampling is done in the first layer with stride of 2
											    layer(snake_case      ,   snake_case      ,   stride=snake_case      ,   activation=config.hidden_act       )      ,   *[layer(snake_case      ,   snake_case      ,   activation=config.hidden_act       ) for _ in range(depth - 1       )]      ,   )




				def     a							(					self      ,   snake_case       ):
											snake_case_							=    input
											for layer in self.layers:
																		snake_case_							=    layer(snake_case       )
											return hidden_state







class  lowercase				(       nn.Module			):




				def __init__(					self      ,   snake_case       ):
											super().__init__()
											snake_case_							=    nn.ModuleList([]       )
											# based on `downsample_in_first_stage` the first layer of the first stage may or may not downsample the input
											self.stages.append(
											    ResNetStage(
											        snake_case      ,   config.embedding_size      ,   config.hidden_sizes[0]      ,   stride=2 if config.downsample_in_first_stage else 1      ,   depth=config.depths[0]      ,   )       )
											snake_case_							=    zip(config.hidden_sizes      ,   config.hidden_sizes[1:]       )
											for (in_channels, out_channels), depth in zip(snake_case      ,   config.depths[1:]       ):
																		self.stages.append(ResNetStage(snake_case      ,   snake_case      ,   snake_case      ,   depth=snake_case       )       )




				def     a							(					self      ,   snake_case      ,   snake_case = False      ,   snake_case = True       ):
											snake_case_							=    () if output_hidden_states else None

											for stage_module in self.stages:
																		if output_hidden_states:
																									snake_case_							=    hidden_states + (hidden_state,)

																		snake_case_							=    stage_module(snake_case       )

											if output_hidden_states:
																		snake_case_							=    hidden_states + (hidden_state,)

											if not return_dict:
																		return tuple(v for v in [hidden_state, hidden_states] if v is not None       )

											return BaseModelOutputWithNoAttention(
											    last_hidden_state=snake_case      ,   hidden_states=snake_case      ,   )







class  lowercase				(       lowercase_			):
				__SCREAMING_SNAKE_CASE					: List[str]       			=			ResNetConfig
				__SCREAMING_SNAKE_CASE					: Any       			=			'''resnet'''
				__SCREAMING_SNAKE_CASE					: int       			=			'''pixel_values'''
				__SCREAMING_SNAKE_CASE					: Tuple       			=			True




				def     a							(					self      ,   snake_case       ):
											if isinstance(snake_case      ,   nn.Convad       ):
																		nn.init.kaiming_normal_(module.weight      ,   mode='fan_out'      ,   nonlinearity='relu'       )
											elif isinstance(snake_case      ,   (nn.BatchNormad, nn.GroupNorm)       ):
																		nn.init.constant_(module.weight      ,   1       )
																		nn.init.constant_(module.bias      ,   0       )




				def     a							(					self      ,   snake_case      ,   snake_case=False       ):
											if isinstance(snake_case      ,   snake_case       ):
																		snake_case_							=    value



_UpperCAmelCase		:   Tuple										=       R"""
    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 ([`ResNetConfig`]): 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.
"""

_UpperCAmelCase		:   Optional[int]										=       R"""
    Args:
        pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):
            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See
            [`ConvNextImageProcessor.__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.
"""







@add_start_docstrings(
    '''The bare ResNet model outputting raw features without any specific head on top.'''	,  lowercase_	,  )
class  lowercase				(       lowercase_			):




				def __init__(					self      ,   snake_case       ):
											super().__init__(snake_case       )
											snake_case_							=    config
											snake_case_							=    ResNetEmbeddings(snake_case       )
											snake_case_							=    ResNetEncoder(snake_case       )
											snake_case_							=    nn.AdaptiveAvgPoolad((1, 1)       )
											# Initialize weights and apply final processing
											self.post_init()




				@add_start_docstrings_to_model_forward(snake_case       )
				@add_code_sample_docstrings(
				    checkpoint=_CHECKPOINT_FOR_DOC      ,   output_type=snake_case      ,   config_class=_CONFIG_FOR_DOC      ,   modality='vision'      ,   expected_output=_EXPECTED_OUTPUT_SHAPE      ,   )
				def     a							(					self      ,   snake_case      ,   snake_case = None      ,   snake_case = None       ):
											snake_case_							=    (
											    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
											)
											snake_case_							=    return_dict if return_dict is not None else self.config.use_return_dict

											snake_case_							=    self.embedder(snake_case       )

											snake_case_							=    self.encoder(
											    snake_case      ,   output_hidden_states=snake_case      ,   return_dict=snake_case       )

											snake_case_							=    encoder_outputs[0]

											snake_case_							=    self.pooler(snake_case       )

											if not return_dict:
																		return (last_hidden_state, pooled_output) + encoder_outputs[1:]

											return BaseModelOutputWithPoolingAndNoAttention(
											    last_hidden_state=snake_case      ,   pooler_output=snake_case      ,   hidden_states=encoder_outputs.hidden_states      ,   )







@add_start_docstrings(
    '''
    ResNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for
    ImageNet.
    '''	,  lowercase_	,  )
class  lowercase				(       lowercase_			):




				def __init__(					self      ,   snake_case       ):
											super().__init__(snake_case       )
											snake_case_							=    config.num_labels
											snake_case_							=    ResNetModel(snake_case       )
											# classification head
											snake_case_							=    nn.Sequential(
											    nn.Flatten()      ,   nn.Linear(config.hidden_sizes[-1]      ,   config.num_labels       ) if config.num_labels > 0 else nn.Identity()      ,   )
											# initialize weights and apply final processing
											self.post_init()




				@add_start_docstrings_to_model_forward(snake_case       )
				@add_code_sample_docstrings(
				    checkpoint=_IMAGE_CLASS_CHECKPOINT      ,   output_type=snake_case      ,   config_class=_CONFIG_FOR_DOC      ,   expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT      ,   )
				def     a							(					self      ,   snake_case = None      ,   snake_case = None      ,   snake_case = None      ,   snake_case = None      ,   ):
											snake_case_							=    return_dict if return_dict is not None else self.config.use_return_dict

											snake_case_							=    self.resnet(snake_case      ,   output_hidden_states=snake_case      ,   return_dict=snake_case       )

											snake_case_							=    outputs.pooler_output if return_dict else outputs[1]

											snake_case_							=    self.classifier(snake_case       )

											snake_case_							=    None

											if labels is not None:
																		if self.config.problem_type is None:
																									if self.num_labels == 1:
																																snake_case_							=    'regression'
																									elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
																																snake_case_							=    'single_label_classification'
																									else:
																																snake_case_							=    'multi_label_classification'
																		if self.config.problem_type == "regression":
																									snake_case_							=    MSELoss()
																									if self.num_labels == 1:
																																snake_case_							=    loss_fct(logits.squeeze()      ,   labels.squeeze()       )
																									else:
																																snake_case_							=    loss_fct(snake_case      ,   snake_case       )
																		elif self.config.problem_type == "single_label_classification":
																									snake_case_							=    CrossEntropyLoss()
																									snake_case_							=    loss_fct(logits.view(-1      ,   self.num_labels       )      ,   labels.view(-1       )       )
																		elif self.config.problem_type == "multi_label_classification":
																									snake_case_							=    BCEWithLogitsLoss()
																									snake_case_							=    loss_fct(snake_case      ,   snake_case       )

											if not return_dict:
																		snake_case_							=    (logits,) + outputs[2:]
																		return (loss,) + output if loss is not None else output

											return ImageClassifierOutputWithNoAttention(loss=snake_case      ,   logits=snake_case      ,   hidden_states=outputs.hidden_states       )







@add_start_docstrings(
    '''
    ResNet backbone, to be used with frameworks like DETR and MaskFormer.
    '''	,  lowercase_	,  )
class  lowercase				(       lowercase_	,  lowercase_			):




				def __init__(					self      ,   snake_case       ):
											super().__init__(snake_case       )
											super()._init_backbone(snake_case       )

											snake_case_							=    [config.embedding_size] + config.hidden_sizes
											snake_case_							=    ResNetEmbeddings(snake_case       )
											snake_case_							=    ResNetEncoder(snake_case       )

											# initialize weights and apply final processing
											self.post_init()




				@add_start_docstrings_to_model_forward(snake_case       )
				@replace_return_docstrings(output_type=snake_case      ,   config_class=_CONFIG_FOR_DOC       )
				def     a							(					self      ,   snake_case      ,   snake_case = None      ,   snake_case = None       ):
											snake_case_							=    return_dict if return_dict is not None else self.config.use_return_dict
											snake_case_							=    (
											    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
											)

											snake_case_							=    self.embedder(snake_case       )

											snake_case_							=    self.encoder(snake_case      ,   output_hidden_states=snake_case      ,   return_dict=snake_case       )

											snake_case_							=    outputs.hidden_states

											snake_case_							=    ()
											for idx, stage in enumerate(self.stage_names       ):
																		if stage in self.out_features:
																									feature_maps += (hidden_states[idx],)

											if not return_dict:
																		snake_case_							=    (feature_maps,)
																		if output_hidden_states:
																									output += (outputs.hidden_states,)
																		return output

											return BackboneOutput(
											    feature_maps=snake_case      ,   hidden_states=outputs.hidden_states if output_hidden_states else None      ,   attentions=snake_case      ,   )




