






# This code is adapted from OpenAI's release
# https://github.com/openai/human-eval/blob/master/human_eval/execution.py

import contextlib
import faulthandler
import io
import multiprocessing
import os
import platform
import signal
import tempfile



def       _SCREAMING_SNAKE_CASE    (			__lowercase :      List[str]      ,					__lowercase :      Tuple      ,					__lowercase :      Union[str, Any]      ,					__lowercase :      List[Any]     )    ->   Optional[int]:





    """simple docstring"""

    __A       =						multiprocessing.Manager()
    __A       =						manager.list()

    __A       =						multiprocessing.Process(target=UpperCamelCase_      ,					args=(check_program, result, timeout)     )
    p.start()
    p.join(timeout=timeout + 1     )
    if p.is_alive():
        p.kill()

    if not result:
        result.append("""timed out"""     )

    return {
        "task_id": task_id,
        "passed": result[0] == "passed",
        "result": result[0],
        "completion_id": completion_id,
    }



def       _SCREAMING_SNAKE_CASE    (			__lowercase :      Optional[int]      ,					__lowercase :      Optional[Any]      ,					__lowercase :      Optional[Any]     )    ->   Optional[Any]:





    """simple docstring"""

    with create_tempdir():
        # These system calls are needed when cleaning up tempdir.
        import os
        import shutil

        __A       =						shutil.rmtree
        __A       =						os.rmdir
        __A       =						os.chdir

        # Disable functionalities that can make destructive changes to the test.
        reliability_guard()

        # Run program.
        try:
            __A       =						{}
            with swallow_io():
                with time_limit(UpperCamelCase_     ):
                    exec(UpperCamelCase_      ,					UpperCamelCase_     )
            result.append("""passed"""     )
        except TimeoutException:
            result.append("""timed out"""     )
        except BaseException as e:
            result.append(f"failed: {e}"     )

        # Needed for cleaning up.
        __A       =						rmtree
        __A       =						rmdir
        __A       =						chdir



@contextlib.contextmanager
def       _SCREAMING_SNAKE_CASE    (			__lowercase :      Dict     )    ->   int:





    """simple docstring"""

    def signal_handler(__lowercase :      Optional[Any]      ,					__lowercase :      List[Any]     ):
        raise TimeoutException("""Timed out!"""     )

    signal.setitimer(signal.ITIMER_REAL      ,					UpperCamelCase_     )
    signal.signal(signal.SIGALRM      ,					UpperCamelCase_     )
    try:
        yield
    finally:
        signal.setitimer(signal.ITIMER_REAL      ,					0     )



@contextlib.contextmanager
def       _SCREAMING_SNAKE_CASE    (			)    ->   Optional[Any]:





    """simple docstring"""

    __A       =						WriteOnlyStringIO()
    with contextlib.redirect_stdout(UpperCamelCase_     ):
        with contextlib.redirect_stderr(UpperCamelCase_     ):
            with redirect_stdin(UpperCamelCase_     ):
                yield



@contextlib.contextmanager
def       _SCREAMING_SNAKE_CASE    (			)    ->   List[Any]:





    """simple docstring"""

    with tempfile.TemporaryDirectory() as dirname:
        with chdir(UpperCamelCase_     ):
            yield dirname


class    __lowercase   (						A__	):







     '''simple docstring'''
     pass


class    __lowercase   (						io.StringIO	):







     '''simple docstring'''




     def 		lowerCAmelCase_  (					self							:      List[str]			,						*UpperCamelCase_							:      Tuple			,						**UpperCamelCase_							:      Optional[int]					):


         """simple docstring"""



         raise OSError




     def 		lowerCAmelCase_  (					self							:      Optional[int]			,						*UpperCamelCase_							:      Optional[int]			,						**UpperCamelCase_							:      Optional[int]					):


         """simple docstring"""



         raise OSError




     def 		lowerCAmelCase_  (					self							:      Optional[int]			,						*UpperCamelCase_							:      int			,						**UpperCamelCase_							:      Optional[int]					):


         """simple docstring"""



         raise OSError





     def 		lowerCAmelCase_  (					self							:      List[Any]			,						*UpperCamelCase_							:      Any			,						**UpperCamelCase_							:      str					):


         """simple docstring"""



         return False


class    __lowercase   (						contextlib._RedirectStream	):  # type: ignore







     '''simple docstring'''
     SCREAMING_SNAKE_CASE     =					"stdin"



@contextlib.contextmanager
def       _SCREAMING_SNAKE_CASE    (			__lowercase :      str     )    ->   str:





    """simple docstring"""

    if root == ".":
        yield
        return
    __A       =						os.getcwd()
    os.chdir(UpperCamelCase_     )
    try:
        yield
    except BaseException as exc:
        raise exc
    finally:
        os.chdir(UpperCamelCase_     )






def       _SCREAMING_SNAKE_CASE    (			__lowercase :      Dict=None     )    ->   int:





    """simple docstring"""

    if maximum_memory_bytes is not None:
        import resource

        resource.setrlimit(resource.RLIMIT_AS      ,					(maximum_memory_bytes, maximum_memory_bytes)     )
        resource.setrlimit(resource.RLIMIT_DATA      ,					(maximum_memory_bytes, maximum_memory_bytes)     )
        if not platform.uname().system == "Darwin":
            resource.setrlimit(resource.RLIMIT_STACK      ,					(maximum_memory_bytes, maximum_memory_bytes)     )

    faulthandler.disable()

    import builtins

    __A       =						None
    __A       =						None

    import os

    __A       =						"""1"""

    __A       =						None
    __A       =						None
    __A       =						None
    __A       =						None
    __A       =						None
    __A       =						None
    __A       =						None
    __A       =						None
    __A       =						None
    __A       =						None
    __A       =						None
    __A       =						None
    __A       =						None
    __A       =						None
    __A       =						None
    __A       =						None
    __A       =						None
    __A       =						None
    __A       =						None
    __A       =						None
    __A       =						None
    __A       =						None
    __A       =						None
    __A       =						None
    __A       =						None
    __A       =						None
    __A       =						None

    import shutil

    __A       =						None
    __A       =						None
    __A       =						None

    import subprocess

    __A       =						None  # type: ignore

    __A       =						None

    import sys

    __A       =						None
    __A       =						None
    __A       =						None
    __A       =						None
    __A       =						None









import argparse
import json
from pathlib import Path

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image
from timm import create_model
from timm.data import resolve_data_config
from timm.data.transforms_factory import create_transform

from transformers import BitConfig, BitForImageClassification, BitImageProcessor
from transformers.image_utils import PILImageResampling
from transformers.utils import logging


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



def 		lowerCAmelCase__     (       UpperCamelCase_					:							str						)->	int:
    A__					=       '''huggingface/label-files'''
    A__					=       '''imagenet-1k-id2label.json'''
    A__					=       json.load(open(hf_hub_download(UpperCamelCase_			,							UpperCamelCase_			,							repo_type='''dataset'''						)			,							'''r'''						)						)
    A__					=       {int(UpperCamelCase_						): v for k, v in idalabel.items()}
    A__					=       {v: k for k, v in idalabel.items()}

    A__					=       '''std_conv''' if '''bit''' in model_name else False

    # note that when using BiT as backbone for ViT-hybrid checkpoints,
    # one needs to additionally set config.layer_type = "bottleneck", config.stem_type = "same",
    # config.conv_layer = "std_conv_same"
    A__					=       BitConfig(
        conv_layer=UpperCamelCase_			,							num_labels=1_0_0_0			,							idalabel=UpperCamelCase_			,							labelaid=UpperCamelCase_			,							)

    return config



def 		lowerCAmelCase__     (       UpperCamelCase_					:							List[Any]						)->	Optional[int]:
    if "stem.conv" in name:
        A__					=       name.replace('''stem.conv'''			,							'''bit.embedder.convolution'''						)
    if "blocks" in name:
        A__					=       name.replace('''blocks'''			,							'''layers'''						)
    if "head.fc" in name:
        A__					=       name.replace('''head.fc'''			,							'''classifier.1'''						)
    if name.startswith('''norm'''						):
        A__					=       '''bit.''' + name
    if "bit" not in name and "classifier" not in name:
        A__					=       '''bit.encoder.''' + name

    return name



def 		lowerCAmelCase__     (       )->	str:
    A__					=       '''http://images.cocodataset.org/val2017/000000039769.jpg'''
    A__					=       Image.open(requests.get(UpperCamelCase_			,							stream=UpperCamelCase_						).raw						)
    return im



@torch.no_grad()
def 		lowerCAmelCase__     (       UpperCamelCase_					:							List[str]			,							UpperCamelCase_					:							Tuple			,							UpperCamelCase_					:							List[Any]=False						)->	Optional[int]:
    A__					=       get_config(UpperCamelCase_						)

    # load original model from timm
    A__					=       create_model(UpperCamelCase_			,							pretrained=UpperCamelCase_						)
    timm_model.eval()

    # load state_dict of original model
    A__					=       timm_model.state_dict()
    for key in state_dict.copy().keys():
        A__					=       state_dict.pop(UpperCamelCase_						)
        A__					=       val.squeeze() if '''head''' in key else val

    # load HuggingFace model
    A__					=       BitForImageClassification(UpperCamelCase_						)
    model.eval()
    model.load_state_dict(UpperCamelCase_						)

    # create image processor
    A__					=       create_transform(**resolve_data_config({}			,							model=UpperCamelCase_						)						)
    A__					=       transform.transforms

    A__					=       {
        '''bilinear''': PILImageResampling.BILINEAR,
        '''bicubic''': PILImageResampling.BICUBIC,
        '''nearest''': PILImageResampling.NEAREST,
    }

    A__					=       BitImageProcessor(
        do_resize=UpperCamelCase_			,							size={'''shortest_edge''': timm_transforms[0].size}			,							resample=pillow_resamplings[timm_transforms[0].interpolation.value]			,							do_center_crop=UpperCamelCase_			,							crop_size={'''height''': timm_transforms[1].size[0], '''width''': timm_transforms[1].size[1]}			,							do_normalize=UpperCamelCase_			,							image_mean=timm_transforms[-1].mean.tolist()			,							image_std=timm_transforms[-1].std.tolist()			,							)

    A__					=       prepare_img()
    A__					=       transform(UpperCamelCase_						).unsqueeze(0						)
    A__					=       processor(UpperCamelCase_			,							return_tensors='''pt'''						).pixel_values

    # verify pixel values
    assert torch.allclose(UpperCamelCase_			,							UpperCamelCase_						)

    # verify logits
    with torch.no_grad():
        A__					=       model(UpperCamelCase_						)
        A__					=       outputs.logits

    print('''Logits:'''			,							logits[0, :3]						)
    print('''Predicted class:'''			,							model.config.idalabel[logits.argmax(-1						).item()]						)
    A__					=       timm_model(UpperCamelCase_						)
    assert timm_logits.shape == outputs.logits.shape
    assert torch.allclose(UpperCamelCase_			,							outputs.logits			,							atol=1E-3						)
    print('''Looks ok!'''						)

    if pytorch_dump_folder_path is not None:
        Path(UpperCamelCase_						).mkdir(exist_ok=UpperCamelCase_						)
        print(f"Saving model {model_name} and processor to {pytorch_dump_folder_path}"						)
        model.save_pretrained(UpperCamelCase_						)
        processor.save_pretrained(UpperCamelCase_						)

    if push_to_hub:
        print(f"Pushing model {model_name} and processor to the hub"						)
        model.push_to_hub(f"ybelkada/{model_name}"						)
        processor.push_to_hub(f"ybelkada/{model_name}"						)


if __name__ == "__main__":
   _lowercase    	=		argparse.ArgumentParser()
   # Required parameters
   parser.add_argument(
       "--model_name",
       default="resnetv2_50x1_bitm",
       type=str,
       help="Name of the BiT 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."
   )
   parser.add_argument(
       "--push_to_hub",
       action="store_true",
       help="Whether to push the model to the hub.",
   )

   _lowercase    	=		parser.parse_args()
   convert_bit_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)
