





import numpy as np



def 				lowerCAmelCase_ (							A_    ,A_    ,A_ = 1e-12    ,A_ = 1_00    ,):
    assert np.shape(UpperCAmelCase__)[0] == np.shape(UpperCAmelCase__)[1]
    # Ensure proper dimensionality.
    assert np.shape(UpperCAmelCase__)[0] == np.shape(UpperCAmelCase__)[0]
    # Ensure inputs are either both complex or both real
    assert np.iscomplexobj(UpperCAmelCase__) == np.iscomplexobj(UpperCAmelCase__)
    UpperCamelCase__:	Tuple					=     np.iscomplexobj(UpperCAmelCase__)
    if is_complex:
        # Ensure complex input_matrix is Hermitian
        assert np.array_equal(UpperCAmelCase__    ,input_matrix.conj().T)

    # Set convergence to False. Will define convergence when we exceed max_iterations
    # or when we have small changes from one iteration to next.

    UpperCamelCase__:	Optional[int]					=     False
    UpperCamelCase__:	Optional[Any]					=     0
    UpperCamelCase__:	Optional[Any]					=     0
    UpperCamelCase__:	List[Any]					=     1e12

    while not convergence:
        # Multiple matrix by the vector.
        UpperCamelCase__:	Optional[int]					=     np.dot(UpperCAmelCase__    ,UpperCAmelCase__)
        # Normalize the resulting output vector.
        UpperCamelCase__:	Dict					=     w / np.linalg.norm(UpperCAmelCase__)
        # Find rayleigh quotient
        # (faster than usual b/c we know vector is normalized already)
        UpperCamelCase__:	Dict					=     vector.conj().T if is_complex else vector.T
        UpperCamelCase__:	Optional[Any]					=     np.dot(UpperCAmelCase__    ,np.dot(UpperCAmelCase__    ,UpperCAmelCase__))

        # Check convergence.
        UpperCamelCase__:	List[Any]					=     np.abs(lambda_ - lambda_previous) / lambda_
        iterations += 1

        if error <= error_tol or iterations >= max_iterations:
            UpperCamelCase__:	int					=     True

        UpperCamelCase__:	Dict					=     lambda_

    if is_complex:
        UpperCamelCase__:	Union[str, Any]					=     np.real(lambda_)

    return lambda_, vector



def 				lowerCAmelCase_ (							):
    UpperCamelCase__:	Dict					=     np.array([[41, 4, 20], [4, 26, 30], [20, 30, 50]])
    UpperCamelCase__:	Optional[int]					=     np.array([41, 4, 20])
    UpperCamelCase__:	Any					=     real_input_matrix.astype(np.complexaaa)
    UpperCamelCase__:	str					=     np.triu(1J * complex_input_matrix    ,1)
    complex_input_matrix += imag_matrix
    complex_input_matrix += -1 * imag_matrix.T
    UpperCamelCase__:	Tuple					=     np.array([41, 4, 20]).astype(np.complexaaa)

    for problem_type in ["real", "complex"]:
        if problem_type == "real":
            UpperCamelCase__:	int					=     real_input_matrix
            UpperCamelCase__:	Optional[int]					=     real_vector
        elif problem_type == "complex":
            UpperCamelCase__:	List[str]					=     complex_input_matrix
            UpperCamelCase__:	int					=     complex_vector

        # Our implementation.
        UpperCamelCase__				, UpperCamelCase__:	str					=     power_iteration(UpperCAmelCase__    ,UpperCAmelCase__)

        # Numpy implementation.

        # Get eigenvalues and eigenvectors using built-in numpy
        # eigh (eigh used for symmetric or hermetian matrices).
        UpperCamelCase__				, UpperCamelCase__:	Tuple					=     np.linalg.eigh(UpperCAmelCase__)
        # Last eigenvalue is the maximum one.
        UpperCamelCase__:	List[Any]					=     eigen_values[-1]
        # Last column in this matrix is eigenvector corresponding to largest eigenvalue.
        UpperCamelCase__:	Union[str, Any]					=     eigen_vectors[:, -1]

        # Check our implementation and numpy gives close answers.
        assert np.abs(eigen_value - eigen_value_max) <= 1e-6
        # Take absolute values element wise of each eigenvector.
        # as they are only unique to a minus sign.
        assert np.linalg.norm(np.abs(UpperCAmelCase__) - np.abs(UpperCAmelCase__)) <= 1e-6


if __name__ == "__main__":
   import doctest

   doctest.testmod()
   test_power_iteration()




'''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		,					)    ->   Union[str, Any]:





           '''simple docstring'''
           A_						       =   parent
           A_						       =   batch_size
           A_						       =   seq_length
           A_						       =   is_training
           A_						       =   use_input_mask
           A_						       =   use_labels
           A_						       =   vocab_size
           A_						       =   hidden_size
           A_						       =   projection_dim
           A_						       =   num_hidden_layers
           A_						       =   num_attention_heads
           A_						       =   intermediate_size
           A_						       =   dropout
           A_						       =   attention_dropout
           A_						       =   max_position_embeddings
           A_						       =   initializer_range
           A_						       =   scope
           A_						       =   bos_token_id



    def        snake_case_      (       self							)    ->   Dict:





           '''simple docstring'''
           A_						       =   ids_tensor([self.batch_size, self.seq_length]		,					self.vocab_size							)

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

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

           A_						       =   self.get_config()

           return config, input_ids, tf.convert_to_tensor(UpperCamelCase__							)



    def        snake_case_      (       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        snake_case_      (       self		,					UpperCamelCase__		,					UpperCamelCase__		,					UpperCamelCase__							)    ->   int:





           '''simple docstring'''
           A_						       =   TFBlipTextModel(config=UpperCamelCase__							)
           A_						       =   model(UpperCamelCase__		,					attention_mask=UpperCamelCase__		,					training=UpperCamelCase__							)
           A_						       =   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							)    ->   List[Any]:





           '''simple docstring'''
           A_						       =   self.prepare_config_and_inputs()
           A_       ,      A_       ,      A_						       =   config_and_inputs
           A_						       =   {"""input_ids""": input_ids, """attention_mask""": input_mask}
           return config, inputs_dict


@require_tf
class        A__   (   _snake_case    ,    unittest.TestCase      ):
    lowercase						       =		(TFBlipTextModel,) if is_tf_available() else ()
    lowercase						       =		False
    lowercase						       =		False
    lowercase						       =		False



    def        snake_case_      (       self							)    ->   Optional[int]:





           '''simple docstring'''
           A_						       =   BlipTextModelTester(self							)
           A_						       =   ConfigTester(self		,					config_class=UpperCamelCase__		,					hidden_size=37							)



    def        snake_case_      (       self							)    ->   Tuple:





           '''simple docstring'''
           self.config_tester.run_common_tests()



    def        snake_case_      (       self							)    ->   str:





           '''simple docstring'''
           A_						       =   self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*UpperCamelCase__							)



    def        snake_case_      (       self							)    ->   List[Any]:





           '''simple docstring'''
           pass



    def        snake_case_      (       self							)    ->   Union[str, Any]:





           '''simple docstring'''
           pass



    @unittest.skip(reason="""Blip does not use inputs_embeds"""							)
    def        snake_case_      (       self							)    ->   Union[str, Any]:





           '''simple docstring'''
           pass



    @unittest.skip(reason="""BlipTextModel has no base class and is not available in MODEL_MAPPING"""							)
    def        snake_case_      (       self							)    ->   List[Any]:





           '''simple docstring'''
           pass



    @unittest.skip(reason="""BlipTextModel has no base class and is not available in MODEL_MAPPING"""							)
    def        snake_case_      (       self							)    ->   Any:





           '''simple docstring'''
           pass



    @slow
    def        snake_case_      (       self							)    ->   List[Any]:





           '''simple docstring'''
           for model_name in TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                  A_						       =   TFBlipTextModel.from_pretrained(UpperCamelCase__							)
                  self.assertIsNotNone(UpperCamelCase__							)







    def        snake_case_      (       self		,					UpperCamelCase__=True							)    ->   str:





           '''simple docstring'''
           super().test_pt_tf_model_equivalence(allow_missing_keys=UpperCamelCase__							)
