code: 
  
  
  
  
  
  
  """simple docstring"""
  import unittest
  
  import numpy as np
  
  from transformers import BlipTextConfig
  from transformers.testing_utils import require_torch, slow, torch_device
  from transformers.utils import is_torch_available
  
  from ...test_configuration_common import ConfigTester
  from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
  
  
  if is_torch_available():
   import torch
  
   from transformers import BlipTextModel
   from transformers.models.blip.modeling_blip import BLIP_PRETRAINED_MODEL_ARCHIVE_LIST
  
  
  
  class 					UpperCamelCase__   :
  
  
  
  
  
  
  
      """simple docstring"""
  
  
  
  
  
  
  
      def __init__(		self   :  Tuple							,						UpperCamelCase_   :  Optional[int]							,						UpperCamelCase_   :  str=1_2							,						UpperCamelCase_   :  Dict=7							,						UpperCamelCase_   :  str=True							,						UpperCamelCase_   :  Tuple=True							,						UpperCamelCase_   :  Tuple=True							,						UpperCamelCase_   :  List[Any]=9_9							,						UpperCamelCase_   :  Dict=3_2							,						UpperCamelCase_   :  Optional[Any]=3_2							,						UpperCamelCase_   :  List[str]=5							,						UpperCamelCase_   :  List[str]=4							,						UpperCamelCase_   :  str=3_7							,						UpperCamelCase_   :  Any=0.1							,						UpperCamelCase_   :  Dict=0.1							,						UpperCamelCase_   :  List[Any]=5_1_2							,						UpperCamelCase_   :  List[str]=0.02							,						UpperCamelCase_   :  Optional[Any]=0							,						UpperCamelCase_   :  int=None							,						):
  
  
  
  
  
             '''simple docstring'''
  
             __magic_name__										=						parent
             __magic_name__										=						batch_size
             __magic_name__										=						seq_length
             __magic_name__										=						is_training
             __magic_name__										=						use_input_mask
             __magic_name__										=						use_labels
             __magic_name__										=						vocab_size
             __magic_name__										=						hidden_size
             __magic_name__										=						projection_dim
             __magic_name__										=						num_hidden_layers
             __magic_name__										=						num_attention_heads
             __magic_name__										=						intermediate_size
             __magic_name__										=						dropout
             __magic_name__										=						attention_dropout
             __magic_name__										=						max_position_embeddings
             __magic_name__										=						initializer_range
             __magic_name__										=						scope
             __magic_name__										=						bos_token_id
  
  
  
  
  
  
  
      def 							a__ (		self   :  Optional[Any]   ):
  
  
  
  
  
             '''simple docstring'''
  
             __magic_name__										=						ids_tensor([self.batch_size, self.seq_length]							,						self.vocab_size   )
  
             __magic_name__										=						None
             if self.use_input_mask:
                    __magic_name__										=						random_attention_mask([self.batch_size, self.seq_length]   )
  
             if input_mask is not None:
                    __magic_name__							,     __magic_name__										=						input_mask.shape
                    __magic_name__										=						np.random.randint(1							,						seq_length - 1							,						size=(batch_size,)   )
                    for batch_idx, start_index in enumerate(UpperCamelCase_   ):
                           __magic_name__										=						1
                           __magic_name__										=						0
  
             __magic_name__										=						self.get_config()
  
             return config, input_ids, input_mask
  
  
  
  
  
  
  
      def 							a__ (		self   :  Optional[int]   ):
  
  
  
  
  
             '''simple docstring'''
  
             return BlipTextConfig(
                 vocab_size=self.vocab_size							,						hidden_size=self.hidden_size							,						projection_dim=self.projection_dim							,						num_hidden_layers=self.num_hidden_layers							,						num_attention_heads=self.num_attention_heads							,						intermediate_size=self.intermediate_size							,						dropout=self.dropout							,						attention_dropout=self.attention_dropout							,						max_position_embeddings=self.max_position_embeddings							,						initializer_range=self.initializer_range							,						bos_token_id=self.bos_token_id							,						)
  
  
  
  
  
  
  
      def 							a__ (		self   :  Tuple							,						UpperCamelCase_   :  int							,						UpperCamelCase_   :  List[str]							,						UpperCamelCase_   :  Tuple   ):
  
  
  
  
  
             '''simple docstring'''
  
             __magic_name__										=						BlipTextModel(config=UpperCamelCase_   )
             model.to(UpperCamelCase_   )
             model.eval()
             with torch.no_grad():
                    __magic_name__										=						model(UpperCamelCase_							,						attention_mask=UpperCamelCase_   )
                    __magic_name__										=						model(UpperCamelCase_   )
             self.parent.assertEqual(result.last_hidden_state.shape							,						(self.batch_size, self.seq_length, self.hidden_size)   )
             self.parent.assertEqual(result.pooler_output.shape							,						(self.batch_size, self.hidden_size)   )
  
  
  
  
  
  
  
      def 							a__ (		self   :  Tuple   ):
  
  
  
  
  
             '''simple docstring'''
  
             __magic_name__										=						self.prepare_config_and_inputs()
             __magic_name__							,     __magic_name__							,     __magic_name__										=						config_and_inputs
             __magic_name__										=						{'input_ids': input_ids, 'attention_mask': input_mask}
             return config, inputs_dict
  
  
  
  @require_torch
  class 					UpperCamelCase__   (							a_       ,  unittest.TestCase):
  
  
  
  
  
  
  
      """simple docstring"""
      __UpperCAmelCase											=   (BlipTextModel,) if is_torch_available() else ()
      __UpperCAmelCase											=   False
      __UpperCAmelCase											=   False
      __UpperCAmelCase											=   False
  
  
  
  
  
  
  
      def 							a__ (		self   :  Optional[Any]   ):
  
  
  
  
  
             '''simple docstring'''
  
             __magic_name__										=						BlipTextModelTester(self   )
             __magic_name__										=						ConfigTester(self							,						config_class=UpperCamelCase_							,						hidden_size=3_7   )
  
  
  
  
  
  
  
      def 							a__ (		self   :  Optional[Any]   ):
  
  
  
  
  
             '''simple docstring'''
  
             self.config_tester.run_common_tests()
  
  
  
  
  
  
  
      def 							a__ (		self   :  Any   ):
  
  
  
  
  
             '''simple docstring'''
  
             __magic_name__										=						self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_model(*UpperCamelCase_   )
  
  
  
  
  
  
  
      def 							a__ (		self   :  int   ):
  
  
  
  
  
             '''simple docstring'''
  
             pass
  
  
  
  
  
  
  
      def 							a__ (		self   :  Any   ):
  
  
  
  
  
             '''simple docstring'''
  
             pass
  
  
  
  
  
  
  
      @unittest.skip(reason='Blip does not use inputs_embeds'   )
      def 							a__ (		self   :  str   ):
  
  
  
  
  
             '''simple docstring'''
  
             pass
  
  
  
  
  
  
  
      @unittest.skip(reason='BlipTextModel has no base class and is not available in MODEL_MAPPING'   )
      def 							a__ (		self   :  str   ):
  
  
  
  
  
             '''simple docstring'''
  
             pass
  
  
  
  
  
  
  
      @unittest.skip(reason='BlipTextModel has no base class and is not available in MODEL_MAPPING'   )
      def 							a__ (		self   :  List[str]   ):
  
  
  
  
  
             '''simple docstring'''
  
             pass
  
  
  
  
  
  
  
      @slow
      def 							a__ (		self   :  Tuple   ):
  
  
  
  
  
             '''simple docstring'''
  
             for model_name in BLIP_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                    __magic_name__										=						BlipTextModel.from_pretrained(UpperCamelCase_   )
                    self.assertIsNotNone(UpperCamelCase_   )
  
  
  
  
  
  
  
      def 							a__ (		self   :  Union[str, Any]   ):
  
  
  
  
  
             '''simple docstring'''
  
             super().test_pt_tf_model_equivalence(allow_missing_keys=UpperCamelCase_   )
style_context: 
  
  
  
  
  
  
  """simple docstring"""
  from typing import TYPE_CHECKING
  
  from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available
  
  
  snake_case   :   str    		=		{"""configuration_sew_d""": ["""SEW_D_PRETRAINED_CONFIG_ARCHIVE_MAP""", """SEWDConfig"""]}
  
  try:
   if not is_torch_available():
    raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
   pass
  else:
   snake_case   :   Union[str, Any]    		=		[
       """SEW_D_PRETRAINED_MODEL_ARCHIVE_LIST""",
       """SEWDForCTC""",
       """SEWDForSequenceClassification""",
       """SEWDModel""",
       """SEWDPreTrainedModel""",
   ]
  
  if TYPE_CHECKING:
   from .configuration_sew_d import SEW_D_PRETRAINED_CONFIG_ARCHIVE_MAP, SEWDConfig
  
   try:
    if not is_torch_available():
     raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
    pass
   else:
    from .modeling_sew_d import (
        SEW_D_PRETRAINED_MODEL_ARCHIVE_LIST,
        SEWDForCTC,
        SEWDForSequenceClassification,
        SEWDModel,
        SEWDPreTrainedModel,
    )
  
  
  else:
   import sys
  
   snake_case   :   Union[str, Any]    		=		_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)