

import copy
import os
from typing import Union

from ...configuration_utils import PretrainedConfig
from ...models.auto.modeling_auto import MODEL_FOR_CAUSAL_LM_MAPPING_NAMES
from ...utils import logging
from ..auto import CONFIG_MAPPING


_SCREAMING_SNAKE_CASE					:  Any             =      logging.get_logger(__name__)

_SCREAMING_SNAKE_CASE					:  List[Any]             =      {
    '''Salesforce/instruct-blip-flan-t5''': '''https://huggingface.co/Salesforce/instruct-blip-flan-t5/resolve/main/config.json''',
}






class 	UpperCAmelCase__		(	A__	):






  """simple docstring"""


  a									= "instructblip_vision_model"






  def __init__(							self						:		Tuple     ,       __lowerCamelCase						:		str=1408     ,       __lowerCamelCase						:		int=6144     ,       __lowerCamelCase						:		Any=39     ,       __lowerCamelCase						:		Dict=16     ,       __lowerCamelCase						:		Dict=224     ,       __lowerCamelCase						:		Tuple=14     ,       __lowerCamelCase						:		Optional[Any]="gelu"     ,       __lowerCamelCase						:		Tuple=1e-6     ,       __lowerCamelCase						:		str=0.0     ,       __lowerCamelCase						:		Any=1e-10     ,       __lowerCamelCase						:		Dict=True     ,       **__lowerCamelCase						:		List[Any]     ,       )		->							Optional[int]:
       super().__init__(**__lowerCamelCase )

       SCREAMING_SNAKE_CASE__   =   hidden_size
       SCREAMING_SNAKE_CASE__   =   intermediate_size
       SCREAMING_SNAKE_CASE__   =   num_hidden_layers
       SCREAMING_SNAKE_CASE__   =   num_attention_heads
       SCREAMING_SNAKE_CASE__   =   patch_size
       SCREAMING_SNAKE_CASE__   =   image_size
       SCREAMING_SNAKE_CASE__   =   initializer_range
       SCREAMING_SNAKE_CASE__   =   attention_dropout
       SCREAMING_SNAKE_CASE__   =   layer_norm_eps
       SCREAMING_SNAKE_CASE__   =   hidden_act
       SCREAMING_SNAKE_CASE__   =   qkv_bias







  @classmethod
  def 				lowercase_		(							cls						:		List[str]     ,       __lowerCamelCase						:		Union[str, os.PathLike]     ,       **__lowerCamelCase						:		List[Any] )		->							"PretrainedConfig":
       cls._set_token_in_kwargs(__lowerCamelCase )

       SCREAMING_SNAKE_CASE__,SCREAMING_SNAKE_CASE__   =   cls.get_config_dict(__lowerCamelCase     ,       **__lowerCamelCase )

       # get the vision config dict if we are loading from InstructBlipConfig
       if config_dict.get('''model_type''' ) == "instructblip":
            SCREAMING_SNAKE_CASE__   =   config_dict['''vision_config''']

       if "model_type" in config_dict and hasattr(cls     ,       '''model_type''' ) and config_dict["model_type"] != cls.model_type:
            logger.warning(
                f'''You are using a model of type {config_dict["model_type"]} to instantiate a model of type '''
                f'''{cls.model_type}. This is not supported for all configurations of models and can yield errors.''' )

       return cls.from_dict(__lowerCamelCase     ,       **__lowerCamelCase )






class 	UpperCAmelCase__		(	A__	):






  """simple docstring"""


  a									= "instructblip_qformer"






  def __init__(							self						:		Dict     ,       __lowerCamelCase						:		Dict=3_0522     ,       __lowerCamelCase						:		str=768     ,       __lowerCamelCase						:		Dict=12     ,       __lowerCamelCase						:		Dict=12     ,       __lowerCamelCase						:		Union[str, Any]=3072     ,       __lowerCamelCase						:		List[str]="gelu"     ,       __lowerCamelCase						:		Union[str, Any]=0.1     ,       __lowerCamelCase						:		Any=0.1     ,       __lowerCamelCase						:		Optional[Any]=512     ,       __lowerCamelCase						:		str=0.02     ,       __lowerCamelCase						:		Union[str, Any]=1e-12     ,       __lowerCamelCase						:		int=0     ,       __lowerCamelCase						:		List[Any]="absolute"     ,       __lowerCamelCase						:		Any=2     ,       __lowerCamelCase						:		str=1408     ,       **__lowerCamelCase						:		Union[str, Any]     ,       )		->							Any:
       super().__init__(pad_token_id=__lowerCamelCase     ,       **__lowerCamelCase )

       SCREAMING_SNAKE_CASE__   =   vocab_size
       SCREAMING_SNAKE_CASE__   =   hidden_size
       SCREAMING_SNAKE_CASE__   =   num_hidden_layers
       SCREAMING_SNAKE_CASE__   =   num_attention_heads
       SCREAMING_SNAKE_CASE__   =   hidden_act
       SCREAMING_SNAKE_CASE__   =   intermediate_size
       SCREAMING_SNAKE_CASE__   =   hidden_dropout_prob
       SCREAMING_SNAKE_CASE__   =   attention_probs_dropout_prob
       SCREAMING_SNAKE_CASE__   =   max_position_embeddings
       SCREAMING_SNAKE_CASE__   =   initializer_range
       SCREAMING_SNAKE_CASE__   =   layer_norm_eps
       SCREAMING_SNAKE_CASE__   =   position_embedding_type
       SCREAMING_SNAKE_CASE__   =   cross_attention_frequency
       SCREAMING_SNAKE_CASE__   =   encoder_hidden_size







  @classmethod
  def 				lowercase_		(							cls						:		str     ,       __lowerCamelCase						:		Union[str, os.PathLike]     ,       **__lowerCamelCase						:		List[str] )		->							"PretrainedConfig":
       cls._set_token_in_kwargs(__lowerCamelCase )

       SCREAMING_SNAKE_CASE__,SCREAMING_SNAKE_CASE__   =   cls.get_config_dict(__lowerCamelCase     ,       **__lowerCamelCase )

       # get the qformer config dict if we are loading from InstructBlipConfig
       if config_dict.get('''model_type''' ) == "instructblip":
            SCREAMING_SNAKE_CASE__   =   config_dict['''qformer_config''']

       if "model_type" in config_dict and hasattr(cls     ,       '''model_type''' ) and config_dict["model_type"] != cls.model_type:
            logger.warning(
                f'''You are using a model of type {config_dict["model_type"]} to instantiate a model of type '''
                f'''{cls.model_type}. This is not supported for all configurations of models and can yield errors.''' )

       return cls.from_dict(__lowerCamelCase     ,       **__lowerCamelCase )






class 	UpperCAmelCase__		(	A__	):






  """simple docstring"""


  a									= "instructblip"
  a									= True






  def __init__(							self						:		str     ,       __lowerCamelCase						:		List[str]=None     ,       __lowerCamelCase						:		List[str]=None     ,       __lowerCamelCase						:		Any=None     ,       __lowerCamelCase						:		Tuple=32     ,       **__lowerCamelCase						:		Optional[Any] )		->							List[str]:
       super().__init__(**__lowerCamelCase )

       if vision_config is None:
            SCREAMING_SNAKE_CASE__   =   {}
            logger.info('''vision_config is None. initializing the InstructBlipVisionConfig with default values.''' )

       if qformer_config is None:
            SCREAMING_SNAKE_CASE__   =   {}
            logger.info('''qformer_config is None. Initializing the InstructBlipQFormerConfig with default values.''' )

       if text_config is None:
            SCREAMING_SNAKE_CASE__   =   {}
            logger.info('''text_config is None. Initializing the text config with default values (`OPTConfig`).''' )

       SCREAMING_SNAKE_CASE__   =   InstructBlipVisionConfig(**__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   InstructBlipQFormerConfig(**__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   text_config['''model_type'''] if '''model_type''' in text_config else '''opt'''
       SCREAMING_SNAKE_CASE__   =   CONFIG_MAPPING[text_model_type](**__lowerCamelCase )

       SCREAMING_SNAKE_CASE__   =   self.text_config.tie_word_embeddings
       SCREAMING_SNAKE_CASE__   =   self.text_config.is_encoder_decoder

       SCREAMING_SNAKE_CASE__   =   num_query_tokens
       SCREAMING_SNAKE_CASE__   =   self.vision_config.hidden_size
       SCREAMING_SNAKE_CASE__   =   self.text_config.model_type in MODEL_FOR_CAUSAL_LM_MAPPING_NAMES
       SCREAMING_SNAKE_CASE__   =   1.0
       SCREAMING_SNAKE_CASE__   =   0.02






  @classmethod
  def 				lowercase_		(							cls						:		Dict     ,       __lowerCamelCase						:		InstructBlipVisionConfig     ,       __lowerCamelCase						:		InstructBlipQFormerConfig     ,       __lowerCamelCase						:		PretrainedConfig     ,       **__lowerCamelCase						:		Tuple     ,       )		->							int:
       return cls(
           vision_config=vision_config.to_dict()     ,       qformer_config=qformer_config.to_dict()     ,       text_config=text_config.to_dict()     ,       **__lowerCamelCase     ,       )







  def 				lowercase_		(							self						:		Dict )		->							Optional[int]:
       SCREAMING_SNAKE_CASE__   =   copy.deepcopy(self.__dict__ )
       SCREAMING_SNAKE_CASE__   =   self.vision_config.to_dict()
       SCREAMING_SNAKE_CASE__   =   self.qformer_config.to_dict()
       SCREAMING_SNAKE_CASE__   =   self.text_config.to_dict()
       SCREAMING_SNAKE_CASE__   =   self.__class__.model_type
       return output





import argparse
import os
import pickle
import sys

import torch

from transformers import TransfoXLConfig, TransfoXLLMHeadModel, load_tf_weights_in_transfo_xl
from transformers.models.transfo_xl import tokenization_transfo_xl as data_utils
from transformers.models.transfo_xl.tokenization_transfo_xl import CORPUS_NAME, VOCAB_FILES_NAMES
from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging


logging.set_verbosity_info()

# We do this to be able to load python 2 datasets pickles
# See e.g. https://stackoverflow.com/questions/2121874/python-pickling-after-changing-a-modules-directory/2121918#2121918
_SCREAMING_SNAKE_CASE					:  Tuple             =      data_utils.TransfoXLTokenizer
_SCREAMING_SNAKE_CASE					:  Dict             =      data_utils.TransfoXLCorpus
_SCREAMING_SNAKE_CASE					:  Union[str, Any]             =      data_utils
_SCREAMING_SNAKE_CASE					:  Any             =      data_utils
def     UpperCAmelCase_       (						_A				,		_A				,		_A				,		_A    ):





     '''simple docstring'''




     if transfo_xl_dataset_file:
          # Convert a pre-processed corpus (see original TensorFlow repo)
          with open(_A				,		'''rb'''    ) as fp:
               SCREAMING_SNAKE_CASE__   =   pickle.load(_A				,		encoding='''latin1'''    )
          # Save vocabulary and dataset cache as Dictionaries (should be better than pickles for the long-term)
          SCREAMING_SNAKE_CASE__   =   pytorch_dump_folder_path + '''/''' + VOCAB_FILES_NAMES['''pretrained_vocab_file''']
          print(F'''Save vocabulary to {pytorch_vocab_dump_path}'''    )
          SCREAMING_SNAKE_CASE__   =   corpus.vocab.__dict__
          torch.save(_A				,		_A    )

          SCREAMING_SNAKE_CASE__   =   corpus.__dict__
          corpus_dict_no_vocab.pop('''vocab'''				,		_A    )
          SCREAMING_SNAKE_CASE__   =   pytorch_dump_folder_path + '''/''' + CORPUS_NAME
          print(F'''Save dataset to {pytorch_dataset_dump_path}'''    )
          torch.save(_A				,		_A    )

     if tf_checkpoint_path:
          # Convert a pre-trained TensorFlow model
          SCREAMING_SNAKE_CASE__   =   os.path.abspath(_A    )
          SCREAMING_SNAKE_CASE__   =   os.path.abspath(_A    )

          print(F'''Converting Transformer XL checkpoint from {tf_path} with config at {config_path}.'''    )
          # Initialise PyTorch model
          if transfo_xl_config_file == "":
               SCREAMING_SNAKE_CASE__   =   TransfoXLConfig()
          else:
               SCREAMING_SNAKE_CASE__   =   TransfoXLConfig.from_json_file(_A    )
          print(F'''Building PyTorch model from configuration: {config}'''    )
          SCREAMING_SNAKE_CASE__   =   TransfoXLLMHeadModel(_A    )

          SCREAMING_SNAKE_CASE__   =   load_tf_weights_in_transfo_xl(_A				,		_A				,		_A    )
          # Save pytorch-model
          SCREAMING_SNAKE_CASE__   =   os.path.join(_A				,		_A    )
          SCREAMING_SNAKE_CASE__   =   os.path.join(_A				,		_A    )
          print(F'''Save PyTorch model to {os.path.abspath(_A    )}'''    )
          torch.save(model.state_dict()				,		_A    )
          print(F'''Save configuration file to {os.path.abspath(_A    )}'''    )
          with open(_A				,		'''w'''				,		encoding='''utf-8'''    ) as f:
               f.write(config.to_json_string()    )


if __name__ == "__main__":
       _SCREAMING_SNAKE_CASE					:  Any             =      argparse.ArgumentParser()
       parser.add_argument(
           '''--pytorch_dump_folder_path''',
           default=None,
           type=str,
           required=True,
           help='''Path to the folder to store the PyTorch model or dataset/vocab.''',
       )
       parser.add_argument(
           '''--tf_checkpoint_path''',
           default='''''',
           type=str,
           help='''An optional path to a TensorFlow checkpoint path to be converted.''',
       )
       parser.add_argument(
           '''--transfo_xl_config_file''',
           default='''''',
           type=str,
           help=(
               '''An optional config json file corresponding to the pre-trained BERT model. \n'''
               '''This specifies the model architecture.'''
           ),
       )
       parser.add_argument(
           '''--transfo_xl_dataset_file''',
           default='''''',
           type=str,
           help='''An optional dataset file to be converted in a vocabulary.''',
       )
       _SCREAMING_SNAKE_CASE					:  Union[str, Any]             =      parser.parse_args()
       convert_transfo_xl_checkpoint_to_pytorch(
           args.tf_checkpoint_path,
           args.transfo_xl_config_file,
           args.pytorch_dump_folder_path,
           args.transfo_xl_dataset_file,
       )


