



import copy
import inspect

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


@require_torch
class 	a__       :


					"""simple docstring"""



					A__  :				Tuple					 =				()
					A__  :				Optional[Any]					 =				True

					def 				__UpperCAmelCase		(		self     :Tuple    ):
										lowercase						   =       self.config_class

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

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

					def 				__UpperCAmelCase		(		self     :Union[str, Any]    ):
										lowercase   ,      lowercase						   =       self.model_tester.prepare_config_and_inputs_for_common()

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

					def 				__UpperCAmelCase		(		self     :Optional[Any]    ):
										lowercase   ,      lowercase						   =       self.model_tester.prepare_config_and_inputs_for_common()

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

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

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

					def 				__UpperCAmelCase		(		self     :str    ):
										lowercase   ,      lowercase						   =       self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
															lowercase						   =       model_class(lowercase__    )
															model.to(lowercase__    )
															model.eval()
															lowercase						   =       model(**lowercase__    )

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

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

															lowercase						   =       copy.deepcopy(lowercase__    )
															lowercase						   =       None
															lowercase						   =       model_class(lowercase__    )
															model.to(lowercase__    )
															model.eval()
															lowercase						   =       model(**lowercase__    )

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

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

					def 				__UpperCAmelCase		(		self     :Dict    ):
										lowercase   ,      lowercase						   =       self.model_tester.prepare_config_and_inputs_for_common()

										for backbone_class in self.all_model_classes:
															lowercase						   =       backbone_class(lowercase__    )

															self.assertTrue(hasattr(lowercase__      ,  'backbone_type'    )    )
															self.assertTrue(hasattr(lowercase__      ,  'stage_names'    )    )
															self.assertTrue(hasattr(lowercase__      ,  'num_features'    )    )
															self.assertTrue(hasattr(lowercase__      ,  'out_indices'    )    )
															self.assertTrue(hasattr(lowercase__      ,  'out_features'    )    )
															self.assertTrue(hasattr(lowercase__      ,  'out_feature_channels'    )    )
															self.assertTrue(hasattr(lowercase__      ,  'channels'    )    )

															self.assertIsInstance(backbone.backbone_type      ,  lowercase__    )
															# 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 				__UpperCAmelCase		(		self     :Tuple    ):
										lowercase   ,      lowercase						   =       self.model_tester.prepare_config_and_inputs_for_common()
										lowercase						   =       inputs_dict['pixel_values'].shape[0]

										for backbone_class in self.all_model_classes:
															lowercase						   =       backbone_class(lowercase__    )
															backbone.to(lowercase__    )
															backbone.eval()

															lowercase						   =       backbone(**lowercase__    )

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











from __future__ import annotations





def 		__snake_case						(    _UpperCAmelCase       ,			_UpperCAmelCase       ,			_UpperCAmelCase				):
					"""simple docstring"""






					assert (
					    c % greatest_common_divisor(_UpperCAmelCase       ,			_UpperCAmelCase				) == 0
					)  # greatest_common_divisor(a,b) function implemented below
					((lowercase)   ,      (lowercase)   ,      (lowercase))						   =       extended_gcd(_UpperCAmelCase       ,			_UpperCAmelCase				)  # extended_gcd(a,b) function implemented below
					lowercase						   =       c / d
					return (r * x, r * y)





def 		__snake_case						(    _UpperCAmelCase       ,			_UpperCAmelCase       ,			_UpperCAmelCase       ,			_UpperCAmelCase = 2				):
					"""simple docstring"""






					((lowercase)   ,      (lowercase))						   =       diophantine(_UpperCAmelCase       ,			_UpperCAmelCase       ,			_UpperCAmelCase				)  # Initial value
					lowercase						   =       greatest_common_divisor(_UpperCAmelCase       ,			_UpperCAmelCase				)
					lowercase						   =       a // d
					lowercase						   =       b // d

					for i in range(_UpperCAmelCase				):
										lowercase						   =       xa + i * q
										lowercase						   =       ya - i * p
										print(_UpperCAmelCase       ,			_UpperCAmelCase				)





def 		__snake_case						(    _UpperCAmelCase       ,			_UpperCAmelCase				):
					"""simple docstring"""






					if a < b:
										lowercase   ,      lowercase						   =       b, a

					while a % b != 0:
										lowercase   ,      lowercase						   =       b, a % b

					return b





def 		__snake_case						(    _UpperCAmelCase       ,			_UpperCAmelCase				):
					"""simple docstring"""






					assert a >= 0 and b >= 0

					if b == 0:
										lowercase   ,      lowercase   ,      lowercase						   =       a, 1, 0
					else:
										((lowercase)   ,      (lowercase)   ,      (lowercase))						   =       extended_gcd(_UpperCAmelCase       ,			a % b				)
										lowercase						   =       q
										lowercase						   =       p - q * (a // b)

					assert a % d == 0 and b % d == 0
					assert d == a * x + b * y

					return (d, x, y)


if __name__ == "__main__":
		from doctest import testmod

		testmod(name='''diophantine''', verbose=True)
		testmod(name='''diophantine_all_soln''', verbose=True)
		testmod(name='''extended_gcd''', verbose=True)
		testmod(name='''greatest_common_divisor''', verbose=True)






