

"""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 BeitConfig, BeitForImageClassification, BeitForMaskedImageModeling, BeitImageProcessor
from transformers.image_utils import PILImageResampling
from transformers.utils import logging


logging.set_verbosity_info()
SCREAMING_SNAKE_CASE_					:	Optional[Any]							  =						logging.get_logger(__name__)





def  _snake_case     (    UpperCAmelCase_  :					int					,   UpperCAmelCase_  :					Tuple=False					,   UpperCAmelCase_  :					List[str]=False			):
     A__										=  """backbone.""" if is_semantic else """"""

     A__										=  []
     for i in range(config.num_hidden_layers			):
          # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
          rename_keys.append((F"""{prefix}blocks.{i}.norm1.weight""", F"""beit.encoder.layer.{i}.layernorm_before.weight""")			)
          rename_keys.append((F"""{prefix}blocks.{i}.norm1.bias""", F"""beit.encoder.layer.{i}.layernorm_before.bias""")			)
          rename_keys.append(
              (F"""{prefix}blocks.{i}.attn.proj.weight""", F"""beit.encoder.layer.{i}.attention.output.dense.weight""")			)
          rename_keys.append(
              (F"""{prefix}blocks.{i}.attn.proj.bias""", F"""beit.encoder.layer.{i}.attention.output.dense.bias""")			)
          rename_keys.append((F"""{prefix}blocks.{i}.norm2.weight""", F"""beit.encoder.layer.{i}.layernorm_after.weight""")			)
          rename_keys.append((F"""{prefix}blocks.{i}.norm2.bias""", F"""beit.encoder.layer.{i}.layernorm_after.bias""")			)
          rename_keys.append((F"""{prefix}blocks.{i}.mlp.fc1.weight""", F"""beit.encoder.layer.{i}.intermediate.dense.weight""")			)
          rename_keys.append((F"""{prefix}blocks.{i}.mlp.fc1.bias""", F"""beit.encoder.layer.{i}.intermediate.dense.bias""")			)
          rename_keys.append((F"""{prefix}blocks.{i}.mlp.fc2.weight""", F"""beit.encoder.layer.{i}.output.dense.weight""")			)
          rename_keys.append((F"""{prefix}blocks.{i}.mlp.fc2.bias""", F"""beit.encoder.layer.{i}.output.dense.bias""")			)

     # projection layer + position embeddings
     rename_keys.extend(
         [
             (F"""{prefix}cls_token""", """beit.embeddings.cls_token"""),
             (F"""{prefix}patch_embed.proj.weight""", """beit.embeddings.patch_embeddings.projection.weight"""),
             (F"""{prefix}patch_embed.proj.bias""", """beit.embeddings.patch_embeddings.projection.bias"""),
             (F"""{prefix}pos_embed""", """beit.embeddings.position_embeddings"""),
         ]			)

     if has_lm_head:
          # mask token + layernorm
          rename_keys.extend(
              [
                  ("""mask_token""", """beit.embeddings.mask_token"""),
                  ("""norm.weight""", """layernorm.weight"""),
                  ("""norm.bias""", """layernorm.bias"""),
              ]			)
     else:
          # layernorm + classification head
          rename_keys.extend(
              [
                  ("""fc_norm.weight""", """beit.pooler.layernorm.weight"""),
                  ("""fc_norm.bias""", """beit.pooler.layernorm.bias"""),
                  ("""head.weight""", """classifier.weight"""),
                  ("""head.bias""", """classifier.bias"""),
              ]			)

     return rename_keys





def  _snake_case     (    UpperCAmelCase_  :					int					,   UpperCAmelCase_  :					Optional[int]					,   UpperCAmelCase_  :					Tuple=False					,   UpperCAmelCase_  :					Optional[Any]=False			):
     for i in range(config.num_hidden_layers			):
          A__										=  """backbone.""" if is_semantic else """"""
          # queries, keys and values
          A__										=  state_dict.pop(F"""{prefix}blocks.{i}.attn.qkv.weight"""			)
          A__										=  state_dict.pop(F"""{prefix}blocks.{i}.attn.q_bias"""			)
          A__										=  state_dict.pop(F"""{prefix}blocks.{i}.attn.v_bias"""			)

          A__										=  in_proj_weight[
              : config.hidden_size, :
          ]
          A__										=  q_bias
          A__										=  in_proj_weight[
              config.hidden_size : config.hidden_size * 2, :
          ]
          A__										=  in_proj_weight[
              -config.hidden_size :, :
          ]
          A__										=  v_bias

          # gamma_1 and gamma_2
          # we call them lambda because otherwise they are renamed when using .from_pretrained
          A__										=  state_dict.pop(F"""{prefix}blocks.{i}.gamma_1"""			)
          A__										=  state_dict.pop(F"""{prefix}blocks.{i}.gamma_2"""			)

          A__										=  gamma_a
          A__										=  gamma_a





def  _snake_case     (    UpperCAmelCase_  :					Union[str, Any]					,   UpperCAmelCase_  :					Optional[int]					,   UpperCAmelCase_  :					Optional[Any]			):
     A__										=  dct.pop(UpperCAmelCase_			)
     A__										=  val





def  _snake_case     (    ):
     A__										=  """http://images.cocodataset.org/val2017/000000039769.jpg"""
     A__										=  Image.open(requests.get(UpperCAmelCase_					,   stream=UpperCAmelCase_			).raw			)
     return im





@torch.no_grad()
def  _snake_case     (    UpperCAmelCase_  :					Tuple					,   UpperCAmelCase_  :					str					,   UpperCAmelCase_  :					Any=False			):
     A__										=  False if """rvlcdip""" in checkpoint_url else True
     A__										=  BeitConfig(use_absolute_position_embeddings=UpperCAmelCase_					,   use_mask_token=UpperCAmelCase_			)

     # size of the architecture
     if "large" in checkpoint_url or "dit-l" in checkpoint_url:
          A__										=  1024
          A__										=  4096
          A__										=  24
          A__										=  16

     # labels
     if "rvlcdip" in checkpoint_url:
          A__										=  16
          A__										=  """huggingface/label-files"""
          A__										=  """rvlcdip-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__										=  idalabel
          A__										=  {v: k for k, v in idalabel.items()}

     # load state_dict of original model, remove and rename some keys
     A__										=  torch.hub.load_state_dict_from_url(UpperCAmelCase_					,   map_location="""cpu"""			)["""model"""]

     A__										=  create_rename_keys(UpperCAmelCase_					,   has_lm_head=UpperCAmelCase_			)
     for src, dest in rename_keys:
          rename_key(UpperCAmelCase_					,   UpperCAmelCase_					,   UpperCAmelCase_			)
     read_in_q_k_v(UpperCAmelCase_					,   UpperCAmelCase_					,   has_lm_head=UpperCAmelCase_			)

     # load HuggingFace model
     A__										=  BeitForMaskedImageModeling(UpperCAmelCase_			) if has_lm_head else BeitForImageClassification(UpperCAmelCase_			)
     model.eval()
     model.load_state_dict(UpperCAmelCase_			)

     # Check outputs on an image
     A__										=  BeitImageProcessor(
         size=config.image_size					,   resample=PILImageResampling.BILINEAR					,   do_center_crop=UpperCAmelCase_			)
     A__										=  prepare_img()

     A__										=  image_processor(images=UpperCAmelCase_					,   return_tensors="""pt"""			)
     A__										=  encoding["""pixel_values"""]

     A__										=  model(UpperCAmelCase_			)
     A__										=  outputs.logits

     # verify logits
     A__										=  [1, 16] if """rvlcdip""" in checkpoint_url else [1, 196, 8192]
     assert logits.shape == torch.Size(UpperCAmelCase_			), "Shape of logits not as expected"

     Path(UpperCAmelCase_			).mkdir(exist_ok=UpperCAmelCase_			)
     print(F"""Saving model to {pytorch_dump_folder_path}"""			)
     model.save_pretrained(UpperCAmelCase_			)
     print(F"""Saving image processor to {pytorch_dump_folder_path}"""			)
     image_processor.save_pretrained(UpperCAmelCase_			)

     if push_to_hub:
          if has_lm_head:
               A__										=  """dit-base""" if """base""" in checkpoint_url else """dit-large"""
          else:
               A__										=  """dit-base-finetuned-rvlcdip""" if """dit-b""" in checkpoint_url else """dit-large-finetuned-rvlcdip"""
          image_processor.push_to_hub(
              repo_path_or_name=Path(UpperCAmelCase_					,   UpperCAmelCase_			)					,   organization="""nielsr"""					,   commit_message="""Add image processor"""					,   use_temp_dir=UpperCAmelCase_					,   )
          model.push_to_hub(
              repo_path_or_name=Path(UpperCAmelCase_					,   UpperCAmelCase_			)					,   organization="""nielsr"""					,   commit_message="""Add model"""					,   use_temp_dir=UpperCAmelCase_					,   )


if __name__ == "__main__":
 SCREAMING_SNAKE_CASE_					:	Any							  =						argparse.ArgumentParser()

 parser.add_argument(
     '--checkpoint_url',
     default='https://layoutlm.blob.core.windows.net/dit/dit-pts/dit-base-224-p16-500k-62d53a.pth',
     type=str,
     help='URL to the original PyTorch checkpoint (.pth file).',
 )
 parser.add_argument(
     '--pytorch_dump_folder_path', default=None, type=str, help='Path to the folder to output PyTorch model.'
 )
 parser.add_argument(
     '--push_to_hub',
     action='store_true',
 )
 SCREAMING_SNAKE_CASE_					:	Union[str, Any]							  =						parser.parse_args()
 convert_dit_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.push_to_hub)









"""simple docstring"""



from collections.abc import Callable





def  _snake_case     (    UpperCAmelCase_  :					Callable[[float], float]					,   UpperCAmelCase_  :					float					,   UpperCAmelCase_  :					float			):
     A__										=  a
     A__										=  b
     if function(UpperCAmelCase_			) == 0:  # one of the a or b is a root for the function
          return a
     elif function(UpperCAmelCase_			) == 0:
          return b
     elif (
         function(UpperCAmelCase_			) * function(UpperCAmelCase_			) > 0
     ):  # if none of these are root and they are both positive or negative,
          # then this algorithm can't find the root
          raise ValueError("""could not find root in given interval."""			)
     else:
          A__										=  start + (end - start) / 2.0
          while abs(start - mid			) > 10**-7:  # until precisely equals to 10^-7
               if function(UpperCAmelCase_			) == 0:
                    return mid
               elif function(UpperCAmelCase_			) * function(UpperCAmelCase_			) < 0:
                    A__										=  mid
               else:
                    A__										=  mid
               A__										=  start + (end - start) / 2.0
          return mid





def  _snake_case     (    UpperCAmelCase_  :					float			):
     return x**3 - 2 * x - 5


if __name__ == "__main__":
 print(bisection(f, 1, 1_0_0_0))

 import doctest

 doctest.testmod()






