


import copy
import inspect

from transformers.testing_utils import require_torch, torch_device
from transformers.utils.backbone_utils import BackboneType


@require_torch
class       __lowerCAmelCase       :






  """simple docstring"""





  _SCREAMING_SNAKE_CASE						      =    ()
  _SCREAMING_SNAKE_CASE						      =    True



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




     """simple docstring"""
     snake_case_         =   self.config_class

     # test default config
     snake_case_         =   config_class()
     self.assertIsNotNone(_lowerCAmelCase					)
     snake_case_         =   ["stem"] + [F'''stage{idx}''' for idx in range(1      ,			len(config.depths					) + 1					)]
     self.assertEqual(config.stage_names      ,			_lowerCAmelCase					)
     self.assertTrue(set(config.out_features					).issubset(set(config.stage_names					)					)					)

     # Test out_features and out_indices are correctly set
     # out_features and out_indices both None
     snake_case_         =   config_class(out_features=_lowerCAmelCase      ,			out_indices=_lowerCAmelCase					)
     self.assertEqual(config.out_features      ,			[config.stage_names[-1]]					)
     self.assertEqual(config.out_indices      ,			[len(config.stage_names					) - 1]					)

     # out_features and out_indices both set
     snake_case_         =   config_class(out_features=["stem", "stage1"]      ,			out_indices=[0, 1]					)
     self.assertEqual(config.out_features      ,			["stem", "stage1"]					)
     self.assertEqual(config.out_indices      ,			[0, 1]					)

     # Only out_features set
     snake_case_         =   config_class(out_features=["stage1", "stage3"]					)
     self.assertEqual(config.out_features      ,			["stage1", "stage3"]					)
     self.assertEqual(config.out_indices      ,			[1, 3]					)

     # Only out_indices set
     snake_case_         =   config_class(out_indices=[0, 2]					)
     self.assertEqual(config.out_features      ,			[config.stage_names[0], config.stage_names[2]]					)
     self.assertEqual(config.out_indices      ,			[0, 2]					)

     # Error raised when out_indices do not correspond to out_features
     with self.assertRaises(_lowerCAmelCase					):
        snake_case_         =   config_class(out_features=["stage1", "stage2"]      ,			out_indices=[0, 2]					)



  def    lowerCAmelCase__					(       self    :    str					)				->	int:




     """simple docstring"""
     snake_case_      ,      snake_case_         =   self.model_tester.prepare_config_and_inputs_for_common()

     for model_class in self.all_model_classes:
        snake_case_         =   model_class(_lowerCAmelCase					)
        snake_case_         =   inspect.signature(model.forward					)
        # signature.parameters is an OrderedDict => so arg_names order is deterministic
        snake_case_         =   [*signature.parameters.keys()]
        snake_case_         =   ["pixel_values"]
        self.assertListEqual(arg_names[:1]      ,			_lowerCAmelCase					)



  def    lowerCAmelCase__					(       self    :    List[Any]					)				->	int:




     """simple docstring"""
     snake_case_      ,      snake_case_         =   self.model_tester.prepare_config_and_inputs_for_common()

     for model_class in self.all_model_classes:
        snake_case_         =   model_class(_lowerCAmelCase					)
        self.assertEqual(len(model.channels					)      ,			len(config.out_features					)					)
        snake_case_         =   model.num_features
        snake_case_         =   [config.stage_names.index(_lowerCAmelCase					) for feat in config.out_features]
        snake_case_         =   [num_features[idx] for idx in out_indices]
        self.assertListEqual(model.channels      ,			_lowerCAmelCase					)

        snake_case_         =   copy.deepcopy(_lowerCAmelCase					)
        snake_case_         =   None
        snake_case_         =   model_class(_lowerCAmelCase					)
        self.assertEqual(len(model.channels					)      ,			1					)
        self.assertListEqual(model.channels      ,			[num_features[-1]]					)

        snake_case_         =   copy.deepcopy(_lowerCAmelCase					)
        snake_case_         =   None
        snake_case_         =   model_class(_lowerCAmelCase					)
        self.assertEqual(len(model.channels					)      ,			1					)
        self.assertListEqual(model.channels      ,			[num_features[-1]]					)



  def    lowerCAmelCase__					(       self    :    Optional[int]					)				->	str:




     """simple docstring"""
     snake_case_      ,      snake_case_         =   self.model_tester.prepare_config_and_inputs_for_common()

     for model_class in self.all_model_classes:
        snake_case_         =   model_class(_lowerCAmelCase					)
        model.to(_lowerCAmelCase					)
        model.eval()
        snake_case_         =   model(**_lowerCAmelCase					)

        self.assertEqual(len(result.feature_maps					)      ,			len(config.out_features					)					)
        self.assertEqual(len(model.channels					)      ,			len(config.out_features					)					)
        self.assertEqual(len(result.feature_maps					)      ,			len(config.out_indices					)					)
        self.assertEqual(len(model.channels					)      ,			len(config.out_indices					)					)

        # Check output of last stage is taken if out_features=None, out_indices=None
        snake_case_         =   copy.deepcopy(_lowerCAmelCase					)
        snake_case_         =   None
        snake_case_         =   model_class(_lowerCAmelCase					)
        model.to(_lowerCAmelCase					)
        model.eval()
        snake_case_         =   model(**_lowerCAmelCase					)

        self.assertEqual(len(result.feature_maps					)      ,			1					)
        self.assertEqual(len(model.channels					)      ,			1					)

        snake_case_         =   copy.deepcopy(_lowerCAmelCase					)
        snake_case_         =   None
        snake_case_         =   model_class(_lowerCAmelCase					)
        model.to(_lowerCAmelCase					)
        model.eval()
        snake_case_         =   model(**_lowerCAmelCase					)

        self.assertEqual(len(result.feature_maps					)      ,			1					)
        self.assertEqual(len(model.channels					)      ,			1					)

        # Check backbone can be initialized with fresh weights
        snake_case_         =   copy.deepcopy(_lowerCAmelCase					)
        snake_case_         =   False
        snake_case_         =   model_class(_lowerCAmelCase					)
        model.to(_lowerCAmelCase					)
        model.eval()
        snake_case_         =   model(**_lowerCAmelCase					)



  def    lowerCAmelCase__					(       self    :    Tuple					)				->	Optional[Any]:




     """simple docstring"""
     snake_case_      ,      snake_case_         =   self.model_tester.prepare_config_and_inputs_for_common()

     for backbone_class in self.all_model_classes:
        snake_case_         =   backbone_class(_lowerCAmelCase					)

        self.assertTrue(hasattr(_lowerCAmelCase      ,			"backbone_type"					)					)
        self.assertTrue(hasattr(_lowerCAmelCase      ,			"stage_names"					)					)
        self.assertTrue(hasattr(_lowerCAmelCase      ,			"num_features"					)					)
        self.assertTrue(hasattr(_lowerCAmelCase      ,			"out_indices"					)					)
        self.assertTrue(hasattr(_lowerCAmelCase      ,			"out_features"					)					)
        self.assertTrue(hasattr(_lowerCAmelCase      ,			"out_feature_channels"					)					)
        self.assertTrue(hasattr(_lowerCAmelCase      ,			"channels"					)					)

        self.assertIsInstance(backbone.backbone_type      ,			_lowerCAmelCase					)
        # Verify num_features has been initialized in the backbone init
        self.assertIsNotNone(backbone.num_features					)
        self.assertTrue(len(backbone.channels					) == len(backbone.out_indices					)					)
        self.assertTrue(len(backbone.stage_names					) == len(backbone.num_features					)					)
        self.assertTrue(len(backbone.channels					) <= len(backbone.num_features					)					)
        self.assertTrue(len(backbone.out_feature_channels					) == len(backbone.stage_names					)					)



  def    lowerCAmelCase__					(       self    :    List[str]					)				->	Tuple:




     """simple docstring"""
     snake_case_      ,      snake_case_         =   self.model_tester.prepare_config_and_inputs_for_common()
     snake_case_         =   inputs_dict["pixel_values"].shape[0]

     for backbone_class in self.all_model_classes:
        snake_case_         =   backbone_class(_lowerCAmelCase					)
        backbone.to(_lowerCAmelCase					)
        backbone.eval()

        snake_case_         =   backbone(**_lowerCAmelCase					)

        # Test default outputs and verify feature maps
        self.assertIsInstance(outputs.feature_maps      ,			_lowerCAmelCase					)
        self.assertTrue(len(outputs.feature_maps					) == len(backbone.channels					)					)
        for feature_map, n_channels in zip(outputs.feature_maps      ,			backbone.channels					):
           self.assertTrue(feature_map.shape[:2]      ,			(batch_size, n_channels)					)
        self.assertIsNone(outputs.hidden_states					)
        self.assertIsNone(outputs.attentions					)

        # Test output_hidden_states=True
        snake_case_         =   backbone(**_lowerCAmelCase      ,			output_hidden_states=_lowerCAmelCase					)
        self.assertIsNotNone(outputs.hidden_states					)
        self.assertTrue(len(outputs.hidden_states					)      ,			len(backbone.stage_names					)					)
        for hidden_state, n_channels in zip(outputs.hidden_states      ,			backbone.channels					):
           self.assertTrue(hidden_state.shape[:2]      ,			(batch_size, n_channels)					)

        # Test output_attentions=True
        if self.has_attentions:
           snake_case_         =   backbone(**_lowerCAmelCase      ,			output_attentions=_lowerCAmelCase					)
           self.assertIsNotNone(outputs.attentions					)








from typing import Any

import numpy as np



def      _lowerCAmelCase  (							lowerCAmelCase_							:np.ndarray							)->bool:
   '''simple docstring'''






   assert np.shape(lowerCAmelCase_							)[0] == np.shape(lowerCAmelCase_							)[1]

   # If matrix not symmetric, exit right away.
   if np.allclose(lowerCAmelCase_						,  matrix.T							) is False:
      return False

   # Get eigenvalues and eignevectors for a symmetric matrix.
   snake_case_      ,      snake_case_         =   np.linalg.eigh(lowerCAmelCase_							)

   # Check sign of all eigenvalues.
   # np.all returns a value of type np.bool_
   return bool(np.all(eigen_values > 0							)							)



def      _lowerCAmelCase  (							lowerCAmelCase_							:int							)->Any:
   '''simple docstring'''






   snake_case_         =   np.random.randn(lowerCAmelCase_						,  lowerCAmelCase_							)
   snake_case_         =   np.dot(lowerCAmelCase_						,  random_matrix.T							)
   assert _is_matrix_spd(lowerCAmelCase_							)
   return spd_matrix



def      _lowerCAmelCase  (							lowerCAmelCase_							:np.ndarray						,  lowerCAmelCase_							:np.ndarray						,  lowerCAmelCase_							:int = 1_000						,  lowerCAmelCase_							:float = 1e-8						,  )->Any:
   '''simple docstring'''






   assert np.shape(lowerCAmelCase_							)[0] == np.shape(lowerCAmelCase_							)[1]
   assert np.shape(lowerCAmelCase_							)[0] == np.shape(lowerCAmelCase_							)[0]
   assert _is_matrix_spd(lowerCAmelCase_							)

   # Initialize solution guess, residual, search direction.
   snake_case_         =   np.zeros((np.shape(lowerCAmelCase_							)[0], 1)							)
   snake_case_         =   np.copy(lowerCAmelCase_							)
   snake_case_         =   np.copy(lowerCAmelCase_							)

   # Set initial errors in solution guess and residual.
   snake_case_         =   1e9
   snake_case_         =   1e9
   snake_case_         =   1e9

   # Set iteration counter to threshold number of iterations.
   snake_case_         =   0

   while error > tol:
      # Save this value so we only calculate the matrix-vector product once.
      snake_case_         =   np.dot(lowerCAmelCase_						,  lowerCAmelCase_							)

      # The main algorithm.

      # Update search direction magnitude.
      snake_case_         =   np.dot(ra.T						,  lowerCAmelCase_							) / np.dot(pa.T						,  lowerCAmelCase_							)
      # Update solution guess.
      snake_case_         =   xa + alpha * pa
      # Calculate new residual.
      snake_case_         =   ra - alpha * w
      # Calculate new Krylov subspace scale.
      snake_case_         =   np.dot(r.T						,  lowerCAmelCase_							) / np.dot(ra.T						,  lowerCAmelCase_							)
      # Calculate new A conjuage search direction.
      snake_case_         =   r + beta * pa

      # Calculate errors.
      snake_case_         =   np.linalg.norm(r - ra							)
      snake_case_         =   np.linalg.norm(x - xa							)
      snake_case_         =   np.maximum(lowerCAmelCase_						,  lowerCAmelCase_							)

      # Update variables.
      snake_case_         =   np.copy(lowerCAmelCase_							)
      snake_case_         =   np.copy(lowerCAmelCase_							)
      snake_case_         =   np.copy(lowerCAmelCase_							)

      # Update number of iterations.
      iterations += 1
      if iterations > max_iterations:
         break

   return x



def      _lowerCAmelCase  (							)->None:
   '''simple docstring'''






   snake_case_         =   3
   snake_case_         =   _create_spd_matrix(lowerCAmelCase_							)
   snake_case_         =   np.random.randn(lowerCAmelCase_						,  1							)
   snake_case_         =   np.dot(lowerCAmelCase_						,  lowerCAmelCase_							)

   # Numpy solution.
   snake_case_         =   np.linalg.solve(lowerCAmelCase_						,  lowerCAmelCase_							)

   # Our implementation.
   snake_case_         =   conjugate_gradient(lowerCAmelCase_						,  lowerCAmelCase_							)

   # Ensure both solutions are close to x_true (and therefore one another).
   assert np.linalg.norm(x_numpy - x_true							) <= 1e-6
   assert np.linalg.norm(x_conjugate_gradient - x_true							) <= 1e-6


if __name__ == "__main__":
   import doctest

   doctest.testmod()
   test_conjugate_gradient()




