



'''simple docstring'''





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


_lowerCAmelCase										=     logging.get_logger(__name__)

# General docstring
_lowerCAmelCase										=     '''ResNetConfig'''

# Base docstring
_lowerCAmelCase										=     '''microsoft/resnet-50'''
_lowerCAmelCase										=     [1, 2048, 7, 7]

# Image classification docstring
_lowerCAmelCase										=     '''microsoft/resnet-50'''
_lowerCAmelCase										=     '''tiger cat'''

_lowerCAmelCase										=     [
    '''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"				)   ->		Optional[int]:
      super().__init__()
      lowerCAmelCase__			:  int											= nn.Convad(
          __lowerCamelCase  ,__lowerCamelCase  ,kernel_size=__lowerCamelCase  ,stride=__lowerCamelCase  ,padding=kernel_size // 2  ,bias=__lowerCamelCase				)
      lowerCAmelCase__			:  int											= nn.BatchNormad(__lowerCamelCase				)
      lowerCAmelCase__			:  Optional[Any]											= ACTaFN[activation] if activation is not None else nn.Identity()






  def 							UpperCAmelCase_     (   self  ,__UpperCAmelCase				)   ->		Optional[int]:
      lowerCAmelCase__			:  Tuple											= self.convolution(__lowerCamelCase				)
      lowerCAmelCase__			:  Dict											= self.normalization(__lowerCamelCase				)
      lowerCAmelCase__			:  str											= self.activation(__lowerCamelCase				)
      return hidden_state







class 	lowerCAmelCase_(    nn.Module					):
  '''simple docstring'''




  def __init__(   self  ,__UpperCAmelCase				)   ->		List[str]:
      super().__init__()
      lowerCAmelCase__			:  Optional[Any]											= ResNetConvLayer(
          config.num_channels  ,config.embedding_size  ,kernel_size=7  ,stride=2  ,activation=config.hidden_act				)
      lowerCAmelCase__			:  Optional[int]											= nn.MaxPoolad(kernel_size=3  ,stride=2  ,padding=1				)
      lowerCAmelCase__			:  str											= config.num_channels






  def 							UpperCAmelCase_     (   self  ,__UpperCAmelCase				)   ->		List[str]:
      lowerCAmelCase__			:  Dict											= 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."""				)
      lowerCAmelCase__			:  int											= self.embedder(__lowerCamelCase				)
      lowerCAmelCase__			:  Tuple											= self.pooler(__lowerCamelCase				)
      return embedding







class 	lowerCAmelCase_(    nn.Module					):
  '''simple docstring'''




  def __init__(   self  ,__UpperCAmelCase  ,__UpperCAmelCase  ,__UpperCAmelCase = 2				)   ->		Union[str, Any]:
      super().__init__()
      lowerCAmelCase__			:  Optional[Any]											= nn.Convad(__lowerCamelCase  ,__lowerCamelCase  ,kernel_size=1  ,stride=__lowerCamelCase  ,bias=__lowerCamelCase				)
      lowerCAmelCase__			:  Dict											= nn.BatchNormad(__lowerCamelCase				)






  def 							UpperCAmelCase_     (   self  ,__UpperCAmelCase				)   ->		str:
      lowerCAmelCase__			:  str											= self.convolution(__lowerCamelCase				)
      lowerCAmelCase__			:  Dict											= self.normalization(__lowerCamelCase				)
      return hidden_state







class 	lowerCAmelCase_(    nn.Module					):
  '''simple docstring'''




  def __init__(   self  ,__UpperCAmelCase  ,__UpperCAmelCase  ,__UpperCAmelCase = 1  ,__UpperCAmelCase = "relu"				)   ->		Tuple:
      super().__init__()
      lowerCAmelCase__			:  List[str]											= in_channels != out_channels or stride != 1
      lowerCAmelCase__			:  Union[str, Any]											= (
          ResNetShortCut(__lowerCamelCase  ,__lowerCamelCase  ,stride=__lowerCamelCase				) if should_apply_shortcut else nn.Identity()
      )
      lowerCAmelCase__			:  Optional[int]											= nn.Sequential(
          ResNetConvLayer(__lowerCamelCase  ,__lowerCamelCase  ,stride=__lowerCamelCase				)  ,ResNetConvLayer(__lowerCamelCase  ,__lowerCamelCase  ,activation=__lowerCamelCase				)  ,)
      lowerCAmelCase__			:  Optional[int]											= ACTaFN[activation]






  def 							UpperCAmelCase_     (   self  ,__UpperCAmelCase				)   ->		int:
      lowerCAmelCase__			:  Tuple											= hidden_state
      lowerCAmelCase__			:  List[Any]											= self.layer(__lowerCamelCase				)
      lowerCAmelCase__			:  Optional[int]											= self.shortcut(__lowerCamelCase				)
      hidden_state += residual
      lowerCAmelCase__			:  int											= self.activation(__lowerCamelCase				)
      return hidden_state







class 	lowerCAmelCase_(    nn.Module					):
  '''simple docstring'''




  def __init__(   self  ,__UpperCAmelCase  ,__UpperCAmelCase  ,__UpperCAmelCase = 1  ,__UpperCAmelCase = "relu"  ,__UpperCAmelCase = 4				)   ->		List[str]:
      super().__init__()
      lowerCAmelCase__			:  str											= in_channels != out_channels or stride != 1
      lowerCAmelCase__			:  List[Any]											= out_channels // reduction
      lowerCAmelCase__			:  List[Any]											= (
          ResNetShortCut(__lowerCamelCase  ,__lowerCamelCase  ,stride=__lowerCamelCase				) if should_apply_shortcut else nn.Identity()
      )
      lowerCAmelCase__			:  Optional[Any]											= nn.Sequential(
          ResNetConvLayer(__lowerCamelCase  ,__lowerCamelCase  ,kernel_size=1				)  ,ResNetConvLayer(__lowerCamelCase  ,__lowerCamelCase  ,stride=__lowerCamelCase				)  ,ResNetConvLayer(__lowerCamelCase  ,__lowerCamelCase  ,kernel_size=1  ,activation=__lowerCamelCase				)  ,)
      lowerCAmelCase__			:  str											= ACTaFN[activation]






  def 							UpperCAmelCase_     (   self  ,__UpperCAmelCase				)   ->		str:
      lowerCAmelCase__			:  Union[str, Any]											= hidden_state
      lowerCAmelCase__			:  str											= self.layer(__lowerCamelCase				)
      lowerCAmelCase__			:  Tuple											= self.shortcut(__lowerCamelCase				)
      hidden_state += residual
      lowerCAmelCase__			:  Union[str, Any]											= self.activation(__lowerCamelCase				)
      return hidden_state







class 	lowerCAmelCase_(    nn.Module					):
  '''simple docstring'''




  def __init__(   self  ,__UpperCAmelCase  ,__UpperCAmelCase  ,__UpperCAmelCase  ,__UpperCAmelCase = 2  ,__UpperCAmelCase = 2  ,)   ->		int:
      super().__init__()

      lowerCAmelCase__			:  Dict											= ResNetBottleNeckLayer if config.layer_type == """bottleneck""" else ResNetBasicLayer

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






  def 							UpperCAmelCase_     (   self  ,__UpperCAmelCase				)   ->		List[str]:
      lowerCAmelCase__			:  Dict											= input
      for layer in self.layers:
          lowerCAmelCase__			:  Optional[int]											= layer(__lowerCamelCase				)
      return hidden_state







class 	lowerCAmelCase_(    nn.Module					):
  '''simple docstring'''




  def __init__(   self  ,__UpperCAmelCase				)   ->		Any:
      super().__init__()
      lowerCAmelCase__			:  List[str]											= 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(
              __lowerCamelCase  ,config.embedding_size  ,config.hidden_sizes[0]  ,stride=2 if config.downsample_in_first_stage else 1  ,depth=config.depths[0]  ,)				)
      lowerCAmelCase__			:  Optional[int]											= zip(config.hidden_sizes  ,config.hidden_sizes[1:]				)
      for (in_channels, out_channels), depth in zip(__lowerCamelCase  ,config.depths[1:]				):
          self.stages.append(ResNetStage(__lowerCamelCase  ,__lowerCamelCase  ,__lowerCamelCase  ,depth=__lowerCamelCase				)				)






  def 							UpperCAmelCase_     (   self  ,__UpperCAmelCase  ,__UpperCAmelCase = False  ,__UpperCAmelCase = True				)   ->		str:
      lowerCAmelCase__			:  Dict											= () if output_hidden_states else None

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

          lowerCAmelCase__			:  Dict											= stage_module(__lowerCamelCase				)

      if output_hidden_states:
          lowerCAmelCase__			:  Any											= 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=__lowerCamelCase  ,hidden_states=__lowerCamelCase  ,)







class 	lowerCAmelCase_(    _a					):
  '''simple docstring'''




  __lowercase							:				Any           =				ResNetConfig
  __lowercase							:				Dict           =				"""resnet"""
  __lowercase							:				str           =				"""pixel_values"""
  __lowercase							:				Tuple           =				True




  def 							UpperCAmelCase_     (   self  ,__UpperCAmelCase				)   ->		str:
      if isinstance(__lowerCamelCase  ,nn.Convad				):
          nn.init.kaiming_normal_(module.weight  ,mode="""fan_out"""  ,nonlinearity="""relu"""				)
      elif isinstance(__lowerCamelCase  ,(nn.BatchNormad, nn.GroupNorm)				):
          nn.init.constant_(module.weight  ,1				)
          nn.init.constant_(module.bias  ,0				)






  def 							UpperCAmelCase_     (   self  ,__UpperCAmelCase  ,__UpperCAmelCase=False				)   ->		int:
      if isinstance(__lowerCamelCase  ,__lowerCamelCase				):
          lowerCAmelCase__			:  Union[str, Any]											= value







_lowerCAmelCase										=     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.
'''

_lowerCAmelCase										=     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.'''						,			_a						,			)
class 	lowerCAmelCase_(    _a					):
  '''simple docstring'''




  def __init__(   self  ,__UpperCAmelCase				)   ->		Tuple:
      super().__init__(__lowerCamelCase				)
      lowerCAmelCase__			:  Tuple											= config
      lowerCAmelCase__			:  str											= ResNetEmbeddings(__lowerCamelCase				)
      lowerCAmelCase__			:  Dict											= ResNetEncoder(__lowerCamelCase				)
      lowerCAmelCase__			:  Dict											= nn.AdaptiveAvgPoolad((1, 1)				)
      # Initialize weights and apply final processing
      self.post_init()






  @add_start_docstrings_to_model_forward(__lowerCamelCase				)
  @add_code_sample_docstrings(
      checkpoint=_CHECKPOINT_FOR_DOC  ,output_type=__lowerCamelCase  ,config_class=_CONFIG_FOR_DOC  ,modality="""vision"""  ,expected_output=_EXPECTED_OUTPUT_SHAPE  ,)
  def 							UpperCAmelCase_     (   self  ,__UpperCAmelCase  ,__UpperCAmelCase = None  ,__UpperCAmelCase = None				)   ->		str:
      lowerCAmelCase__			:  Optional[int]											= (
          output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
      )
      lowerCAmelCase__			:  Dict											= return_dict if return_dict is not None else self.config.use_return_dict

      lowerCAmelCase__			:  Optional[Any]											= self.embedder(__lowerCamelCase				)

      lowerCAmelCase__			:  Tuple											= self.encoder(
          __lowerCamelCase  ,output_hidden_states=__lowerCamelCase  ,return_dict=__lowerCamelCase				)

      lowerCAmelCase__			:  Dict											= encoder_outputs[0]

      lowerCAmelCase__			:  Optional[Any]											= self.pooler(__lowerCamelCase				)

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

      return BaseModelOutputWithPoolingAndNoAttention(
          last_hidden_state=__lowerCamelCase  ,pooler_output=__lowerCamelCase  ,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.
    '''						,			_a						,			)
class 	lowerCAmelCase_(    _a					):
  '''simple docstring'''




  def __init__(   self  ,__UpperCAmelCase				)   ->		Tuple:
      super().__init__(__lowerCamelCase				)
      lowerCAmelCase__			:  Optional[Any]											= config.num_labels
      lowerCAmelCase__			:  int											= ResNetModel(__lowerCamelCase				)
      # classification head
      lowerCAmelCase__			:  Optional[Any]											= 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(__lowerCamelCase				)
  @add_code_sample_docstrings(
      checkpoint=_IMAGE_CLASS_CHECKPOINT  ,output_type=__lowerCamelCase  ,config_class=_CONFIG_FOR_DOC  ,expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT  ,)
  def 							UpperCAmelCase_     (   self  ,__UpperCAmelCase = None  ,__UpperCAmelCase = None  ,__UpperCAmelCase = None  ,__UpperCAmelCase = None  ,)   ->		str:
      lowerCAmelCase__			:  str											= return_dict if return_dict is not None else self.config.use_return_dict

      lowerCAmelCase__			:  Optional[int]											= self.resnet(__lowerCamelCase  ,output_hidden_states=__lowerCamelCase  ,return_dict=__lowerCamelCase				)

      lowerCAmelCase__			:  Optional[Any]											= outputs.pooler_output if return_dict else outputs[1]

      lowerCAmelCase__			:  Tuple											= self.classifier(__lowerCamelCase				)

      lowerCAmelCase__			:  List[Any]											= None

      if labels is not None:
          if self.config.problem_type is None:
              if self.num_labels == 1:
                  lowerCAmelCase__			:  List[str]											= """regression"""
              elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
                  lowerCAmelCase__			:  List[str]											= """single_label_classification"""
              else:
                  lowerCAmelCase__			:  Tuple											= """multi_label_classification"""
          if self.config.problem_type == "regression":
              lowerCAmelCase__			:  Optional[Any]											= MSELoss()
              if self.num_labels == 1:
                  lowerCAmelCase__			:  Dict											= loss_fct(logits.squeeze()  ,labels.squeeze()				)
              else:
                  lowerCAmelCase__			:  Optional[int]											= loss_fct(__lowerCamelCase  ,__lowerCamelCase				)
          elif self.config.problem_type == "single_label_classification":
              lowerCAmelCase__			:  Any											= CrossEntropyLoss()
              lowerCAmelCase__			:  List[str]											= loss_fct(logits.view(-1  ,self.num_labels				)  ,labels.view(-1				)				)
          elif self.config.problem_type == "multi_label_classification":
              lowerCAmelCase__			:  Dict											= BCEWithLogitsLoss()
              lowerCAmelCase__			:  Any											= loss_fct(__lowerCamelCase  ,__lowerCamelCase				)

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

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







@add_start_docstrings(
    '''
    ResNet backbone, to be used with frameworks like DETR and MaskFormer.
    '''						,			_a						,			)
class 	lowerCAmelCase_(    _a						,			_a					):
  '''simple docstring'''




  def __init__(   self  ,__UpperCAmelCase				)   ->		List[Any]:
      super().__init__(__lowerCamelCase				)
      super()._init_backbone(__lowerCamelCase				)

      lowerCAmelCase__			:  int											= [config.embedding_size] + config.hidden_sizes
      lowerCAmelCase__			:  Any											= ResNetEmbeddings(__lowerCamelCase				)
      lowerCAmelCase__			:  Dict											= ResNetEncoder(__lowerCamelCase				)

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






  @add_start_docstrings_to_model_forward(__lowerCamelCase				)
  @replace_return_docstrings(output_type=__lowerCamelCase  ,config_class=_CONFIG_FOR_DOC				)
  def 							UpperCAmelCase_     (   self  ,__UpperCAmelCase  ,__UpperCAmelCase = None  ,__UpperCAmelCase = None				)   ->		str:
      lowerCAmelCase__			:  Dict											= return_dict if return_dict is not None else self.config.use_return_dict
      lowerCAmelCase__			:  Optional[int]											= (
          output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
      )

      lowerCAmelCase__			:  str											= self.embedder(__lowerCamelCase				)

      lowerCAmelCase__			:  List[str]											= self.encoder(__lowerCamelCase  ,output_hidden_states=__lowerCamelCase  ,return_dict=__lowerCamelCase				)

      lowerCAmelCase__			:  List[str]											= outputs.hidden_states

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

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

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







'''simple docstring'''





import os
def        _SCREAMING_SNAKE_CASE  (	UpperCamelCase      ):



    """simple docstring"""





    lowerCAmelCase__			:  List[str]											= len(grid[0]      )
    lowerCAmelCase__			:  int											= len(UpperCamelCase      )

    lowerCAmelCase__			:  Optional[int]											= 0
    lowerCAmelCase__			:  Tuple											= 0
    lowerCAmelCase__			:  Optional[Any]											= 0

    # Check vertically, horizontally, diagonally at the same time (only works
    # for nxn grid)
    for i in range(UpperCamelCase      ):
        for j in range(n_rows - 3      ):
            lowerCAmelCase__			:  str											= grid[j][i] * grid[j + 1][i] * grid[j + 2][i] * grid[j + 3][i]
            lowerCAmelCase__			:  Optional[int]											= grid[i][j] * grid[i][j + 1] * grid[i][j + 2] * grid[i][j + 3]

            # Left-to-right diagonal (\) product
            if i < n_columns - 3:
                lowerCAmelCase__			:  Optional[int]											= (
                    grid[i][j]
                    * grid[i + 1][j + 1]
                    * grid[i + 2][j + 2]
                    * grid[i + 3][j + 3]
                )

            # Right-to-left diagonal(/) product
            if i > 2:
                lowerCAmelCase__			:  Tuple											= (
                    grid[i][j]
                    * grid[i - 1][j + 1]
                    * grid[i - 2][j + 2]
                    * grid[i - 3][j + 3]
                )

            lowerCAmelCase__			:  Dict											= max(
                UpperCamelCase							,   UpperCamelCase							,   UpperCamelCase							,   UpperCamelCase      )
            if max_product > largest:
                lowerCAmelCase__			:  Any											= max_product

    return largest
def        _SCREAMING_SNAKE_CASE  (	):



    """simple docstring"""





    lowerCAmelCase__			:  List[str]											= []
    with open(os.path.dirname(UpperCamelCase      ) + """/grid.txt"""      ) as file:
        for line in file:
            grid.append(line.strip("""\n"""      ).split(""" """      )      )

    lowerCAmelCase__			:  Dict											= [[int(UpperCamelCase      ) for i in grid[j]] for j in range(len(UpperCamelCase      )      )]

    return largest_product(UpperCamelCase      )


if __name__ == "__main__":
 print(solution())


