



'''simple docstring'''





import argparse
import json
from pathlib import Path

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

from transformers import (
    SwiftFormerConfig,
    SwiftFormerForImageClassification,
    ViTImageProcessor,
)
from transformers.utils import logging


logging.set_verbosity_info()
_lowerCAmelCase										=     logging.get_logger(__name__)

_lowerCAmelCase										=     torch.device('''cpu''')
def        _SCREAMING_SNAKE_CASE  (	):



    """simple docstring"""





    lowerCAmelCase__			:  Optional[Any]											= """http://images.cocodataset.org/val2017/000000039769.jpg"""
    lowerCAmelCase__			:  Tuple											= Image.open(requests.get(snake_case_							,   stream=snake_case_      ).raw      )
    return im
def        _SCREAMING_SNAKE_CASE  (	UpperCamelCase      ):



    """simple docstring"""





    if swiftformer_name == "swiftformer_xs":
        return torch.tensor([-2.17_03e00, 2.11_07e00, -2.08_11e00, 8.86_85e-01, 2.43_60e-01]      )

    elif swiftformer_name == "swiftformer_s":
        return torch.tensor([3.96_36e-01, 2.34_78e-01, -1.69_63e00, -1.73_81e00, -8.63_37e-01]      )

    elif swiftformer_name == "swiftformer_l1":
        return torch.tensor([-4.27_68e-01, -4.74_29e-01, -1.08_97e00, -1.02_48e00, 3.55_23e-02]      )

    elif swiftformer_name == "swiftformer_l3":
        return torch.tensor([-2.53_30e-01, 2.42_11e-01, -6.01_85e-01, -8.27_89e-01, -6.04_46e-02]      )
def        _SCREAMING_SNAKE_CASE  (	UpperCamelCase							,   UpperCamelCase							,   UpperCamelCase      ):



    """simple docstring"""





    lowerCAmelCase__			:  Any											= dct.pop(snake_case_      )
    lowerCAmelCase__			:  List[str]											= val
def        _SCREAMING_SNAKE_CASE  (	UpperCamelCase      ):



    """simple docstring"""





    lowerCAmelCase__			:  Dict											= []
    for k in state_dict.keys():
        lowerCAmelCase__			:  Union[str, Any]											= k
        if ".pwconv" in k:
            lowerCAmelCase__			:  int											= k_new.replace(""".pwconv"""							,   """.point_wise_conv"""      )
        if ".dwconv" in k:
            lowerCAmelCase__			:  Any											= k_new.replace(""".dwconv"""							,   """.depth_wise_conv"""      )
        if ".Proj." in k:
            lowerCAmelCase__			:  List[Any]											= k_new.replace(""".Proj."""							,   """.proj."""      )
        if "patch_embed" in k_new:
            lowerCAmelCase__			:  Union[str, Any]											= k_new.replace("""patch_embed"""							,   """swiftformer.patch_embed.patch_embedding"""      )
        if "network" in k_new:
            lowerCAmelCase__			:  Dict											= k_new.split("""."""      )
            if ls[2].isdigit():
                lowerCAmelCase__			:  List[str]											= """swiftformer.encoder.network.""" + ls[1] + """.blocks.""" + ls[2] + """.""" + """.""".join(ls[3:]      )
            else:
                lowerCAmelCase__			:  Any											= k_new.replace("""network"""							,   """swiftformer.encoder.network"""      )
        rename_keys.append((k, k_new)      )
    return rename_keys
@torch.no_grad()
def        _SCREAMING_SNAKE_CASE  (	UpperCamelCase							,   UpperCamelCase							,   UpperCamelCase      ):



    """simple docstring"""





    lowerCAmelCase__			:  Optional[int]											= SwiftFormerConfig()

    # dataset (ImageNet-21k only or also fine-tuned on ImageNet 2012), patch_size and image_size
    lowerCAmelCase__			:  List[str]											= 1000
    lowerCAmelCase__			:  Optional[Any]											= """huggingface/label-files"""
    lowerCAmelCase__			:  Union[str, Any]											= """imagenet-1k-id2label.json"""
    lowerCAmelCase__			:  List[str]											= json.load(open(hf_hub_download(snake_case_							,   snake_case_							,   repo_type="""dataset"""      )							,   """r"""      )      )
    lowerCAmelCase__			:  List[Any]											= {int(snake_case_      ): v for k, v in idalabel.items()}
    lowerCAmelCase__			:  List[Any]											= idalabel
    lowerCAmelCase__			:  List[str]											= {v: k for k, v in idalabel.items()}

    # size of the architecture
    if swiftformer_name == "swiftformer_xs":
        lowerCAmelCase__			:  int											= [3, 3, 6, 4]
        lowerCAmelCase__			:  Any											= [48, 56, 112, 220]

    elif swiftformer_name == "swiftformer_s":
        lowerCAmelCase__			:  Dict											= [3, 3, 9, 6]
        lowerCAmelCase__			:  List[str]											= [48, 64, 168, 224]

    elif swiftformer_name == "swiftformer_l1":
        lowerCAmelCase__			:  Any											= [4, 3, 10, 5]
        lowerCAmelCase__			:  Dict											= [48, 96, 192, 384]

    elif swiftformer_name == "swiftformer_l3":
        lowerCAmelCase__			:  Any											= [4, 4, 12, 6]
        lowerCAmelCase__			:  Union[str, Any]											= [64, 128, 320, 512]

    # load state_dict of original model, remove and rename some keys
    if original_ckpt:
        if original_ckpt.startswith("""https"""      ):
            lowerCAmelCase__			:  Tuple											= torch.hub.load_state_dict_from_url(snake_case_							,   map_location="""cpu"""							,   check_hash=snake_case_      )
        else:
            lowerCAmelCase__			:  Dict											= torch.load(snake_case_							,   map_location="""cpu"""      )
    lowerCAmelCase__			:  Optional[int]											= checkpoint

    lowerCAmelCase__			:  int											= create_rename_keys(snake_case_      )
    for rename_key_src, rename_key_dest in rename_keys:
        rename_key(snake_case_							,   snake_case_							,   snake_case_      )

    # load HuggingFace model
    lowerCAmelCase__			:  Optional[Any]											= SwiftFormerForImageClassification(snake_case_      ).eval()
    hf_model.load_state_dict(snake_case_      )

    # prepare test inputs
    lowerCAmelCase__			:  Dict											= prepare_img()
    lowerCAmelCase__			:  Tuple											= ViTImageProcessor.from_pretrained("""preprocessor_config"""      )
    lowerCAmelCase__			:  Any											= processor(images=snake_case_							,   return_tensors="""pt"""      )

    # compare outputs from both models
    lowerCAmelCase__			:  str											= get_expected_output(snake_case_      )
    lowerCAmelCase__			:  int											= hf_model(inputs["""pixel_values"""]      ).logits

    assert hf_logits.shape == torch.Size([1, 1000]      )
    assert torch.allclose(hf_logits[0, 0:5]							,   snake_case_							,   atol=1e-3      )

    Path(snake_case_      ).mkdir(exist_ok=snake_case_      )
    print(f"""Saving model {swiftformer_name} to {pytorch_dump_folder_path}"""      )
    hf_model.save_pretrained(snake_case_      )


if __name__ == "__main__":
    _lowerCAmelCase										=     argparse.ArgumentParser()
    # Required parameters
    parser.add_argument(
        '''--swiftformer_name''',
        default='''swiftformer_xs''',
        choices=['''swiftformer_xs''', '''swiftformer_s''', '''swiftformer_l1''', '''swiftformer_l3'''],
        type=str,
        help='''Name of the SwiftFormer model you\'d like to convert.''',
    )
    parser.add_argument(
        '''--pytorch_dump_folder_path''',
        default='''./converted_outputs/''',
        type=str,
        help='''Path to the output PyTorch model directory.''',
    )
    parser.add_argument('''--original_ckpt''', default=None, type=str, help='''Path to the original model checkpoint.''')

    _lowerCAmelCase										=     parser.parse_args()
    convert_swiftformer_checkpoint(args.swiftformer_name, args.pytorch_dump_folder_path, args.original_ckpt)







'''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())


