





"""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 ViTConfig, ViTForImageClassification, ViTImageProcessor, ViTModel
from transformers.utils import logging


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

def       __lowerCamelCase    (       SCREAMING_SNAKE_CASE,SCREAMING_SNAKE_CASE=False							)		->       str:






       """simple docstring"""




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

       # projection layer + position embeddings
       rename_keys.extend(
           [
               ('cls_token', 'vit.embeddings.cls_token'),
               ('patch_embed.proj.weight', 'vit.embeddings.patch_embeddings.projection.weight'),
               ('patch_embed.proj.bias', 'vit.embeddings.patch_embeddings.projection.bias'),
               ('pos_embed', 'vit.embeddings.position_embeddings'),
           ]							)

       if base_model:
              # layernorm + pooler
              rename_keys.extend(
                  [
                      ('norm.weight', 'layernorm.weight'),
                      ('norm.bias', 'layernorm.bias'),
                  ]							)

              # if just the base model, we should remove "vit" from all keys that start with "vit"
              _UpperCAmelCase     =     [(pair[0], pair[1][4:]) if pair[1].startswith('vit'							) else pair for pair in rename_keys]
       else:
              # layernorm + classification head
              rename_keys.extend(
                  [
                      ('norm.weight', 'vit.layernorm.weight'),
                      ('norm.bias', 'vit.layernorm.bias'),
                      ('head.weight', 'classifier.weight'),
                      ('head.bias', 'classifier.bias'),
                  ]							)

       return rename_keys

def       __lowerCamelCase    (       SCREAMING_SNAKE_CASE,SCREAMING_SNAKE_CASE,SCREAMING_SNAKE_CASE=False							)		->       int:






       """simple docstring"""




       for i in range(config.num_hidden_layers							):
              if base_model:
                     _UpperCAmelCase     =     ''
              else:
                     _UpperCAmelCase     =     'vit.'
              # read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
              _UpperCAmelCase     =     state_dict.pop(F"""blocks.{i}.attn.qkv.weight"""							)
              _UpperCAmelCase     =     state_dict.pop(F"""blocks.{i}.attn.qkv.bias"""							)
              # next, add query, keys and values (in that order) to the state dict
              _UpperCAmelCase     =     in_proj_weight[
                  : config.hidden_size, :
              ]
              _UpperCAmelCase     =     in_proj_bias[: config.hidden_size]
              _UpperCAmelCase     =     in_proj_weight[
                  config.hidden_size : config.hidden_size * 2, :
              ]
              _UpperCAmelCase     =     in_proj_bias[
                  config.hidden_size : config.hidden_size * 2
              ]
              _UpperCAmelCase     =     in_proj_weight[
                  -config.hidden_size :, :
              ]
              _UpperCAmelCase     =     in_proj_bias[-config.hidden_size :]

def       __lowerCamelCase    (       SCREAMING_SNAKE_CASE							)		->       Tuple:






       """simple docstring"""




       _UpperCAmelCase     =     ['head.weight', 'head.bias']
       for k in ignore_keys:
              state_dict.pop(SCREAMING_SNAKE_CASE,SCREAMING_SNAKE_CASE							)

def       __lowerCamelCase    (       SCREAMING_SNAKE_CASE,SCREAMING_SNAKE_CASE,SCREAMING_SNAKE_CASE							)		->       Optional[Any]:






       """simple docstring"""




       _UpperCAmelCase     =     dct.pop(SCREAMING_SNAKE_CASE							)
       _UpperCAmelCase     =     val

def       __lowerCamelCase    (       )		->       str:






       """simple docstring"""




       _UpperCAmelCase     =     'http://images.cocodataset.org/val2017/000000039769.jpg'
       _UpperCAmelCase     =     Image.open(requests.get(SCREAMING_SNAKE_CASE,stream=SCREAMING_SNAKE_CASE							).raw							)
       return im

@torch.no_grad()
def       __lowerCamelCase    (       SCREAMING_SNAKE_CASE,SCREAMING_SNAKE_CASE,SCREAMING_SNAKE_CASE=True							)		->       Optional[Any]:






       """simple docstring"""




       _UpperCAmelCase     =     ViTConfig()
       # patch_size
       if model_name[-1] == "8":
              _UpperCAmelCase     =     8
       # set labels if required
       if not base_model:
              _UpperCAmelCase     =     1000
              _UpperCAmelCase     =     'huggingface/label-files'
              _UpperCAmelCase     =     'imagenet-1k-id2label.json'
              _UpperCAmelCase     =     json.load(open(hf_hub_download(SCREAMING_SNAKE_CASE,SCREAMING_SNAKE_CASE,repo_type='dataset'							),'r'							)							)
              _UpperCAmelCase     =     {int(SCREAMING_SNAKE_CASE							): v for k, v in idalabel.items()}
              _UpperCAmelCase     =     idalabel
              _UpperCAmelCase     =     {v: k for k, v in idalabel.items()}
       # size of the architecture
       if model_name in ["dino_vits8", "dino_vits16"]:
              _UpperCAmelCase     =     384
              _UpperCAmelCase     =     1536
              _UpperCAmelCase     =     12
              _UpperCAmelCase     =     6

       # load original model from torch hub
       _UpperCAmelCase     =     torch.hub.load('facebookresearch/dino:main',SCREAMING_SNAKE_CASE							)
       original_model.eval()

       # load state_dict of original model, remove and rename some keys
       _UpperCAmelCase     =     original_model.state_dict()
       if base_model:
              remove_classification_head_(SCREAMING_SNAKE_CASE							)
       _UpperCAmelCase     =     create_rename_keys(SCREAMING_SNAKE_CASE,base_model=SCREAMING_SNAKE_CASE							)
       for src, dest in rename_keys:
              rename_key(SCREAMING_SNAKE_CASE,SCREAMING_SNAKE_CASE,SCREAMING_SNAKE_CASE							)
       read_in_q_k_v(SCREAMING_SNAKE_CASE,SCREAMING_SNAKE_CASE,SCREAMING_SNAKE_CASE							)

       # load HuggingFace model
       if base_model:
              _UpperCAmelCase     =     ViTModel(SCREAMING_SNAKE_CASE,add_pooling_layer=SCREAMING_SNAKE_CASE							).eval()
       else:
              _UpperCAmelCase     =     ViTForImageClassification(SCREAMING_SNAKE_CASE							).eval()
       model.load_state_dict(SCREAMING_SNAKE_CASE							)

       # Check outputs on an image, prepared by ViTImageProcessor
       _UpperCAmelCase     =     ViTImageProcessor()
       _UpperCAmelCase     =     image_processor(images=prepare_img(),return_tensors='pt'							)
       _UpperCAmelCase     =     encoding['pixel_values']
       _UpperCAmelCase     =     model(SCREAMING_SNAKE_CASE							)

       if base_model:
              _UpperCAmelCase     =     original_model(SCREAMING_SNAKE_CASE							)
              assert torch.allclose(SCREAMING_SNAKE_CASE,outputs.last_hidden_state[:, 0, :],atol=1E-1							)
       else:
              _UpperCAmelCase     =     original_model(SCREAMING_SNAKE_CASE							)
              assert logits.shape == outputs.logits.shape
              assert torch.allclose(SCREAMING_SNAKE_CASE,outputs.logits,atol=1E-3							)

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


if __name__ == "__main__":
    lowerCAmelCase_			=							argparse.ArgumentParser()
    # Required parameters
    parser.add_argument(
        '''--model_name''',
        default='''dino_vitb16''',
        type=str,
        help='''Name of the model trained with DINO 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(
        '''--base_model''',
        action='''store_true''',
        help='''Whether to only convert the base model (no projection head weights).''',
    )

    parser.set_defaults(base_model=True)
    lowerCAmelCase_			=							parser.parse_args()
    convert_vit_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.base_model)













"""simple docstring"""






import os
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple

import sentencepiece as spm

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging


lowerCAmelCase_			=							logging.get_logger(__name__)

lowerCAmelCase_			=							'''▁'''

lowerCAmelCase_			=							{'''vocab_file''': '''sentencepiece.bpe.model''', '''monolingual_vocab_file''': '''dict.txt'''}

lowerCAmelCase_			=							{
    '''vocab_file''': {
        '''vinai/bartpho-syllable''': '''https://huggingface.co/vinai/bartpho-syllable/resolve/main/sentencepiece.bpe.model''',
    },
    '''monolingual_vocab_file''': {
        '''vinai/bartpho-syllable''': '''https://huggingface.co/vinai/bartpho-syllable/resolve/main/dict.txt''',
    },
}

lowerCAmelCase_			=							{'''vinai/bartpho-syllable''': 1_024}



class 	lowerCAmelCase					(      snake_case							):
       lowerCAmelCase__						 =  VOCAB_FILES_NAMES
       lowerCAmelCase__						 =  PRETRAINED_VOCAB_FILES_MAP
       lowerCAmelCase__						 =  PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
       lowerCAmelCase__						 =  ["""input_ids""", """attention_mask"""]






       def __init__(   self    ,  a__    ,  a__    ,  a__="<s>"    ,  a__="</s>"    ,  a__="</s>"    ,  a__="<s>"    ,  a__="<unk>"    ,  a__="<pad>"    ,  a__="<mask>"    ,  a__ = None    ,  **a__    ,  ):
              # Mask token behave like a normal word, i.e. include the space before it
              _UpperCAmelCase     =     AddedToken(a__    ,  lstrip=a__    ,  rstrip=a__     ) if isinstance(a__    ,  a__     ) else mask_token

              _UpperCAmelCase     =     {} if sp_model_kwargs is None else sp_model_kwargs

              super().__init__(
                  bos_token=a__    ,  eos_token=a__    ,  unk_token=a__    ,  sep_token=a__    ,  cls_token=a__    ,  pad_token=a__    ,  mask_token=a__    ,  sp_model_kwargs=self.sp_model_kwargs    ,  **a__    ,  )

              _UpperCAmelCase     =     vocab_file
              _UpperCAmelCase     =     monolingual_vocab_file
              _UpperCAmelCase     =     spm.SentencePieceProcessor(**self.sp_model_kwargs     )
              self.sp_model.Load(str(a__     )     )

              # Load the reduced vocab

              # Keep order of special tokens for backward compatibility
              _UpperCAmelCase     =     {}
              _UpperCAmelCase     =     0
              for token in [bos_token, pad_token, eos_token, unk_token, sep_token, cls_token]:
                     if str(a__     ) not in self.fairseq_tokens_to_ids:
                            _UpperCAmelCase     =     cnt
                            cnt += 1
              with open(a__    ,  'r'    ,  encoding='utf-8'     ) as f:
                     for line in f.readlines():
                            _UpperCAmelCase     =     line.strip().split()[0]
                            _UpperCAmelCase     =     len(self.fairseq_tokens_to_ids     )
              if str(a__     ) not in self.fairseq_tokens_to_ids:
                     _UpperCAmelCase     =     len(self.fairseq_tokens_to_ids     )

              _UpperCAmelCase     =     {v: k for k, v in self.fairseq_tokens_to_ids.items()}






       def __getstate__(   self     ):
              _UpperCAmelCase     =     self.__dict__.copy()
              _UpperCAmelCase     =     None
              _UpperCAmelCase     =     self.sp_model.serialized_model_proto()
              return state






       def __setstate__(   self    ,  a__     ):
              _UpperCAmelCase     =     d

              # for backward compatibility
              if not hasattr(self    ,  'sp_model_kwargs'     ):
                     _UpperCAmelCase     =     {}

              _UpperCAmelCase     =     spm.SentencePieceProcessor(**self.sp_model_kwargs     )
              self.sp_model.LoadFromSerializedProto(self.sp_model_proto     )






       def 							__A (   self    ,  a__    ,  a__ = None     ):

              if token_ids_a is None:
                     return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
              _UpperCAmelCase     =     [self.cls_token_id]
              _UpperCAmelCase     =     [self.sep_token_id]
              return cls + token_ids_a + sep + sep + token_ids_a + sep






       def 							__A (   self    ,  a__    ,  a__ = None    ,  a__ = False     ):

              if already_has_special_tokens:
                     return super().get_special_tokens_mask(
                         token_ids_a=a__    ,  token_ids_a=a__    ,  already_has_special_tokens=a__     )

              if token_ids_a is None:
                     return [1] + ([0] * len(a__     )) + [1]
              return [1] + ([0] * len(a__     )) + [1, 1] + ([0] * len(a__     )) + [1]






       def 							__A (   self    ,  a__    ,  a__ = None     ):
              _UpperCAmelCase     =     [self.sep_token_id]
              _UpperCAmelCase     =     [self.cls_token_id]

              if token_ids_a is None:
                     return len(cls + token_ids_a + sep     ) * [0]
              return len(cls + token_ids_a + sep + sep + token_ids_a + sep     ) * [0]






       @property
       def 							__A (   self     ):
              return len(self.fairseq_ids_to_tokens     )






       def 							__A (   self     ):
              _UpperCAmelCase     =     {self.convert_ids_to_tokens(a__     ): i for i in range(self.vocab_size     )}
              vocab.update(self.added_tokens_encoder     )
              return vocab






       def 							__A (   self    ,  a__     ):
              return self.sp_model.encode(a__    ,  out_type=a__     )






       def 							__A (   self    ,  a__     ):
              if token in self.fairseq_tokens_to_ids:
                     return self.fairseq_tokens_to_ids[token]
              else:
                     return self.unk_token_id






       def 							__A (   self    ,  a__     ):
              return self.fairseq_ids_to_tokens[index]






       def 							__A (   self    ,  a__     ):
              _UpperCAmelCase     =     ''.join(a__     ).replace(a__    ,  ' '     ).strip()
              return out_string






       def 							__A (   self    ,  a__    ,  a__ = None     ):
              if not os.path.isdir(a__     ):
                     logger.error(f"""Vocabulary path ({save_directory}) should be a directory"""     )
                     return
              _UpperCAmelCase     =     os.path.join(
                  a__    ,  (filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file']     )
              _UpperCAmelCase     =     os.path.join(
                  a__    ,  (filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['monolingual_vocab_file']    ,  )

              if os.path.abspath(self.vocab_file     ) != os.path.abspath(a__     ) and os.path.isfile(self.vocab_file     ):
                     copyfile(self.vocab_file    ,  a__     )
              elif not os.path.isfile(self.vocab_file     ):
                     with open(a__    ,  'wb'     ) as fi:
                            _UpperCAmelCase     =     self.sp_model.serialized_model_proto()
                            fi.write(a__     )

              if os.path.abspath(self.monolingual_vocab_file     ) != os.path.abspath(
                  a__     ) and os.path.isfile(self.monolingual_vocab_file     ):
                     copyfile(self.monolingual_vocab_file    ,  a__     )
              elif not os.path.isfile(self.monolingual_vocab_file     ):
                     with open(a__    ,  'w'    ,  encoding='utf-8'     ) as fp:
                            for token in self.fairseq_tokens_to_ids:
                                   if token not in self.all_special_tokens:
                                          fp.write(f"""{str(a__     )} \n"""     )

              return out_vocab_file, out_monolingual_vocab_file






