"""simple docstring"""


from __future__ import annotations

import unittest

import numpy as np

from transformers import BlipTextConfig
from transformers.testing_utils import require_tf, slow
from transformers.utils import is_tf_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask


if is_tf_available():
 import tensorflow as tf

 from transformers import TFBlipTextModel
 from transformers.models.blip.modeling_tf_blip import TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST






class    a__    :


   def __init__(     self,				_UpperCAmelCase,				_UpperCAmelCase=12,				_UpperCAmelCase=7,				_UpperCAmelCase=True,				_UpperCAmelCase=True,				_UpperCAmelCase=True,				_UpperCAmelCase=99,				_UpperCAmelCase=32,				_UpperCAmelCase=32,				_UpperCAmelCase=2,				_UpperCAmelCase=4,				_UpperCAmelCase=37,				_UpperCAmelCase=0.1,				_UpperCAmelCase=0.1,				_UpperCAmelCase=512,				_UpperCAmelCase=0.02,				_UpperCAmelCase=0,				_UpperCAmelCase=None,				):
        '''simple docstring'''



        lowercase__				 =							parent
        lowercase__				 =							batch_size
        lowercase__				 =							seq_length
        lowercase__				 =							is_training
        lowercase__				 =							use_input_mask
        lowercase__				 =							use_labels
        lowercase__				 =							vocab_size
        lowercase__				 =							hidden_size
        lowercase__				 =							projection_dim
        lowercase__				 =							num_hidden_layers
        lowercase__				 =							num_attention_heads
        lowercase__				 =							intermediate_size
        lowercase__				 =							dropout
        lowercase__				 =							attention_dropout
        lowercase__				 =							max_position_embeddings
        lowercase__				 =							initializer_range
        lowercase__				 =							scope
        lowercase__				 =							bos_token_id


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        lowercase__				 =							ids_tensor([self.batch_size, self.seq_length],				self.vocab_size  )

        lowercase__				 =							None
        if self.use_input_mask:
             lowercase__				 =							random_attention_mask([self.batch_size, self.seq_length]  )

        if input_mask is not None:
             lowercase__				 =							input_mask.numpy()
             lowercase__ ,						lowercase__				 =							input_mask.shape
             lowercase__				 =							np.random.randint(1,				seq_length - 1,				size=(batch_size,)  )
             for batch_idx, start_index in enumerate(_UpperCAmelCase  ):
                  lowercase__				 =							1
                  lowercase__				 =							0

        lowercase__				 =							self.get_config()

        return config, input_ids, tf.convert_to_tensor(_UpperCAmelCase  )


   def 	snake_case__	(     self  ):
        '''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 	snake_case__	(     self,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase  ):
        '''simple docstring'''



        lowercase__				 =							TFBlipTextModel(config=_UpperCAmelCase  )
        lowercase__				 =							model(_UpperCAmelCase,				attention_mask=_UpperCAmelCase,				training=_UpperCAmelCase  )
        lowercase__				 =							model(_UpperCAmelCase,				training=_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 	snake_case__	(     self  ):
        '''simple docstring'''



        lowercase__				 =							self.prepare_config_and_inputs()
        lowercase__ ,						lowercase__ ,						lowercase__				 =							config_and_inputs
        lowercase__				 =							{"input_ids": input_ids, "attention_mask": input_mask}
        return config, inputs_dict






@require_tf
class    a__    (   _a					,					unittest.TestCase	):
   snake_case_							=      (TFBlipTextModel,) if is_tf_available() else ()
   snake_case_							=      False
   snake_case_							=      False
   snake_case_							=      False


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        lowercase__				 =							BlipTextModelTester(self  )
        lowercase__				 =							ConfigTester(self,				config_class=_UpperCAmelCase,				hidden_size=37  )


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        self.config_tester.run_common_tests()


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        lowercase__				 =							self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*_UpperCAmelCase  )


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        pass


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        pass


   @unittest.skip(reason="Blip does not use inputs_embeds"  )
   def 	snake_case__	(     self  ):
        '''simple docstring'''



        pass


   @unittest.skip(reason="BlipTextModel has no base class and is not available in MODEL_MAPPING"  )
   def 	snake_case__	(     self  ):
        '''simple docstring'''



        pass


   @unittest.skip(reason="BlipTextModel has no base class and is not available in MODEL_MAPPING"  )
   def 	snake_case__	(     self  ):
        '''simple docstring'''



        pass


   @slow
   def 	snake_case__	(     self  ):
        '''simple docstring'''



        for model_name in TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             lowercase__				 =							TFBlipTextModel.from_pretrained(_UpperCAmelCase  )
             self.assertIsNotNone(_UpperCAmelCase  )


   def 	snake_case__	(     self,				_UpperCAmelCase=True  ):
        '''simple docstring'''



        super().test_pt_tf_model_equivalence(allow_missing_keys=_UpperCAmelCase  )





"""simple docstring"""


from typing import Any

import numpy as np







def 					__a   (		A      ):






     '''simple docstring'''



     return np.array_equal(A    ,				matrix.conjugate().T      )







def 					__a   (		A    ,				A      ):






     '''simple docstring'''



     lowercase__				 =							v.conjugate().T
     lowercase__				 =							v_star.dot(A      )
     assert isinstance(A    ,				np.ndarray      )
     return (v_star_dot.dot(A      )) / (v_star.dot(A      ))







def 					__a   (		):






     '''simple docstring'''



     lowercase__				 =							np.array([[2, 2 + 1j, 4], [2 - 1j, 3, 1j], [4, -1j, 1]]      )
     lowercase__				 =							np.array([[1], [2], [3]]      )
     assert is_hermitian(A      ), f'''{a} is not hermitian.'''
     print(rayleigh_quotient(A    ,				A      )      )

     lowercase__				 =							np.array([[1, 2, 4], [2, 3, -1], [4, -1, 1]]      )
     assert is_hermitian(A      ), f'''{a} is not hermitian.'''
     assert rayleigh_quotient(A    ,				A      ) == float(3      )


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 tests()




