






import argparse

import torch
from datasets import load_dataset
from donut import DonutModel

from transformers import (
    DonutImageProcessor,
    DonutProcessor,
    DonutSwinConfig,
    DonutSwinModel,
    MBartConfig,
    MBartForCausalLM,
    VisionEncoderDecoderModel,
    XLMRobertaTokenizerFast,
)






def 					__lowercase      (     _A			)     ->						Dict:
      SCREAMING_SNAKE_CASE :      Dict       =   model.config

      SCREAMING_SNAKE_CASE :      Union[str, Any]       =   DonutSwinConfig(
          image_size=original_config.input_size						,    patch_size=4						,    depths=original_config.encoder_layer						,    num_heads=[4, 8, 16, 32]						,    window_size=original_config.window_size						,    embed_dim=128						,    )
      SCREAMING_SNAKE_CASE :      str       =   MBartConfig(
          is_decoder=_A						,    is_encoder_decoder=_A						,    add_cross_attention=_A						,    decoder_layers=original_config.decoder_layer						,    max_position_embeddings=original_config.max_position_embeddings						,    vocab_size=len(
              model.decoder.tokenizer			)						,    scale_embedding=_A						,    add_final_layer_norm=_A						,    )

      return encoder_config, decoder_config






def 					__lowercase      (     _A			)     ->						Union[str, Any]:
      if "encoder.model" in name:
            SCREAMING_SNAKE_CASE :      List[str]       =   name.replace("""encoder.model"""						,    """encoder"""			)
      if "decoder.model" in name:
            SCREAMING_SNAKE_CASE :      Tuple       =   name.replace("""decoder.model"""						,    """decoder"""			)
      if "patch_embed.proj" in name:
            SCREAMING_SNAKE_CASE :      List[str]       =   name.replace("""patch_embed.proj"""						,    """embeddings.patch_embeddings.projection"""			)
      if "patch_embed.norm" in name:
            SCREAMING_SNAKE_CASE :      List[Any]       =   name.replace("""patch_embed.norm"""						,    """embeddings.norm"""			)
      if name.startswith("""encoder"""			):
            if "layers" in name:
                  SCREAMING_SNAKE_CASE :      int       =   """encoder.""" + name
            if "attn.proj" in name:
                  SCREAMING_SNAKE_CASE :      Dict       =   name.replace("""attn.proj"""						,    """attention.output.dense"""			)
            if "attn" in name and "mask" not in name:
                  SCREAMING_SNAKE_CASE :      Any       =   name.replace("""attn"""						,    """attention.self"""			)
            if "norm1" in name:
                  SCREAMING_SNAKE_CASE :      Optional[int]       =   name.replace("""norm1"""						,    """layernorm_before"""			)
            if "norm2" in name:
                  SCREAMING_SNAKE_CASE :      Union[str, Any]       =   name.replace("""norm2"""						,    """layernorm_after"""			)
            if "mlp.fc1" in name:
                  SCREAMING_SNAKE_CASE :      Optional[Any]       =   name.replace("""mlp.fc1"""						,    """intermediate.dense"""			)
            if "mlp.fc2" in name:
                  SCREAMING_SNAKE_CASE :      List[Any]       =   name.replace("""mlp.fc2"""						,    """output.dense"""			)

            if name == "encoder.norm.weight":
                  SCREAMING_SNAKE_CASE :      Dict       =   """encoder.layernorm.weight"""
            if name == "encoder.norm.bias":
                  SCREAMING_SNAKE_CASE :      Union[str, Any]       =   """encoder.layernorm.bias"""

      return name






def 					__lowercase      (     _A						,    _A			)     ->						Union[str, Any]:
      for key in orig_state_dict.copy().keys():
            SCREAMING_SNAKE_CASE :      Any       =   orig_state_dict.pop(_A			)

            if "qkv" in key:
                  SCREAMING_SNAKE_CASE :      Optional[int]       =   key.split("""."""			)
                  SCREAMING_SNAKE_CASE :      Union[str, Any]       =   int(key_split[3]			)
                  SCREAMING_SNAKE_CASE :      Optional[int]       =   int(key_split[5]			)
                  SCREAMING_SNAKE_CASE :      str       =   model.encoder.encoder.layers[layer_num].blocks[block_num].attention.self.all_head_size

                  if "weight" in key:
                        SCREAMING_SNAKE_CASE :      Dict       =   val[:dim, :]
                        SCREAMING_SNAKE_CASE :      Any       =   val[dim : dim * 2, :]
                        SCREAMING_SNAKE_CASE :      List[str]       =   val[-dim:, :]
                  else:
                        SCREAMING_SNAKE_CASE :      Any       =   val[:dim]
                        SCREAMING_SNAKE_CASE :      Union[str, Any]       =   val[dim : dim * 2]
                        SCREAMING_SNAKE_CASE :      List[Any]       =   val[-dim:]
            elif "attn_mask" in key or key in ["encoder.model.norm.weight", "encoder.model.norm.bias"]:
                  # HuggingFace implementation doesn't use attn_mask buffer
                  # and model doesn't use final LayerNorms for the encoder
                  pass
            else:
                  SCREAMING_SNAKE_CASE :      Optional[int]       =   val

      return orig_state_dict






def 					__lowercase      (     _A						,    _A=None						,    _A=False			)     ->						str:
      # load original model
      SCREAMING_SNAKE_CASE :      Any       =   DonutModel.from_pretrained(_A			).eval()

      # load HuggingFace model
      SCREAMING_SNAKE_CASE :      List[str]       =   get_configs(_A			)
      SCREAMING_SNAKE_CASE :      str       =   DonutSwinModel(_A			)
      SCREAMING_SNAKE_CASE :      Tuple       =   MBartForCausalLM(_A			)
      SCREAMING_SNAKE_CASE :      int       =   VisionEncoderDecoderModel(encoder=_A						,    decoder=_A			)
      model.eval()

      SCREAMING_SNAKE_CASE :      List[Any]       =   original_model.state_dict()
      SCREAMING_SNAKE_CASE :      Optional[int]       =   convert_state_dict(_A						,    _A			)
      model.load_state_dict(_A			)

      # verify results on scanned document
      SCREAMING_SNAKE_CASE :      Optional[int]       =   load_dataset("""hf-internal-testing/example-documents"""			)
      SCREAMING_SNAKE_CASE :      Optional[Any]       =   dataset["""test"""][0]["""image"""].convert("""RGB"""			)

      SCREAMING_SNAKE_CASE :      Tuple       =   XLMRobertaTokenizerFast.from_pretrained(_A						,    from_slow=_A			)
      SCREAMING_SNAKE_CASE :      Any       =   DonutImageProcessor(
          do_align_long_axis=original_model.config.align_long_axis						,    size=original_model.config.input_size[::-1]			)
      SCREAMING_SNAKE_CASE :      Optional[Any]       =   DonutProcessor(_A						,    _A			)
      SCREAMING_SNAKE_CASE :      Tuple       =   processor(_A						,    return_tensors="""pt"""			).pixel_values

      if model_name == "naver-clova-ix/donut-base-finetuned-docvqa":
            SCREAMING_SNAKE_CASE :      str       =   """<s_docvqa><s_question>{user_input}</s_question><s_answer>"""
            SCREAMING_SNAKE_CASE :      int       =   """When is the coffee break?"""
            SCREAMING_SNAKE_CASE :      Optional[Any]       =   task_prompt.replace("""{user_input}"""						,    _A			)
      elif model_name == "naver-clova-ix/donut-base-finetuned-rvlcdip":
            SCREAMING_SNAKE_CASE :      Optional[Any]       =   """<s_rvlcdip>"""
      elif model_name in [
          "naver-clova-ix/donut-base-finetuned-cord-v1",
          "naver-clova-ix/donut-base-finetuned-cord-v1-2560",
      ]:
            SCREAMING_SNAKE_CASE :      Union[str, Any]       =   """<s_cord>"""
      elif model_name == "naver-clova-ix/donut-base-finetuned-cord-v2":
            SCREAMING_SNAKE_CASE :      Any       =   """s_cord-v2>"""
      elif model_name == "naver-clova-ix/donut-base-finetuned-zhtrainticket":
            SCREAMING_SNAKE_CASE :      List[str]       =   """<s_zhtrainticket>"""
      elif model_name in ["naver-clova-ix/donut-proto", "naver-clova-ix/donut-base"]:
            # use a random prompt
            SCREAMING_SNAKE_CASE :      Any       =   """hello world"""
      else:
            raise ValueError("""Model name not supported"""			)
      SCREAMING_SNAKE_CASE :      Optional[Any]       =   original_model.decoder.tokenizer(_A						,    add_special_tokens=_A						,    return_tensors="""pt"""			)[
          """input_ids"""
      ]

      SCREAMING_SNAKE_CASE :      List[str]       =   original_model.encoder.model.patch_embed(_A			)
      SCREAMING_SNAKE_CASE :      List[Any]       =   model.encoder.embeddings(_A			)
      assert torch.allclose(_A						,    _A						,    atol=1e-3			)

      # verify encoder hidden states
      SCREAMING_SNAKE_CASE :      List[str]       =   original_model.encoder(_A			)
      SCREAMING_SNAKE_CASE :      int       =   model.encoder(_A			).last_hidden_state
      assert torch.allclose(_A						,    _A						,    atol=1e-2			)

      # verify decoder hidden states
      SCREAMING_SNAKE_CASE :      Tuple       =   original_model(_A						,    _A						,    _A			).logits
      SCREAMING_SNAKE_CASE :      Dict       =   model(_A						,    decoder_input_ids=_A			).logits
      assert torch.allclose(_A						,    _A						,    atol=1e-3			)
      print("""Looks ok!"""			)

      if pytorch_dump_folder_path is not None:
            print(F"Saving model and processor to {pytorch_dump_folder_path}"			)
            model.save_pretrained(_A			)
            processor.save_pretrained(_A			)

      if push_to_hub:
            model.push_to_hub("""nielsr/""" + model_name.split("""/"""			)[-1]						,    commit_message="""Update model"""			)
            processor.push_to_hub("""nielsr/""" + model_name.split("""/"""			)[-1]						,    commit_message="""Update model"""			)


if __name__ == "__main__":
  UpperCAmelCase__ :     Tuple				    =    argparse.ArgumentParser()
  # Required parameters
  parser.add_argument(
      """--model_name""",
      default="""naver-clova-ix/donut-base-finetuned-docvqa""",
      required=False,
      type=str,
      help="""Name of the original model you'd like to convert.""",
  )
  parser.add_argument(
      """--pytorch_dump_folder_path""",
      default=None,
      required=False,
      type=str,
      help="""Path to the output PyTorch model directory.""",
  )
  parser.add_argument(
      """--push_to_hub""",
      action="""store_true""",
      help="""Whether or not to push the converted model and processor to the 🤗 hub.""",
  )

  UpperCAmelCase__ :     Union[str, Any]				    =    parser.parse_args()
  convert_donut_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)







from typing import Any

import numpy as np






def 					__lowercase      (     _A			)     ->						bool:
      return np.array_equal(_A						,    matrix.conjugate().T			)






def 					__lowercase      (     _A						,    _A			)     ->						Any:
      SCREAMING_SNAKE_CASE :      Optional[int]       =   v.conjugate().T
      SCREAMING_SNAKE_CASE :      List[Any]       =   v_star.dot(_A			)
      assert isinstance(_A						,    np.ndarray			)
      return (v_star_dot.dot(_A			)) / (v_star.dot(_A			))






def 					__lowercase      (     )     ->						None:
      SCREAMING_SNAKE_CASE :      Any       =   np.array([[2, 2 + 1J, 4], [2 - 1J, 3, 1J], [4, -1J, 1]]			)
      SCREAMING_SNAKE_CASE :      Optional[int]       =   np.array([[1], [2], [3]]			)
      assert is_hermitian(_A			), F"{a} is not hermitian."
      print(rayleigh_quotient(_A						,    _A			)			)

      SCREAMING_SNAKE_CASE :      Any       =   np.array([[1, 2, 4], [2, 3, -1], [4, -1, 1]]			)
      assert is_hermitian(_A			), F"{a} is not hermitian."
      assert rayleigh_quotient(_A						,    _A			) == float(3			)


if __name__ == "__main__":
  import doctest

  doctest.testmod()
  tests()




