





'''simple docstring'''




import argparse
import json

import requests
import timm
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import AutoImageProcessor, SwinConfig, SwinForImageClassification
def 	UpperCAmelCase_							(					__lowercase							:      List[Any]       )		->       str:


     '''simple docstring'''



     _UpperCAmelCase     							=   SwinConfig()
     _UpperCAmelCase     							=   swin_name.split("_"       )

     _UpperCAmelCase     							=   name_split[1]
     _UpperCAmelCase     							=   int(name_split[4]       )
     _UpperCAmelCase     							=   int(name_split[3][-1]       )

     if model_size == "tiny":
          _UpperCAmelCase     							=   96
          _UpperCAmelCase     							=   (2, 2, 6, 2)
          _UpperCAmelCase     							=   (3, 6, 12, 24)
     elif model_size == "small":
          _UpperCAmelCase     							=   96
          _UpperCAmelCase     							=   (2, 2, 18, 2)
          _UpperCAmelCase     							=   (3, 6, 12, 24)
     elif model_size == "base":
          _UpperCAmelCase     							=   128
          _UpperCAmelCase     							=   (2, 2, 18, 2)
          _UpperCAmelCase     							=   (4, 8, 16, 32)
     else:
          _UpperCAmelCase     							=   192
          _UpperCAmelCase     							=   (2, 2, 18, 2)
          _UpperCAmelCase     							=   (6, 12, 24, 48)

     if "in22k" in swin_name:
          _UpperCAmelCase     							=   2_1841
     else:
          _UpperCAmelCase     							=   1000
          _UpperCAmelCase     							=   "huggingface/label-files"
          _UpperCAmelCase     							=   "imagenet-1k-id2label.json"
          _UpperCAmelCase     							=   json.load(open(hf_hub_download(_lowerCamelCase			,     _lowerCamelCase			,     repo_type="dataset"       )			,     "r"       )       )
          _UpperCAmelCase     							=   {int(_lowerCamelCase       ): v for k, v in idalabel.items()}
          _UpperCAmelCase     							=   idalabel
          _UpperCAmelCase     							=   {v: k for k, v in idalabel.items()}

     _UpperCAmelCase     							=   img_size
     _UpperCAmelCase     							=   num_classes
     _UpperCAmelCase     							=   embed_dim
     _UpperCAmelCase     							=   depths
     _UpperCAmelCase     							=   num_heads
     _UpperCAmelCase     							=   window_size

     return config
def 	UpperCAmelCase_							(					__lowercase							:      Optional[Any]       )		->       List[Any]:


     '''simple docstring'''



     if "patch_embed.proj" in name:
          _UpperCAmelCase     							=   name.replace("patch_embed.proj"			,     "embeddings.patch_embeddings.projection"       )
     if "patch_embed.norm" in name:
          _UpperCAmelCase     							=   name.replace("patch_embed.norm"			,     "embeddings.norm"       )
     if "layers" in name:
          _UpperCAmelCase     							=   "encoder." + name
     if "attn.proj" in name:
          _UpperCAmelCase     							=   name.replace("attn.proj"			,     "attention.output.dense"       )
     if "attn" in name:
          _UpperCAmelCase     							=   name.replace("attn"			,     "attention.self"       )
     if "norm1" in name:
          _UpperCAmelCase     							=   name.replace("norm1"			,     "layernorm_before"       )
     if "norm2" in name:
          _UpperCAmelCase     							=   name.replace("norm2"			,     "layernorm_after"       )
     if "mlp.fc1" in name:
          _UpperCAmelCase     							=   name.replace("mlp.fc1"			,     "intermediate.dense"       )
     if "mlp.fc2" in name:
          _UpperCAmelCase     							=   name.replace("mlp.fc2"			,     "output.dense"       )

     if name == "norm.weight":
          _UpperCAmelCase     							=   "layernorm.weight"
     if name == "norm.bias":
          _UpperCAmelCase     							=   "layernorm.bias"

     if "head" in name:
          _UpperCAmelCase     							=   name.replace("head"			,     "classifier"       )
     else:
          _UpperCAmelCase     							=   "swin." + name

     return name
def 	UpperCAmelCase_							(					__lowercase							:      int			,     __lowercase							:      str       )		->       Tuple:


     '''simple docstring'''



     for key in orig_state_dict.copy().keys():
          _UpperCAmelCase     							=   orig_state_dict.pop(_lowerCamelCase       )

          if "mask" in key:
               continue
          elif "qkv" in key:
               _UpperCAmelCase     							=   key.split("."       )
               _UpperCAmelCase     							=   int(key_split[1]       )
               _UpperCAmelCase     							=   int(key_split[3]       )
               _UpperCAmelCase     							=   model.swin.encoder.layers[layer_num].blocks[block_num].attention.self.all_head_size

               if "weight" in key:
                    _UpperCAmelCase     							=   val[:dim, :]
                    _UpperCAmelCase     							=   val[
                        dim : dim * 2, :
                    ]
                    _UpperCAmelCase     							=   val[-dim:, :]
               else:
                    _UpperCAmelCase     							=   val[
                        :dim
                    ]
                    _UpperCAmelCase     							=   val[
                        dim : dim * 2
                    ]
                    _UpperCAmelCase     							=   val[
                        -dim:
                    ]
          else:
               _UpperCAmelCase     							=   val

     return orig_state_dict
def 	UpperCAmelCase_							(					__lowercase							:      Tuple			,     __lowercase							:      int       )		->       Optional[Any]:


     '''simple docstring'''



     _UpperCAmelCase     							=   timm.create_model(_lowerCamelCase			,     pretrained=_lowerCamelCase       )
     timm_model.eval()

     _UpperCAmelCase     							=   get_swin_config(_lowerCamelCase       )
     _UpperCAmelCase     							=   SwinForImageClassification(_lowerCamelCase       )
     model.eval()

     _UpperCAmelCase     							=   convert_state_dict(timm_model.state_dict()			,     _lowerCamelCase       )
     model.load_state_dict(_lowerCamelCase       )

     _UpperCAmelCase     							=   "http://images.cocodataset.org/val2017/000000039769.jpg"

     _UpperCAmelCase     							=   AutoImageProcessor.from_pretrained("microsoft/{}".format(swin_name.replace("_"			,     "-"       )       )       )
     _UpperCAmelCase     							=   Image.open(requests.get(_lowerCamelCase			,     stream=_lowerCamelCase       ).raw       )
     _UpperCAmelCase     							=   image_processor(images=_lowerCamelCase			,     return_tensors="pt"       )

     _UpperCAmelCase     							=   timm_model(inputs["pixel_values"]       )
     _UpperCAmelCase     							=   model(**_lowerCamelCase       ).logits

     assert torch.allclose(_lowerCamelCase			,     _lowerCamelCase			,     atol=1E-3       )

     print(f'Saving model {swin_name} to {pytorch_dump_folder_path}'       )
     model.save_pretrained(_lowerCamelCase       )

     print(f'Saving image processor to {pytorch_dump_folder_path}'       )
     image_processor.save_pretrained(_lowerCamelCase       )


if __name__ == "__main__":
  __SCREAMING_SNAKE_CASE     :int       =				argparse.ArgumentParser()
  # Required parameters
  parser.add_argument(
      '''--swin_name''',
      default='''swin_tiny_patch4_window7_224''',
      type=str,
      help='''Name of the Swin timm model you\'d like to convert.''',
  )
  parser.add_argument(
      '''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to the output PyTorch model directory.'''
  )

  __SCREAMING_SNAKE_CASE     :int       =				parser.parse_args()
  convert_swin_checkpoint(args.swin_name, args.pytorch_dump_folder_path)












"""simple docstring"""





import os







def      lowerCamelCase__       (							)      ->				List[Any]:
  with open(os.path.dirname(_lowerCamelCase ) + '/grid.txt' ) as f:
    lowerCamelCase_         =						[]  # noqa: E741
    for _ in range(20 ):
      l.append([int(_lowerCamelCase ) for x in f.readline().split()] )

    lowerCamelCase_         =						0

    # right
    for i in range(20 ):
      for j in range(17 ):
        lowerCamelCase_         =						l[i][j] * l[i][j + 1] * l[i][j + 2] * l[i][j + 3]
        if temp > maximum:
          lowerCamelCase_         =						temp

        # down
    for i in range(17 ):
      for j in range(20 ):
        lowerCamelCase_         =						l[i][j] * l[i + 1][j] * l[i + 2][j] * l[i + 3][j]
        if temp > maximum:
          lowerCamelCase_         =						temp

        # diagonal 1
    for i in range(17 ):
      for j in range(17 ):
        lowerCamelCase_         =						l[i][j] * l[i + 1][j + 1] * l[i + 2][j + 2] * l[i + 3][j + 3]
        if temp > maximum:
          lowerCamelCase_         =						temp

        # diagonal 2
    for i in range(17 ):
      for j in range(3		,				20 ):
        lowerCamelCase_         =						l[i][j] * l[i + 1][j - 1] * l[i + 2][j - 2] * l[i + 3][j - 3]
        if temp > maximum:
          lowerCamelCase_         =						temp
    return maximum


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




