




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    =					logging.get_logger(__name__)

# General docstring
UpperCAmelCase    =					"""ResNetConfig"""

# Base docstring
UpperCAmelCase    =					"""microsoft/resnet-50"""
UpperCAmelCase    =					[1, 2048, 7, 7]

# Image classification docstring
UpperCAmelCase    =					"""microsoft/resnet-50"""
UpperCAmelCase    =					"""tiger cat"""

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







class lowerCAmelCase_		(				nn.Module ):

 '''simple docstring'''

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





 def 		UpperCamelCase__  (			self	,   _UpperCAmelCase      ):
       snake_case_ =   self.convolution(_UpperCAmelCase      )
       snake_case_ =   self.normalization(_UpperCAmelCase      )
       snake_case_ =   self.activation(_UpperCAmelCase      )
       return hidden_state







class lowerCAmelCase_		(				nn.Module ):

 '''simple docstring'''

 def __init__(			self	,   _UpperCAmelCase      ):
       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 		UpperCamelCase__  (			self	,   _UpperCAmelCase      ):
       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(_UpperCAmelCase      )
       snake_case_ =   self.pooler(_UpperCAmelCase      )
       return embedding







class lowerCAmelCase_		(				nn.Module ):

 '''simple docstring'''

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





 def 		UpperCamelCase__  (			self	,   _UpperCAmelCase      ):
       snake_case_ =   self.convolution(_UpperCAmelCase      )
       snake_case_ =   self.normalization(_UpperCAmelCase      )
       return hidden_state







class lowerCAmelCase_		(				nn.Module ):

 '''simple docstring'''

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





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







class lowerCAmelCase_		(				nn.Module ):

 '''simple docstring'''

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





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







class lowerCAmelCase_		(				nn.Module ):

 '''simple docstring'''

 def __init__(			self	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase = 2	,   _UpperCAmelCase = 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(_UpperCAmelCase	,   _UpperCAmelCase	,   stride=_UpperCAmelCase	,   activation=config.hidden_act      )	,   *[layer(_UpperCAmelCase	,   _UpperCAmelCase	,   activation=config.hidden_act      ) for _ in range(depth - 1      )]	,   )





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







class lowerCAmelCase_		(				nn.Module ):

 '''simple docstring'''

 def __init__(			self	,   _UpperCAmelCase      ):
       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(
               _UpperCAmelCase	,   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(_UpperCAmelCase	,   config.depths[1:]      ):
             self.stages.append(ResNetStage(_UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase	,   depth=_UpperCAmelCase      )      )





 def 		UpperCamelCase__  (			self	,   _UpperCAmelCase	,   _UpperCAmelCase = False	,   _UpperCAmelCase = 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(_UpperCAmelCase      )

       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=_UpperCAmelCase	,   hidden_states=_UpperCAmelCase	,   )







class lowerCAmelCase_		(				lowerCamelCase__ ):

 '''simple docstring'''

 __snake_case				=						ResNetConfig
 __snake_case				=						"resnet"
 __snake_case				=						"pixel_values"
 __snake_case				=						True



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





 def 		UpperCamelCase__  (			self	,   _UpperCAmelCase	,   _UpperCAmelCase=False      ):
       if isinstance(_UpperCAmelCase	,   _UpperCAmelCase      ):
             snake_case_ =   value





UpperCAmelCase    =					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    =					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."      ,		lowerCamelCase__      ,		)
class lowerCAmelCase_		(				lowerCamelCase__ ):

 '''simple docstring'''

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





 @add_start_docstrings_to_model_forward(_UpperCAmelCase      )
 @add_code_sample_docstrings(
     checkpoint=_CHECKPOINT_FOR_DOC	,   output_type=_UpperCAmelCase	,   config_class=_CONFIG_FOR_DOC	,   modality='''vision'''	,   expected_output=_EXPECTED_OUTPUT_SHAPE	,   )
 def 		UpperCamelCase__  (			self	,   _UpperCAmelCase	,   _UpperCAmelCase = None	,   _UpperCAmelCase = 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(_UpperCAmelCase      )

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

       snake_case_ =   encoder_outputs[0]

       snake_case_ =   self.pooler(_UpperCAmelCase      )

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

       return BaseModelOutputWithPoolingAndNoAttention(
           last_hidden_state=_UpperCAmelCase	,   pooler_output=_UpperCAmelCase	,   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    "      ,		lowerCamelCase__      ,		)
class lowerCAmelCase_		(				lowerCamelCase__ ):

 '''simple docstring'''

 def __init__(			self	,   _UpperCAmelCase      ):
       super().__init__(_UpperCAmelCase      )
       snake_case_ =   config.num_labels
       snake_case_ =   ResNetModel(_UpperCAmelCase      )
       # 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(_UpperCAmelCase      )
 @add_code_sample_docstrings(
     checkpoint=_IMAGE_CLASS_CHECKPOINT	,   output_type=_UpperCAmelCase	,   config_class=_CONFIG_FOR_DOC	,   expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT	,   )
 def 		UpperCamelCase__  (			self	,   _UpperCAmelCase = None	,   _UpperCAmelCase = None	,   _UpperCAmelCase = None	,   _UpperCAmelCase = None	,   ):
       snake_case_ =   return_dict if return_dict is not None else self.config.use_return_dict

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

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

       snake_case_ =   self.classifier(_UpperCAmelCase      )

       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(_UpperCAmelCase	,   _UpperCAmelCase      )
             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(_UpperCAmelCase	,   _UpperCAmelCase      )

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

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







@add_start_docstrings(
    "\n    ResNet backbone, to be used with frameworks like DETR and MaskFormer.\n    "      ,		lowerCamelCase__      ,		)
class lowerCAmelCase_		(				lowerCamelCase__      ,		lowerCamelCase__ ):

 '''simple docstring'''

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

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

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





 @add_start_docstrings_to_model_forward(_UpperCAmelCase      )
 @replace_return_docstrings(output_type=_UpperCAmelCase	,   config_class=_CONFIG_FOR_DOC      )
 def 		UpperCamelCase__  (			self	,   _UpperCAmelCase	,   _UpperCAmelCase = None	,   _UpperCAmelCase = 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(_UpperCAmelCase      )

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

       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=_UpperCAmelCase	,   hidden_states=outputs.hidden_states if output_hidden_states else None	,   attentions=_UpperCAmelCase	,   )



def  __lowerCAmelCase					(SCREAMING_SNAKE_CASE      ,      SCREAMING_SNAKE_CASE      )->						int:




      """simple docstring"""

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






def  __lowerCAmelCase					()->						None:




      """simple docstring"""

      assert and_gate(0      ,      0      ) == 0
      assert and_gate(0      ,      1      ) == 0
      assert and_gate(1      ,      0      ) == 0
      assert and_gate(1      ,      1      ) == 1


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