
"""simple docstring"""






from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


__SCREAMING_SNAKE_CASE							=     {
    'configuration_whisper': ['WHISPER_PRETRAINED_CONFIG_ARCHIVE_MAP', 'WhisperConfig', 'WhisperOnnxConfig'],
    'feature_extraction_whisper': ['WhisperFeatureExtractor'],
    'processing_whisper': ['WhisperProcessor'],
    'tokenization_whisper': ['WhisperTokenizer'],
}

try:
 if not is_tokenizers_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __SCREAMING_SNAKE_CASE							=     ['WhisperTokenizerFast']

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __SCREAMING_SNAKE_CASE							=     [
     'WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST',
     'WhisperForConditionalGeneration',
     'WhisperModel',
     'WhisperPreTrainedModel',
     'WhisperForAudioClassification',
 ]

try:
 if not is_tf_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __SCREAMING_SNAKE_CASE							=     [
     'TF_WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST',
     'TFWhisperForConditionalGeneration',
     'TFWhisperModel',
     'TFWhisperPreTrainedModel',
 ]

try:
 if not is_flax_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __SCREAMING_SNAKE_CASE							=     [
     'FlaxWhisperForConditionalGeneration',
     'FlaxWhisperModel',
     'FlaxWhisperPreTrainedModel',
     'FlaxWhisperForAudioClassification',
 ]


if TYPE_CHECKING:
 from .configuration_whisper import WHISPER_PRETRAINED_CONFIG_ARCHIVE_MAP, WhisperConfig, WhisperOnnxConfig
 from .feature_extraction_whisper import WhisperFeatureExtractor
 from .processing_whisper import WhisperProcessor
 from .tokenization_whisper import WhisperTokenizer

 try:
  if not is_tokenizers_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .tokenization_whisper_fast import WhisperTokenizerFast

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_whisper import (
      WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST,
      WhisperForAudioClassification,
      WhisperForConditionalGeneration,
      WhisperModel,
      WhisperPreTrainedModel,
  )

 try:
  if not is_tf_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_tf_whisper import (
      TF_WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST,
      TFWhisperForConditionalGeneration,
      TFWhisperModel,
      TFWhisperPreTrainedModel,
  )

 try:
  if not is_flax_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_flax_whisper import (
      FlaxWhisperForAudioClassification,
      FlaxWhisperForConditionalGeneration,
      FlaxWhisperModel,
      FlaxWhisperPreTrainedModel,
  )

else:
 import sys

 __SCREAMING_SNAKE_CASE							=     _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)


"""simple docstring"""






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							=     logging.get_logger(__name__)

__SCREAMING_SNAKE_CASE							=     {
    'Salesforce/instruct-blip-flan-t5': 'https://huggingface.co/Salesforce/instruct-blip-flan-t5/resolve/main/config.json',
}





class 				a__					(						A__       ):
     UpperCAmelCase__         =      '''instructblip_vision_model'''



     def __init__(							self :int      ,  _lowerCamelCase :Optional[int]=1_408      ,  _lowerCamelCase :int=6_144      ,  _lowerCamelCase :str=39      ,  _lowerCamelCase :Tuple=16      ,  _lowerCamelCase :List[Any]=224      ,  _lowerCamelCase :int=14      ,  _lowerCamelCase :int="gelu"      ,  _lowerCamelCase :Optional[Any]=1E-6      ,  _lowerCamelCase :str=0.0      ,  _lowerCamelCase :Optional[Any]=1E-1_0      ,  _lowerCamelCase :str=True      ,  **_lowerCamelCase :Optional[Any]      ,  ):







      '''simple docstring'''



      super().__init__(**_lowerCamelCase   )

      UpperCamelCase_     :					Dict   	=hidden_size
      UpperCamelCase_     :					Tuple   	=intermediate_size
      UpperCamelCase_     :					Optional[int]   	=num_hidden_layers
      UpperCamelCase_     :					Union[str, Any]   	=num_attention_heads
      UpperCamelCase_     :					Optional[Any]   	=patch_size
      UpperCamelCase_     :					List[Any]   	=image_size
      UpperCamelCase_     :					Dict   	=initializer_range
      UpperCamelCase_     :					List[Any]   	=attention_dropout
      UpperCamelCase_     :					List[str]   	=layer_norm_eps
      UpperCamelCase_     :					List[str]   	=hidden_act
      UpperCamelCase_     :					Tuple   	=qkv_bias




     @classmethod
     def  lowerCamelCase_						(							cls :Optional[Any]      ,  _lowerCamelCase :Union[str, os.PathLike]      ,  **_lowerCamelCase :Any   ):







      '''simple docstring'''



      cls._set_token_in_kwargs(_lowerCamelCase   )

      UpperCamelCase_	,     UpperCamelCase_     :					List[str]   	=cls.get_config_dict(_lowerCamelCase      ,  **_lowerCamelCase   )

      # get the vision config dict if we are loading from InstructBlipConfig
      if config_dict.get('model_type'   ) == "instructblip":
       UpperCamelCase_     :					Tuple   	=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 				a__					(						A__       ):
     UpperCAmelCase__         =      '''instructblip_qformer'''



     def __init__(							self :Dict      ,  _lowerCamelCase :List[Any]=30_522      ,  _lowerCamelCase :Optional[int]=768      ,  _lowerCamelCase :Tuple=12      ,  _lowerCamelCase :List[str]=12      ,  _lowerCamelCase :int=3_072      ,  _lowerCamelCase :Tuple="gelu"      ,  _lowerCamelCase :Dict=0.1      ,  _lowerCamelCase :List[Any]=0.1      ,  _lowerCamelCase :Optional[int]=512      ,  _lowerCamelCase :List[Any]=0.02      ,  _lowerCamelCase :int=1E-1_2      ,  _lowerCamelCase :str=0      ,  _lowerCamelCase :Dict="absolute"      ,  _lowerCamelCase :Optional[int]=2      ,  _lowerCamelCase :Union[str, Any]=1_408      ,  **_lowerCamelCase :Tuple      ,  ):







      '''simple docstring'''



      super().__init__(pad_token_id=_lowerCamelCase      ,  **_lowerCamelCase   )

      UpperCamelCase_     :					Optional[Any]   	=vocab_size
      UpperCamelCase_     :					Tuple   	=hidden_size
      UpperCamelCase_     :					Union[str, Any]   	=num_hidden_layers
      UpperCamelCase_     :					List[str]   	=num_attention_heads
      UpperCamelCase_     :					List[str]   	=hidden_act
      UpperCamelCase_     :					Tuple   	=intermediate_size
      UpperCamelCase_     :					Optional[Any]   	=hidden_dropout_prob
      UpperCamelCase_     :					List[str]   	=attention_probs_dropout_prob
      UpperCamelCase_     :					List[str]   	=max_position_embeddings
      UpperCamelCase_     :					List[str]   	=initializer_range
      UpperCamelCase_     :					str   	=layer_norm_eps
      UpperCamelCase_     :					int   	=position_embedding_type
      UpperCamelCase_     :					Tuple   	=cross_attention_frequency
      UpperCamelCase_     :					List[Any]   	=encoder_hidden_size




     @classmethod
     def  lowerCamelCase_						(							cls :Optional[Any]      ,  _lowerCamelCase :Union[str, os.PathLike]      ,  **_lowerCamelCase :List[Any]   ):







      '''simple docstring'''



      cls._set_token_in_kwargs(_lowerCamelCase   )

      UpperCamelCase_	,     UpperCamelCase_     :					Optional[Any]   	=cls.get_config_dict(_lowerCamelCase      ,  **_lowerCamelCase   )

      # get the qformer config dict if we are loading from InstructBlipConfig
      if config_dict.get('model_type'   ) == "instructblip":
       UpperCamelCase_     :					List[Any]   	=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 				a__					(						A__       ):
     UpperCAmelCase__         =      '''instructblip'''
     UpperCAmelCase__         =      True



     def __init__(							self :str      ,  _lowerCamelCase :Optional[Any]=None      ,  _lowerCamelCase :List[str]=None      ,  _lowerCamelCase :List[Any]=None      ,  _lowerCamelCase :Union[str, Any]=32      ,  **_lowerCamelCase :Tuple   ):







      '''simple docstring'''



      super().__init__(**_lowerCamelCase   )

      if vision_config is None:
       UpperCamelCase_     :					Optional[int]   	={}
       logger.info('vision_config is None. initializing the InstructBlipVisionConfig with default values.'   )

      if qformer_config is None:
       UpperCamelCase_     :					Union[str, Any]   	={}
       logger.info('qformer_config is None. Initializing the InstructBlipQFormerConfig with default values.'   )

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

      UpperCamelCase_     :					Any   	=InstructBlipVisionConfig(**_lowerCamelCase   )
      UpperCamelCase_     :					Optional[Any]   	=InstructBlipQFormerConfig(**_lowerCamelCase   )
      UpperCamelCase_     :					str   	=text_config['model_type'] if 'model_type' in text_config else 'opt'
      UpperCamelCase_     :					int   	=CONFIG_MAPPING[text_model_type](**_lowerCamelCase   )

      UpperCamelCase_     :					Tuple   	=self.text_config.tie_word_embeddings
      UpperCamelCase_     :					Any   	=self.text_config.is_encoder_decoder

      UpperCamelCase_     :					List[Any]   	=num_query_tokens
      UpperCamelCase_     :					Tuple   	=self.vision_config.hidden_size
      UpperCamelCase_     :					Tuple   	=self.text_config.model_type in MODEL_FOR_CAUSAL_LM_MAPPING_NAMES
      UpperCamelCase_     :					int   	=1.0
      UpperCamelCase_     :					List[str]   	=0.02



     @classmethod
     def  lowerCamelCase_						(							cls :Optional[Any]      ,  _lowerCamelCase :InstructBlipVisionConfig      ,  _lowerCamelCase :InstructBlipQFormerConfig      ,  _lowerCamelCase :PretrainedConfig      ,  **_lowerCamelCase :Dict      ,  ):







      '''simple docstring'''



      return cls(
          vision_config=vision_config.to_dict()      ,  qformer_config=qformer_config.to_dict()      ,  text_config=text_config.to_dict()      ,  **_lowerCamelCase      ,  )




     def  lowerCamelCase_						(							self :Optional[Any]   ):







      '''simple docstring'''



      UpperCamelCase_     :					str   	=copy.deepcopy(self.__dict__   )
      UpperCamelCase_     :					Dict   	=self.vision_config.to_dict()
      UpperCamelCase_     :					Tuple   	=self.qformer_config.to_dict()
      UpperCamelCase_     :					List[str]   	=self.text_config.to_dict()
      UpperCamelCase_     :					List[str]   	=self.__class__.model_type
      return output
