




"""simple docstring"""


import numpy as np

from transformers import BatchFeature
from transformers.testing_utils import require_tf, require_torch

from .test_feature_extraction_common import FeatureExtractionSavingTestMixin






class       lowercase(  __a				):







 '''simple docstring'''





 lowercase__				      =      None
 lowercase__				      =      None


 @property
 def 				UpperCamelCase_     (       self:	List[str]	):




   '''simple docstring'''



   return self.feat_extract_tester.prepare_feat_extract_dict()


 def 				UpperCamelCase_     (       self:	Optional[Any]	):




   '''simple docstring'''



   _snake_case							:	str			=						self.feature_extraction_class(**self.feat_extract_dict	)
   self.assertTrue(hasattr(a_,   """feature_size"""	)	)
   self.assertTrue(hasattr(a_,   """sampling_rate"""	)	)
   self.assertTrue(hasattr(a_,   """padding_value"""	)	)


 def 				UpperCamelCase_     (       self:	str	):




   '''simple docstring'''



   _snake_case							:	int			=						self.feat_extract_tester.prepare_inputs_for_common()
   _snake_case							:	List[Any]			=						self.feature_extraction_class(**self.feat_extract_dict	)
   _snake_case							:	List[str]			=						feat_extract.model_input_names[0]

   _snake_case							:	Dict			=						BatchFeature({input_name: speech_inputs}	)

   self.assertTrue(all(len(a_	) == len(a_	) for x, y in zip(a_,   processed_features[input_name]	)	)	)

   _snake_case							:	List[Any]			=						self.feat_extract_tester.prepare_inputs_for_common(equal_length=a_	)
   _snake_case							:	Optional[int]			=						BatchFeature({input_name: speech_inputs},   tensor_type="""np"""	)

   _snake_case							:	Optional[Any]			=						processed_features[input_name]

   if len(batch_features_input.shape	) < 3:
     _snake_case							:	Optional[Any]			=						batch_features_input[:, :, None]

   self.assertTrue(
       batch_features_input.shape
       == (self.feat_extract_tester.batch_size, len(speech_inputs[0]	), self.feat_extract_tester.feature_size)	)


 @require_torch
 def 				UpperCamelCase_     (       self:	int	):




   '''simple docstring'''



   _snake_case							:	Any			=						self.feat_extract_tester.prepare_inputs_for_common(equal_length=a_	)
   _snake_case							:	List[Any]			=						self.feature_extraction_class(**self.feat_extract_dict	)
   _snake_case							:	Optional[int]			=						feat_extract.model_input_names[0]

   _snake_case							:	Dict			=						BatchFeature({input_name: speech_inputs},   tensor_type="""pt"""	)

   _snake_case							:	str			=						processed_features[input_name]

   if len(batch_features_input.shape	) < 3:
     _snake_case							:	Dict			=						batch_features_input[:, :, None]

   self.assertTrue(
       batch_features_input.shape
       == (self.feat_extract_tester.batch_size, len(speech_inputs[0]	), self.feat_extract_tester.feature_size)	)


 @require_tf
 def 				UpperCamelCase_     (       self:	Union[str, Any]	):




   '''simple docstring'''



   _snake_case							:	List[Any]			=						self.feat_extract_tester.prepare_inputs_for_common(equal_length=a_	)
   _snake_case							:	Optional[int]			=						self.feature_extraction_class(**self.feat_extract_dict	)
   _snake_case							:	List[str]			=						feat_extract.model_input_names[0]

   _snake_case							:	List[str]			=						BatchFeature({input_name: speech_inputs},   tensor_type="""tf"""	)

   _snake_case							:	int			=						processed_features[input_name]

   if len(batch_features_input.shape	) < 3:
     _snake_case							:	Optional[int]			=						batch_features_input[:, :, None]

   self.assertTrue(
       batch_features_input.shape
       == (self.feat_extract_tester.batch_size, len(speech_inputs[0]	), self.feat_extract_tester.feature_size)	)


 def 				UpperCamelCase_     (       self:	List[str],   a_:	Union[str, Any]=False	):




   '''simple docstring'''



   def _inputs_have_equal_length(a_:	Union[str, Any]	):
     _snake_case							:	Dict			=						len(input[0]	)
     for input_slice in input[1:]:
       if len(a_	) != length:
         return False
     return True

   def _inputs_are_equal(a_:	List[str],   a_:	int	):
     if len(a_	) != len(a_	):
       return False

     for input_slice_a, input_slice_a in zip(a_,   a_	):
       if not np.allclose(np.asarray(a_	),   np.asarray(a_	),   atol=1E-3	):
         return False
     return True

   _snake_case							:	List[Any]			=						self.feature_extraction_class(**self.feat_extract_dict	)
   _snake_case							:	Dict			=						self.feat_extract_tester.prepare_inputs_for_common(numpify=a_	)
   _snake_case							:	Dict			=						feat_extract.model_input_names[0]

   _snake_case							:	str			=						BatchFeature({input_name: speech_inputs}	)

   _snake_case							:	List[str]			=						self.feat_extract_tester.seq_length_diff
   _snake_case							:	List[Any]			=						self.feat_extract_tester.max_seq_length + pad_diff
   _snake_case							:	Optional[int]			=						self.feat_extract_tester.min_seq_length
   _snake_case							:	Any			=						self.feat_extract_tester.batch_size
   _snake_case							:	Any			=						self.feat_extract_tester.feature_size

   # test padding for List[int] + numpy
   _snake_case							:	Optional[int]			=						feat_extract.pad(a_,   padding=a_	)
   _snake_case							:	Union[str, Any]			=						input_a[input_name]

   _snake_case							:	str			=						feat_extract.pad(a_,   padding="""longest"""	)
   _snake_case							:	List[str]			=						input_a[input_name]

   _snake_case							:	Optional[Any]			=						feat_extract.pad(a_,   padding="""max_length""",   max_length=len(speech_inputs[-1]	)	)
   _snake_case							:	str			=						input_a[input_name]

   _snake_case							:	Any			=						feat_extract.pad(a_,   padding="""longest""",   return_tensors="""np"""	)
   _snake_case							:	Optional[int]			=						input_a[input_name]

   # max_length parameter has to be provided when setting `padding="max_length"`
   with self.assertRaises(a_	):
     feat_extract.pad(a_,   padding="""max_length"""	)[input_name]

   _snake_case							:	str			=						feat_extract.pad(
       a_,   padding="""max_length""",   max_length=a_,   return_tensors="""np"""	)
   _snake_case							:	List[Any]			=						input_a[input_name]

   self.assertFalse(_inputs_have_equal_length(a_	)	)
   self.assertTrue(_inputs_have_equal_length(a_	)	)
   self.assertTrue(_inputs_have_equal_length(a_	)	)
   self.assertTrue(_inputs_are_equal(a_,   a_	)	)
   self.assertTrue(len(input_a[0]	) == pad_min_length	)
   self.assertTrue(len(input_a[1]	) == pad_min_length + pad_diff	)
   self.assertTrue(input_a.shape[:2] == (batch_size, len(input_a[0]	))	)
   self.assertTrue(input_a.shape[:2] == (batch_size, pad_max_length)	)

   if feature_size > 1:
     self.assertTrue(input_a.shape[2] == input_a.shape[2] == feature_size	)

   # test padding for `pad_to_multiple_of` for List[int] + numpy
   _snake_case							:	str			=						feat_extract.pad(a_,   pad_to_multiple_of=10	)
   _snake_case							:	Union[str, Any]			=						input_a[input_name]

   _snake_case							:	Any			=						feat_extract.pad(a_,   padding="""longest""",   pad_to_multiple_of=10	)
   _snake_case							:	List[str]			=						input_a[input_name]

   _snake_case							:	Union[str, Any]			=						feat_extract.pad(
       a_,   padding="""max_length""",   pad_to_multiple_of=10,   max_length=a_	)
   _snake_case							:	int			=						input_a[input_name]

   _snake_case							:	str			=						feat_extract.pad(
       a_,   padding="""max_length""",   pad_to_multiple_of=10,   max_length=a_,   return_tensors="""np""",   )
   _snake_case							:	Tuple			=						input_a[input_name]

   self.assertTrue(all(len(a_	) % 10 == 0 for x in input_a	)	)
   self.assertTrue(_inputs_are_equal(a_,   a_	)	)

   _snake_case							:	Optional[int]			=						pad_max_length if pad_max_length % 10 == 0 else (pad_max_length // 10 + 1) * 10
   self.assertTrue(all(len(a_	) == expected_mult_pad_length for x in input_a	)	)
   self.assertEqual(input_a.shape[:2],   (batch_size, expected_mult_pad_length)	)

   if feature_size > 1:
     self.assertTrue(input_a.shape[2] == feature_size	)

   # Check padding value is correct
   _snake_case							:	Tuple			=						(np.ones(self.feat_extract_tester.feature_size	) * feat_extract.padding_value).sum()
   self.assertTrue(
       abs(np.asarray(input_a[0]	)[pad_min_length:].sum() - padding_vector_sum * (pad_max_length - pad_min_length)	)
       < 1E-3	)
   self.assertTrue(
       abs(
           np.asarray(input_a[1]	)[pad_min_length + pad_diff :].sum()
           - padding_vector_sum * (pad_max_length - pad_min_length - pad_diff)	)
       < 1E-3	)
   self.assertTrue(
       abs(
           np.asarray(input_a[2]	)[pad_min_length + 2 * pad_diff :].sum()
           - padding_vector_sum * (pad_max_length - pad_min_length - 2 * pad_diff)	)
       < 1E-3	)
   self.assertTrue(
       abs(input_a[0, pad_min_length:].sum() - padding_vector_sum * (pad_max_length - pad_min_length)	) < 1E-3	)
   self.assertTrue(
       abs(input_a[0, pad_min_length:].sum() - padding_vector_sum * (expected_mult_pad_length - pad_min_length)	)
       < 1E-3	)


 def 				UpperCamelCase_     (       self:	Optional[Any],   a_:	Union[str, Any]=False	):




   '''simple docstring'''



   def _inputs_have_equal_length(a_:	Union[str, Any]	):
     _snake_case							:	Union[str, Any]			=						len(input[0]	)
     for input_slice in input[1:]:
       if len(a_	) != length:
         return False
     return True

   def _inputs_are_equal(a_:	Tuple,   a_:	Any	):
     if len(a_	) != len(a_	):
       return False

     for input_slice_a, input_slice_a in zip(a_,   a_	):
       if not np.allclose(np.asarray(a_	),   np.asarray(a_	),   atol=1E-3	):
         return False
     return True

   _snake_case							:	Any			=						self.feature_extraction_class(**self.feat_extract_dict	)
   _snake_case							:	Optional[Any]			=						self.feat_extract_tester.prepare_inputs_for_common(numpify=a_	)
   _snake_case							:	List[str]			=						feat_extract.model_input_names[0]

   _snake_case							:	List[str]			=						BatchFeature({input_name: speech_inputs}	)

   # truncate to smallest
   _snake_case							:	Tuple			=						feat_extract.pad(
       a_,   padding="""max_length""",   max_length=len(speech_inputs[0]	),   truncation=a_	)
   _snake_case							:	Optional[int]			=						input_a[input_name]

   _snake_case							:	Tuple			=						feat_extract.pad(a_,   padding="""max_length""",   max_length=len(speech_inputs[0]	)	)
   _snake_case							:	Tuple			=						input_a[input_name]

   self.assertTrue(_inputs_have_equal_length(a_	)	)
   self.assertFalse(_inputs_have_equal_length(a_	)	)

   # truncate to smallest with np
   _snake_case							:	List[Any]			=						feat_extract.pad(
       a_,   padding="""max_length""",   max_length=len(speech_inputs[0]	),   return_tensors="""np""",   truncation=a_,   )
   _snake_case							:	List[Any]			=						input_a[input_name]

   _snake_case							:	List[str]			=						feat_extract.pad(
       a_,   padding="""max_length""",   max_length=len(speech_inputs[0]	),   return_tensors="""np"""	)
   _snake_case							:	Any			=						input_a[input_name]

   self.assertTrue(_inputs_have_equal_length(a_	)	)
   self.assertTrue(input_a.shape[1] == len(speech_inputs[0]	)	)

   # since truncation forces padding to be smaller than longest input
   # function can't return `np.ndarray`, but has to return list
   self.assertFalse(_inputs_have_equal_length(a_	)	)

   # truncate to middle
   _snake_case							:	Tuple			=						feat_extract.pad(
       a_,   padding="""max_length""",   max_length=len(speech_inputs[1]	),   truncation=a_,   return_tensors="""np""",   )
   _snake_case							:	Dict			=						input_a[input_name]

   _snake_case							:	int			=						feat_extract.pad(
       a_,   padding="""max_length""",   max_length=len(speech_inputs[1]	),   truncation=a_	)
   _snake_case							:	List[Any]			=						input_a[input_name]

   _snake_case							:	Any			=						feat_extract.pad(
       a_,   padding="""max_length""",   max_length=len(speech_inputs[1]	),   return_tensors="""np"""	)
   _snake_case							:	List[Any]			=						input_a[input_name]

   self.assertTrue(input_a.shape[1] == len(speech_inputs[1]	)	)
   self.assertTrue(_inputs_have_equal_length(a_	)	)
   self.assertTrue(_inputs_have_equal_length(a_	)	)
   self.assertTrue(_inputs_are_equal(a_,   a_	)	)

   # since truncation forces padding to be smaller than longest input
   # function can't return `np.ndarray`, but has to return list
   self.assertFalse(_inputs_have_equal_length(a_	)	)
   self.assertTrue(len(input_a[-1]	) == len(speech_inputs[-1]	)	)

   # padding has to be max_length when setting `truncation=True`
   with self.assertRaises(a_	):
     feat_extract.pad(a_,   truncation=a_	)[input_name]

   # padding has to be max_length when setting `truncation=True`
   with self.assertRaises(a_	):
     feat_extract.pad(a_,   padding="""longest""",   truncation=a_	)[input_name]

   # padding has to be max_length when setting `truncation=True`
   with self.assertRaises(a_	):
     feat_extract.pad(a_,   padding="""longest""",   truncation=a_	)[input_name]

   # max_length parameter has to be provided when setting `truncation=True` and padding="max_length"
   with self.assertRaises(a_	):
     feat_extract.pad(a_,   padding="""max_length""",   truncation=a_	)[input_name]

   # test truncation for `pad_to_multiple_of` for List[int] + numpy
   _snake_case							:	int			=						12
   _snake_case							:	Any			=						feat_extract.pad(
       a_,   padding="""max_length""",   max_length=len(speech_inputs[0]	),   pad_to_multiple_of=a_,   truncation=a_,   )
   _snake_case							:	Optional[int]			=						input_a[input_name]

   _snake_case							:	Tuple			=						feat_extract.pad(
       a_,   padding="""max_length""",   max_length=len(speech_inputs[0]	),   pad_to_multiple_of=a_,   )
   _snake_case							:	List[Any]			=						input_a[input_name]

   # retrieve expected_length as multiple of pad_to_multiple_of
   _snake_case							:	Tuple			=						len(speech_inputs[0]	)
   if expected_length % pad_to_multiple_of != 0:
     _snake_case							:	List[str]			=						((len(speech_inputs[0]	) // pad_to_multiple_of) + 1) * pad_to_multiple_of

   self.assertTrue(len(input_a[0]	) == expected_length	)
   self.assertTrue(_inputs_have_equal_length(a_	)	)
   self.assertFalse(_inputs_have_equal_length(a_	)	)


 def 				UpperCamelCase_     (       self:	int	):




   '''simple docstring'''



   self._check_padding(numpify=a_	)


 def 				UpperCamelCase_     (       self:	Dict	):




   '''simple docstring'''



   self._check_padding(numpify=a_	)


 def 				UpperCamelCase_     (       self:	Optional[int]	):




   '''simple docstring'''



   self._check_truncation(numpify=a_	)


 def 				UpperCamelCase_     (       self:	Tuple	):




   '''simple docstring'''



   self._check_truncation(numpify=a_	)


 @require_torch
 def 				UpperCamelCase_     (       self:	Union[str, Any]	):




   '''simple docstring'''



   _snake_case							:	Tuple			=						self.feature_extraction_class(**self.feat_extract_dict	)
   _snake_case							:	Dict			=						self.feat_extract_tester.prepare_inputs_for_common()
   _snake_case							:	Any			=						feat_extract.model_input_names[0]

   _snake_case							:	Union[str, Any]			=						BatchFeature({input_name: speech_inputs}	)

   _snake_case							:	List[Any]			=						feat_extract.pad(a_,   padding="""longest""",   return_tensors="""np"""	)[input_name]
   _snake_case							:	Tuple			=						feat_extract.pad(a_,   padding="""longest""",   return_tensors="""pt"""	)[input_name]

   self.assertTrue(abs(input_np.astype(np.floataa	).sum() - input_pt.numpy().astype(np.floataa	).sum()	) < 1E-2	)


 @require_tf
 def 				UpperCamelCase_     (       self:	int	):




   '''simple docstring'''



   _snake_case							:	Optional[int]			=						self.feature_extraction_class(**self.feat_extract_dict	)
   _snake_case							:	Optional[int]			=						self.feat_extract_tester.prepare_inputs_for_common()
   _snake_case							:	int			=						feat_extract.model_input_names[0]

   _snake_case							:	Tuple			=						BatchFeature({input_name: speech_inputs}	)

   _snake_case							:	Optional[Any]			=						feat_extract.pad(a_,   padding="""longest""",   return_tensors="""np"""	)[input_name]
   _snake_case							:	Tuple			=						feat_extract.pad(a_,   padding="""longest""",   return_tensors="""tf"""	)[input_name]

   self.assertTrue(abs(input_np.astype(np.floataa	).sum() - input_tf.numpy().astype(np.floataa	).sum()	) < 1E-2	)


 def 				UpperCamelCase_     (       self:	List[Any]	):




   '''simple docstring'''



   _snake_case							:	Union[str, Any]			=						self.feat_extract_dict
   _snake_case							:	List[Any]			=						True
   _snake_case							:	Optional[int]			=						self.feature_extraction_class(**a_	)
   _snake_case							:	List[Any]			=						self.feat_extract_tester.prepare_inputs_for_common()
   _snake_case							:	List[str]			=						[len(a_	) for x in speech_inputs]
   _snake_case							:	int			=						feat_extract.model_input_names[0]

   _snake_case							:	Any			=						BatchFeature({input_name: speech_inputs}	)

   _snake_case							:	List[str]			=						feat_extract.pad(a_,   padding="""longest""",   return_tensors="""np"""	)
   self.assertIn("""attention_mask""",   a_	)
   self.assertListEqual(list(processed.attention_mask.shape	),   list(processed[input_name].shape[:2]	)	)
   self.assertListEqual(processed.attention_mask.sum(-1	).tolist(),   a_	)


 def 				UpperCamelCase_     (       self:	Optional[Any]	):




   '''simple docstring'''



   _snake_case							:	Optional[Any]			=						self.feat_extract_dict
   _snake_case							:	Dict			=						True
   _snake_case							:	str			=						self.feature_extraction_class(**a_	)
   _snake_case							:	Optional[int]			=						self.feat_extract_tester.prepare_inputs_for_common()
   _snake_case							:	Optional[int]			=						[len(a_	) for x in speech_inputs]
   _snake_case							:	int			=						feat_extract.model_input_names[0]

   _snake_case							:	Any			=						BatchFeature({input_name: speech_inputs}	)
   _snake_case							:	List[Any]			=						min(a_	)

   _snake_case							:	Optional[Any]			=						feat_extract.pad(
       a_,   padding="""max_length""",   max_length=a_,   truncation=a_,   return_tensors="""np"""	)
   self.assertIn("""attention_mask""",   a_	)
   self.assertListEqual(
       list(processed_pad.attention_mask.shape	),   [processed_pad[input_name].shape[0], max_length]	)
   self.assertListEqual(
       processed_pad.attention_mask[:, :max_length].sum(-1	).tolist(),   [max_length for x in speech_inputs]	)








"""simple docstring"""


import copy
import os
from typing import Union

from ...configuration_utils import PretrainedConfig
from ...utils import logging


A_      			=       logging.get_logger(__name__)

A_      			=       {
    '''BridgeTower/bridgetower-base''': '''https://huggingface.co/BridgeTower/bridgetower-base/blob/main/config.json''',
    '''BridgeTower/bridgetower-base-itm-mlm''': (
        '''https://huggingface.co/BridgeTower/bridgetower-base-itm-mlm/blob/main/config.json'''
    ),
}






class       lowercase(  __a				):







 '''simple docstring'''





 lowercase__				      =      "bridgetower_vision_model"


 def __init__(       self:	Tuple,   a_:	str=768,   a_:	Union[str, Any]=12,   a_:	List[str]=3,   a_:	Optional[int]=16,   a_:	List[Any]=288,   a_:	Optional[Any]=1,   a_:	Any=1E-05,   a_:	Dict=False,   a_:	Any=True,   a_:	int=False,   **a_:	int,   ):




   '''simple docstring'''



   super().__init__(**a_	)
   _snake_case							:	str			=						hidden_size
   _snake_case							:	int			=						num_hidden_layers
   _snake_case							:	Any			=						num_channels
   _snake_case							:	Union[str, Any]			=						patch_size
   _snake_case							:	Dict			=						image_size
   _snake_case							:	Optional[Any]			=						initializer_factor
   _snake_case							:	Any			=						layer_norm_eps
   _snake_case							:	int			=						stop_gradient
   _snake_case							:	Any			=						share_layernorm
   _snake_case							:	List[Any]			=						remove_last_layer


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




   '''simple docstring'''



   _snake_case	,      _snake_case							:	List[Any]			=						cls.get_config_dict(a_,   **a_	)

   if config_dict.get("""model_type"""	) == "bridgetower":
     _snake_case							:	str			=						config_dict["""text_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(a_,   **a_	)







class       lowercase(  __a				):







 '''simple docstring'''





 lowercase__				      =      "bridgetower_text_model"


 def __init__(       self:	str,   a_:	Dict=50_265,   a_:	List[Any]=768,   a_:	Union[str, Any]=12,   a_:	List[str]=12,   a_:	str=1,   a_:	Optional[Any]=3_072,   a_:	int="gelu",   a_:	int=0.1,   a_:	int=0.1,   a_:	Optional[int]=514,   a_:	Tuple=1,   a_:	Tuple=1E-05,   a_:	Optional[int]=1,   a_:	Union[str, Any]=0,   a_:	str=2,   a_:	Any="absolute",   a_:	List[Any]=True,   **a_:	Union[str, Any],   ):




   '''simple docstring'''



   super().__init__(**a_	)

   _snake_case							:	str			=						vocab_size
   _snake_case							:	Optional[int]			=						hidden_size
   _snake_case							:	Dict			=						num_hidden_layers
   _snake_case							:	Optional[int]			=						num_attention_heads
   _snake_case							:	Optional[int]			=						hidden_act
   _snake_case							:	List[Any]			=						initializer_factor
   _snake_case							:	Optional[int]			=						intermediate_size
   _snake_case							:	int			=						hidden_dropout_prob
   _snake_case							:	Tuple			=						attention_probs_dropout_prob
   _snake_case							:	List[str]			=						max_position_embeddings
   _snake_case							:	Optional[int]			=						type_vocab_size
   _snake_case							:	List[Any]			=						layer_norm_eps
   _snake_case							:	Dict			=						position_embedding_type
   _snake_case							:	Dict			=						use_cache
   _snake_case							:	int			=						pad_token_id
   _snake_case							:	Union[str, Any]			=						bos_token_id
   _snake_case							:	Union[str, Any]			=						eos_token_id


 @classmethod
 def 				UpperCamelCase_     (       cls:	str,   a_:	Union[str, os.PathLike],   **a_:	int	):




   '''simple docstring'''



   _snake_case	,      _snake_case							:	Optional[int]			=						cls.get_config_dict(a_,   **a_	)

   if config_dict.get("""model_type"""	) == "bridgetower":
     _snake_case							:	Union[str, Any]			=						config_dict["""text_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(a_,   **a_	)







class       lowercase(  __a				):







 '''simple docstring'''





 lowercase__				      =      "bridgetower"


 def __init__(       self:	int,   a_:	List[str]=True,   a_:	Any="gelu",   a_:	List[Any]=768,   a_:	int=1,   a_:	Optional[int]=1E-05,   a_:	Tuple=False,   a_:	Optional[Any]="add",   a_:	List[str]=12,   a_:	Union[str, Any]=6,   a_:	int=False,   a_:	Any=False,   a_:	Dict=None,   a_:	Any=None,   **a_:	str,   ):




   '''simple docstring'''



   _snake_case							:	str			=						kwargs.pop("""text_config_dict""",   a_	)
   _snake_case							:	Optional[Any]			=						kwargs.pop("""vision_config_dict""",   a_	)

   super().__init__(**a_	)
   _snake_case							:	str			=						share_cross_modal_transformer_layers
   _snake_case							:	Any			=						hidden_act
   _snake_case							:	Union[str, Any]			=						hidden_size
   _snake_case							:	Union[str, Any]			=						initializer_factor
   _snake_case							:	Dict			=						layer_norm_eps
   _snake_case							:	Dict			=						share_link_tower_layers
   _snake_case							:	Optional[int]			=						link_tower_type
   _snake_case							:	Any			=						num_attention_heads
   _snake_case							:	int			=						num_hidden_layers
   _snake_case							:	int			=						tie_word_embeddings
   _snake_case							:	Optional[Any]			=						init_layernorm_from_vision_encoder

   if text_config is None:
     _snake_case							:	Optional[Any]			=						{}
     logger.info("""`text_config` is `None`. Initializing the `BridgeTowerTextConfig` with default values."""	)

   if vision_config is None:
     _snake_case							:	str			=						{}
     logger.info("""`vision_config` is `None`. Initializing the `BridgeTowerVisionConfig` with default values."""	)

   _snake_case							:	Any			=						BridgeTowerTextConfig(**a_	)
   _snake_case							:	List[Any]			=						BridgeTowerVisionConfig(**a_	)


 @classmethod
 def 				UpperCamelCase_     (       cls:	Union[str, Any],   a_:	BridgeTowerTextConfig,   a_:	BridgeTowerVisionConfig,   **a_:	Optional[Any]	):




   '''simple docstring'''



   return cls(text_config=text_config.to_dict(),   vision_config=vision_config.to_dict(),   **a_	)


 def 				UpperCamelCase_     (       self:	int	):




   '''simple docstring'''



   _snake_case							:	Optional[int]			=						copy.deepcopy(self.__dict__	)
   _snake_case							:	str			=						self.text_config.to_dict()
   _snake_case							:	List[str]			=						self.vision_config.to_dict()
   _snake_case							:	Tuple			=						self.__class__.model_type
   return output


