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		:       List[str]						    =	logging.get_logger(__name__)

# General docstring
_UpperCAmelCase		:       List[str]						    =	'''ResNetConfig'''

# Base docstring
_UpperCAmelCase		:       Any						    =	'''microsoft/resnet-50'''
_UpperCAmelCase		:       List[Any]						    =	[1, 2048, 7, 7]

# Image classification docstring
_UpperCAmelCase		:       Union[str, Any]						    =	'''microsoft/resnet-50'''
_UpperCAmelCase		:       Tuple						    =	'''tiger cat'''

_UpperCAmelCase		:       Optional[int]						    =	[
    '''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(
											    _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       kernel_size=_SCREAMING_SNAKE_CASE				,       stride=_SCREAMING_SNAKE_CASE				,       padding=kernel_size // 2				,       bias=_SCREAMING_SNAKE_CASE	)
											snake_case_          =   nn.BatchNormad(_SCREAMING_SNAKE_CASE	)
											snake_case_          =   ACTaFN[activation] if activation is not None else nn.Identity()




				def    a							( self				,       snake_case	):
											snake_case_          =   self.convolution(_SCREAMING_SNAKE_CASE	)
											snake_case_          =   self.normalization(_SCREAMING_SNAKE_CASE	)
											snake_case_          =   self.activation(_SCREAMING_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(_SCREAMING_SNAKE_CASE	)
											snake_case_          =   self.pooler(_SCREAMING_SNAKE_CASE	)
											return embedding







class 			lowercase    (	nn.Module      ):




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




				def    a							( self				,       snake_case	):
											snake_case_          =   self.convolution(_SCREAMING_SNAKE_CASE	)
											snake_case_          =   self.normalization(_SCREAMING_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(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       stride=_SCREAMING_SNAKE_CASE	) if should_apply_shortcut else nn.Identity()
											)
											snake_case_          =   nn.Sequential(
											    ResNetConvLayer(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       stride=_SCREAMING_SNAKE_CASE	)				,       ResNetConvLayer(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       activation=_SCREAMING_SNAKE_CASE	)				,       )
											snake_case_          =   ACTaFN[activation]




				def    a							( self				,       snake_case	):
											snake_case_          =   hidden_state
											snake_case_          =   self.layer(_SCREAMING_SNAKE_CASE	)
											snake_case_          =   self.shortcut(_SCREAMING_SNAKE_CASE	)
											hidden_state += residual
											snake_case_          =   self.activation(_SCREAMING_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(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       stride=_SCREAMING_SNAKE_CASE	) if should_apply_shortcut else nn.Identity()
											)
											snake_case_          =   nn.Sequential(
											    ResNetConvLayer(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       kernel_size=1	)				,       ResNetConvLayer(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       stride=_SCREAMING_SNAKE_CASE	)				,       ResNetConvLayer(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       kernel_size=1				,       activation=_SCREAMING_SNAKE_CASE	)				,       )
											snake_case_          =   ACTaFN[activation]




				def    a							( self				,       snake_case	):
											snake_case_          =   hidden_state
											snake_case_          =   self.layer(_SCREAMING_SNAKE_CASE	)
											snake_case_          =   self.shortcut(_SCREAMING_SNAKE_CASE	)
											hidden_state += residual
											snake_case_          =   self.activation(_SCREAMING_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(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       stride=_SCREAMING_SNAKE_CASE				,       activation=config.hidden_act	)				,       *[layer(_SCREAMING_SNAKE_CASE				,       _SCREAMING_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(_SCREAMING_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(
											        _SCREAMING_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(_SCREAMING_SNAKE_CASE				,       config.depths[1:]	):
																		self.stages.append(ResNetStage(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       depth=_SCREAMING_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(_SCREAMING_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=_SCREAMING_SNAKE_CASE				,       hidden_states=_SCREAMING_SNAKE_CASE				,       )







class 			lowercase    (	SCREAMING_SNAKE_CASE__      ):
				__SCREAMING_SNAKE_CASE :			Tuple	      =      ResNetConfig
				__SCREAMING_SNAKE_CASE :			List[Any]	      =      'resnet'
				__SCREAMING_SNAKE_CASE :			Dict	      =      'pixel_values'
				__SCREAMING_SNAKE_CASE :			Optional[int]	      =      True




				def    a							( self				,       snake_case	):
											if isinstance(_SCREAMING_SNAKE_CASE				,       nn.Convad	):
																		nn.init.kaiming_normal_(module.weight				,       mode='fan_out'				,       nonlinearity='relu'	)
											elif isinstance(_SCREAMING_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(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE	):
																		snake_case_          =   value



_UpperCAmelCase		:       Optional[int]						    =	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		:       Any						    =	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.'''     ,  SCREAMING_SNAKE_CASE__     ,  )
class 			lowercase    (	SCREAMING_SNAKE_CASE__      ):




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




				@add_start_docstrings_to_model_forward(_SCREAMING_SNAKE_CASE	)
				@add_code_sample_docstrings(
				    checkpoint=_CHECKPOINT_FOR_DOC				,       output_type=_SCREAMING_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(_SCREAMING_SNAKE_CASE	)

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

											snake_case_          =   encoder_outputs[0]

											snake_case_          =   self.pooler(_SCREAMING_SNAKE_CASE	)

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

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







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




				def __init__( self				,       snake_case	):
											super().__init__(_SCREAMING_SNAKE_CASE	)
											snake_case_          =   config.num_labels
											snake_case_          =   ResNetModel(_SCREAMING_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(_SCREAMING_SNAKE_CASE	)
				@add_code_sample_docstrings(
				    checkpoint=_IMAGE_CLASS_CHECKPOINT				,       output_type=_SCREAMING_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(_SCREAMING_SNAKE_CASE				,       output_hidden_states=_SCREAMING_SNAKE_CASE				,       return_dict=_SCREAMING_SNAKE_CASE	)

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

											snake_case_          =   self.classifier(_SCREAMING_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(_SCREAMING_SNAKE_CASE				,       _SCREAMING_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(_SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE	)

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

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







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




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

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

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




				@add_start_docstrings_to_model_forward(_SCREAMING_SNAKE_CASE	)
				@replace_return_docstrings(output_type=_SCREAMING_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(_SCREAMING_SNAKE_CASE	)

											snake_case_          =   self.encoder(_SCREAMING_SNAKE_CASE				,       output_hidden_states=_SCREAMING_SNAKE_CASE				,       return_dict=_SCREAMING_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=_SCREAMING_SNAKE_CASE				,       hidden_states=outputs.hidden_states if output_hidden_states else None				,       attentions=_SCREAMING_SNAKE_CASE				,       )







def  __lowerCamelCase     (			UpperCamelCase__       ,							UpperCamelCase__				):







							'''simple docstring'''






							return int((input_a, input_a).count(0				) != 0				)





def  __lowerCamelCase     (			):







							'''simple docstring'''






							assert nand_gate(0       ,							0				) == 1
							assert nand_gate(0       ,							1				) == 1
							assert nand_gate(1       ,							0				) == 1
							assert nand_gate(1       ,							1				) == 0


if __name__ == "__main__":
					print(nand_gate(0, 0))
					print(nand_gate(0, 1))
					print(nand_gate(1, 0))
					print(nand_gate(1, 1))




