






"""simple docstring"""






import copy
import inspect
import unittest

from transformers import AutoBackbone
from transformers.configuration_utils import PretrainedConfig
from transformers.testing_utils import require_timm, require_torch, torch_device
from transformers.utils.import_utils import is_torch_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor


if is_torch_available():
  import torch

  from transformers import TimmBackbone, TimmBackboneConfig

from ...test_pipeline_mixin import PipelineTesterMixin




class 							lowerCAmelCase__				:






      '''simple docstring'''

      def __init__(						self     :  int						,	lowercase_     :  List[str]						,	lowercase_     :  int=None						,	lowercase_     :  List[Any]=None						,	lowercase_     :  Optional[Any]=None						,	lowercase_     :  List[Any]="resnet50"						,	lowercase_     :  Dict=3						,	lowercase_     :  str=32						,	lowercase_     :  str=3						,	lowercase_     :  Tuple=True						,	lowercase_     :  str=True						,	):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Dict    						=		parent
          SCREAMING_SNAKE_CASE_      :  Tuple    						=		out_indices if out_indices is not None else [4]
          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		stage_names
          SCREAMING_SNAKE_CASE_      :  Any    						=		out_features
          SCREAMING_SNAKE_CASE_      :  List[str]    						=		backbone
          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		batch_size
          SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		image_size
          SCREAMING_SNAKE_CASE_      :  Dict    						=		num_channels
          SCREAMING_SNAKE_CASE_      :  Any    						=		use_pretrained_backbone
          SCREAMING_SNAKE_CASE_      :  Any    						=		is_training
      def _SCREAMING_SNAKE_CASE (						self     :  Optional[int]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  List[str]    						=		floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])
          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		self.get_config()

          return config, pixel_values
      def _SCREAMING_SNAKE_CASE (						self     :  Dict):




          '''simple docstring'''


          return TimmBackboneConfig(
              image_size=self.image_size						,	num_channels=self.num_channels						,	out_features=self.out_features						,	out_indices=self.out_indices						,	stage_names=self.stage_names						,	use_pretrained_backbone=self.use_pretrained_backbone						,	backbone=self.backbone						,	)
      def _SCREAMING_SNAKE_CASE (						self     :  List[str]						,	lowercase_     :  Dict						,	lowercase_     :  List[str]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Any    						=		TimmBackbone(config=lowercase_)
          model.to(lowercase_)
          model.eval()
          with torch.no_grad():
              SCREAMING_SNAKE_CASE_      :  List[Any]    						=		model(lowercase_)
          self.parent.assertEqual(
              result.feature_map[-1].shape						,	(self.batch_size, model.channels[-1], 14, 14)						,	)



      def _SCREAMING_SNAKE_CASE (						self     :  List[Any]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  List[str]    						=		self.prepare_config_and_inputs()
          SCREAMING_SNAKE_CASE_						,			SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		config_and_inputs
          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		{'''pixel_values''': pixel_values}
          return config, inputs_dict




@require_torch
@require_timm
class 							lowerCAmelCase__				(			UpperCAmelCase__				,		UpperCAmelCase__				,		UpperCAmelCase__				,		unittest.TestCase ):






      '''simple docstring'''

      __UpperCamelCase	 =  (TimmBackbone,) if is_torch_available() else ()
      __UpperCamelCase	 =  {"feature-extraction": TimmBackbone} if is_torch_available() else {}
      __UpperCamelCase	 =  False
      __UpperCamelCase	 =  False
      __UpperCamelCase	 =  False
      __UpperCamelCase	 =  False
      def _SCREAMING_SNAKE_CASE (						self     :  Any):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Dict    						=		TimmBackboneModelTester(self)
          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		ConfigTester(self						,	config_class=lowercase_						,	has_text_modality=lowercase_)
      def _SCREAMING_SNAKE_CASE (						self     :  Dict):




          '''simple docstring'''


          self.config_tester.create_and_test_config_to_json_string()
          self.config_tester.create_and_test_config_to_json_file()
          self.config_tester.create_and_test_config_from_and_save_pretrained()
          self.config_tester.create_and_test_config_with_num_labels()
          self.config_tester.check_config_can_be_init_without_params()
          self.config_tester.check_config_arguments_init()
      def _SCREAMING_SNAKE_CASE (						self     :  Dict):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		'''resnet18'''
          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		'''microsoft/resnet-18'''

          SCREAMING_SNAKE_CASE_      :  str    						=		AutoBackbone.from_pretrained(lowercase_						,	use_timm_backbone=lowercase_)
          SCREAMING_SNAKE_CASE_      :  str    						=		AutoBackbone.from_pretrained(lowercase_)

          self.assertEqual(len(timm_model.out_features)						,	len(transformers_model.out_features))
          self.assertEqual(len(timm_model.stage_names)						,	len(transformers_model.stage_names))
          self.assertEqual(timm_model.channels						,	transformers_model.channels)
          # Out indices are set to the last layer by default. For timm models, we don't know
          # the number of layers in advance, so we set it to (-1,), whereas for transformers
          # models, we set it to [len(stage_names) - 1] (kept for backward compatibility).
          self.assertEqual(timm_model.out_indices						,	(-1,))
          self.assertEqual(transformers_model.out_indices						,	[len(timm_model.stage_names) - 1])

          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		AutoBackbone.from_pretrained(lowercase_						,	use_timm_backbone=lowercase_						,	out_indices=[1, 2, 3])
          SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		AutoBackbone.from_pretrained(lowercase_						,	out_indices=[1, 2, 3])

          self.assertEqual(timm_model.out_indices						,	transformers_model.out_indices)
          self.assertEqual(len(timm_model.out_features)						,	len(transformers_model.out_features))
          self.assertEqual(timm_model.channels						,	transformers_model.channels)
      @unittest.skip('''TimmBackbone doesn\'t support feed forward chunking''')
      def _SCREAMING_SNAKE_CASE (						self     :  Union[str, Any]):




          '''simple docstring'''


          pass
      @unittest.skip('''TimmBackbone doesn\'t have num_hidden_layers attribute''')
      def _SCREAMING_SNAKE_CASE (						self     :  Optional[Any]):




          '''simple docstring'''


          pass
      @unittest.skip('''TimmBackbone initialization is managed on the timm side''')
      def _SCREAMING_SNAKE_CASE (						self     :  str):




          '''simple docstring'''


          pass
      @unittest.skip('''TimmBackbone models doesn\'t have inputs_embeds''')
      def _SCREAMING_SNAKE_CASE (						self     :  Optional[int]):




          '''simple docstring'''


          pass
      @unittest.skip('''TimmBackbone models doesn\'t have inputs_embeds''')
      def _SCREAMING_SNAKE_CASE (						self     :  Optional[Any]):




          '''simple docstring'''


          pass
      @unittest.skip('''TimmBackbone model cannot be created without specifying a backbone checkpoint''')
      def _SCREAMING_SNAKE_CASE (						self     :  Optional[int]):




          '''simple docstring'''


          pass
      @unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone''')
      def _SCREAMING_SNAKE_CASE (						self     :  Union[str, Any]):




          '''simple docstring'''


          pass
      @unittest.skip('''model weights aren\'t tied in TimmBackbone.''')
      def _SCREAMING_SNAKE_CASE (						self     :  List[str]):




          '''simple docstring'''


          pass
      @unittest.skip('''model weights aren\'t tied in TimmBackbone.''')
      def _SCREAMING_SNAKE_CASE (						self     :  int):




          '''simple docstring'''


          pass
      @unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone''')
      def _SCREAMING_SNAKE_CASE (						self     :  Any):




          '''simple docstring'''


          pass
      @unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone''')
      def _SCREAMING_SNAKE_CASE (						self     :  Union[str, Any]):




          '''simple docstring'''


          pass
      @unittest.skip('''TimmBackbone doesn\'t have hidden size info in its configuration.''')
      def _SCREAMING_SNAKE_CASE (						self     :  str):




          '''simple docstring'''


          pass
      @unittest.skip('''TimmBackbone doesn\'t support output_attentions.''')
      def _SCREAMING_SNAKE_CASE (						self     :  Union[str, Any]):




          '''simple docstring'''


          pass
      @unittest.skip('''Safetensors is not supported by timm.''')
      def _SCREAMING_SNAKE_CASE (						self     :  Union[str, Any]):




          '''simple docstring'''


          pass
      @unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.''')
      def _SCREAMING_SNAKE_CASE (						self     :  List[Any]):




          '''simple docstring'''


          pass
      def _SCREAMING_SNAKE_CASE (						self     :  Optional[int]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_						,			SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
              SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		model_class(lowercase_)
              SCREAMING_SNAKE_CASE_      :  List[Any]    						=		inspect.signature(model.forward)
              # signature.parameters is an OrderedDict => so arg_names order is deterministic
              SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		[*signature.parameters.keys()]

              SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		['''pixel_values''']
              self.assertListEqual(arg_names[:1]						,	lowercase_)
      def _SCREAMING_SNAKE_CASE (						self     :  Optional[int]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_						,			SCREAMING_SNAKE_CASE_      :  List[str]    						=		self.model_tester.prepare_config_and_inputs_for_common()
          SCREAMING_SNAKE_CASE_      :  List[str]    						=		True
          SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		self.has_attentions

          # no need to test all models as different heads yield the same functionality
          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		self.all_model_classes[0]
          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		model_class(lowercase_)
          model.to(lowercase_)

          SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		self._prepare_for_class(lowercase_						,	lowercase_)
          SCREAMING_SNAKE_CASE_      :  List[str]    						=		model(**lowercase_)
          SCREAMING_SNAKE_CASE_      :  int    						=		outputs[0][-1]

          # Encoder-/Decoder-only models
          SCREAMING_SNAKE_CASE_      :  List[str]    						=		outputs.hidden_states[0]
          hidden_states.retain_grad()

          if self.has_attentions:
              SCREAMING_SNAKE_CASE_      :  Any    						=		outputs.attentions[0]
              attentions.retain_grad()

          output.flatten()[0].backward(retain_graph=lowercase_)

          self.assertIsNotNone(hidden_states.grad)

          if self.has_attentions:
              self.assertIsNotNone(attentions.grad)



      def _SCREAMING_SNAKE_CASE (						self     :  Union[str, Any]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_						,			SCREAMING_SNAKE_CASE_      :  str    						=		self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
              SCREAMING_SNAKE_CASE_      :  int    						=		model_class(lowercase_)
              model.to(lowercase_)
              model.eval()
              SCREAMING_SNAKE_CASE_      :  int    						=		model(**lowercase_)

              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
              SCREAMING_SNAKE_CASE_      :  List[str]    						=		copy.deepcopy(lowercase_)
              SCREAMING_SNAKE_CASE_      :  int    						=		None
              SCREAMING_SNAKE_CASE_      :  Any    						=		model_class(lowercase_)
              model.to(lowercase_)
              model.eval()
              SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		model(**lowercase_)

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

              # Check backbone can be initialized with fresh weights
              SCREAMING_SNAKE_CASE_      :  int    						=		copy.deepcopy(lowercase_)
              SCREAMING_SNAKE_CASE_      :  List[str]    						=		False
              SCREAMING_SNAKE_CASE_      :  Any    						=		model_class(lowercase_)
              model.to(lowercase_)
              model.eval()
              SCREAMING_SNAKE_CASE_      :  Dict    						=		model(**lowercase_)






from math import isclose, sqrt


def   _SCREAMING_SNAKE_CASE	( SCREAMING_SNAKE_CASE ,			SCREAMING_SNAKE_CASE ,			SCREAMING_SNAKE_CASE       ):
  A_      :				List[str]		     =					point_y / 4 / point_x
  A_      :				Union[str, Any]		     =					2 * normal_gradient / (1 + normal_gradient * normal_gradient)
  A_      :				int		     =					(1 - normal_gradient * normal_gradient) / (
      1 + normal_gradient * normal_gradient
  )
  A_      :				List[str]		     =					(sa - ca * incoming_gradient) / (ca + sa * incoming_gradient)

  # to find the next point, solve the simultaeneous equations:
  # y^2 + 4x^2 = 100
  # y - b = m * (x - a)
  # ==> A x^2 + B x + C = 0
  A_      :				List[str]		     =					outgoing_gradient**2 + 4
  A_      :				List[str]		     =					2 * outgoing_gradient * (point_y - outgoing_gradient * point_x)
  A_      :				Any		     =					(point_y - outgoing_gradient * point_x) ** 2 - 100

  A_      :				str		     =					(
      -linear_term - sqrt(linear_term**2 - 4 * quadratic_term * constant_term       )
  ) / (2 * quadratic_term)
  A_      :				Any		     =					(
      -linear_term + sqrt(linear_term**2 - 4 * quadratic_term * constant_term       )
  ) / (2 * quadratic_term)

  # two solutions, one of which is our input point
  A_      :				int		     =					x_minus if isclose(SCREAMING_SNAKE_CASE ,			SCREAMING_SNAKE_CASE       ) else x_plus
  A_      :				Any		     =					point_y + outgoing_gradient * (next_x - point_x)

  return next_x, next_y, outgoing_gradient


def   _SCREAMING_SNAKE_CASE	( SCREAMING_SNAKE_CASE = 1.4 ,			SCREAMING_SNAKE_CASE = -9.6       ):
  A_      :				int		     =					0
  A_      :				float		     =					first_x_coord
  A_      :				float		     =					first_y_coord
  A_      :				float		     =					(1_0.1 - point_y) / (0.0 - point_x)

  while not (-0.0_1 <= point_x <= 0.0_1 and point_y > 0):
    A_     ,       A_     ,       A_      :				List[str]		     =					next_point(SCREAMING_SNAKE_CASE ,			SCREAMING_SNAKE_CASE ,			SCREAMING_SNAKE_CASE       )
    num_reflections += 1

  return num_reflections


if __name__ == "__main__":
     print(F'''{solution() = }''')




