



import copy
import inspect

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





@require_torch
class  __lowerCAmelCase			:
    __lowerCamelCase			=    ()
    __lowerCamelCase			=    True




    def 							snake_case       (							self		):



         """simple docstring"""





         _lowerCAmelCase      =   self.config_class

         # test default config
         _lowerCAmelCase      =   config_class()
         self.assertIsNotNone(__UpperCamelCase		)
         _lowerCAmelCase      =   ["""stem"""] + [F'stage{idx}' for idx in range(1						,    len(config.depths		) + 1		)]
         self.assertEqual(config.stage_names						,    __UpperCamelCase		)
         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
         _lowerCAmelCase      =   config_class(out_features=__UpperCamelCase						,    out_indices=__UpperCamelCase		)
         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
         _lowerCAmelCase      =   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
         _lowerCAmelCase      =   config_class(out_features=["""stage1""", """stage3"""]		)
         self.assertEqual(config.out_features						,    ["""stage1""", """stage3"""]		)
         self.assertEqual(config.out_indices						,    [1, 3]		)

         # Only out_indices set
         _lowerCAmelCase      =   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(__UpperCamelCase		):
              _lowerCAmelCase      =   config_class(out_features=["""stage1""", """stage2"""]						,    out_indices=[0, 2]		)




    def 							snake_case       (							self		):



         """simple docstring"""





         _lowerCAmelCase     ,     _lowerCAmelCase      =   self.model_tester.prepare_config_and_inputs_for_common()

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




    def 							snake_case       (							self		):



         """simple docstring"""





         _lowerCAmelCase     ,     _lowerCAmelCase      =   self.model_tester.prepare_config_and_inputs_for_common()

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

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

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




    def 							snake_case       (							self		):



         """simple docstring"""





         _lowerCAmelCase     ,     _lowerCAmelCase      =   self.model_tester.prepare_config_and_inputs_for_common()

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

              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
              _lowerCAmelCase      =   copy.deepcopy(__UpperCamelCase		)
              _lowerCAmelCase      =   None
              _lowerCAmelCase      =   model_class(__UpperCamelCase		)
              model.to(__UpperCamelCase		)
              model.eval()
              _lowerCAmelCase      =   model(**__UpperCamelCase		)

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

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

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

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




    def 							snake_case       (							self		):



         """simple docstring"""





         _lowerCAmelCase     ,     _lowerCAmelCase      =   self.model_tester.prepare_config_and_inputs_for_common()

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

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

              self.assertIsInstance(backbone.backbone_type						,    __UpperCamelCase		)
              # 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 							snake_case       (							self		):



         """simple docstring"""





         _lowerCAmelCase     ,     _lowerCAmelCase      =   self.model_tester.prepare_config_and_inputs_for_common()
         _lowerCAmelCase      =   inputs_dict["""pixel_values"""].shape[0]

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

              _lowerCAmelCase      =   backbone(**__UpperCamelCase		)

              # Test default outputs and verify feature maps
              self.assertIsInstance(outputs.feature_maps						,    __UpperCamelCase		)
              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
              _lowerCAmelCase      =   backbone(**__UpperCamelCase						,    output_hidden_states=__UpperCamelCase		)
              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:
                   _lowerCAmelCase      =   backbone(**__UpperCamelCase						,    output_attentions=__UpperCamelCase		)
                   self.assertIsNotNone(outputs.attentions		)








from math import exp


def 		_UpperCAmelCase    (				snake_case      ):





					"""simple docstring"""

					return 8 * x - 2 * exp(-x      )


def 		_UpperCAmelCase    (				snake_case     ,						snake_case     ,						snake_case      ):





					"""simple docstring"""

					_lowerCAmelCase      =   lower_bound
					_lowerCAmelCase      =   upper_bound
					for _ in range(0     ,						snake_case      ):
										_lowerCAmelCase     ,     _lowerCAmelCase      =   xa, xa - (f(snake_case      ) * (xa - xa)) / (f(snake_case      ) - f(snake_case      ))
					return xa


if __name__ == "__main__":
	print(f"Example: {secant_method(1, 3, 2)}")



