



"""simple docstring"""







import copy
import inspect

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





@require_torch
class   UpperCamelCase	:




	"""simple docstring"""
	SCREAMING_SNAKE_CASE_							:       Tuple						       =  ()
	SCREAMING_SNAKE_CASE_							:       Optional[Any]						       =  True






	def    lowerCamelCase__					(     self   ):
			_lowercase				: Any     =   self.config_class

			# test default config
			_lowercase				: List[str]     =   config_class()
			self.assertIsNotNone(UpperCAmelCase_   )
			_lowercase				: Optional[Any]     =   ["""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
			_lowercase				: Optional[Any]     =   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
			_lowercase				: Any     =   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				: str     =   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				: Any     =   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_   ):
					_lowercase				: str     =   config_class(out_features=["""stage1""", """stage2"""]				,out_indices=[0, 2]   )






	def    lowerCamelCase__					(     self   ):
			_lowercase     ,  _lowercase				: Tuple     =   self.model_tester.prepare_config_and_inputs_for_common()

			for model_class in self.all_model_classes:
					_lowercase				: List[str]     =   model_class(UpperCAmelCase_   )
					_lowercase				: int     =   inspect.signature(model.forward   )
					# signature.parameters is an OrderedDict => so arg_names order is deterministic
					_lowercase				: Optional[Any]     =   [*signature.parameters.keys()]
					_lowercase				: Dict     =   ["""pixel_values"""]
					self.assertListEqual(arg_names[:1]				,UpperCAmelCase_   )






	def    lowerCamelCase__					(     self   ):
			_lowercase     ,  _lowercase				: Tuple     =   self.model_tester.prepare_config_and_inputs_for_common()

			for model_class in self.all_model_classes:
					_lowercase				: Dict     =   model_class(UpperCAmelCase_   )
					self.assertEqual(len(model.channels   )				,len(config.out_features   )   )
					_lowercase				: Union[str, Any]     =   model.num_features
					_lowercase				: Optional[Any]     =   [config.stage_names.index(UpperCAmelCase_   ) for feat in config.out_features]
					_lowercase				: List[str]     =   [num_features[idx] for idx in out_indices]
					self.assertListEqual(model.channels				,UpperCAmelCase_   )

					_lowercase				: List[Any]     =   copy.deepcopy(UpperCAmelCase_   )
					_lowercase				: List[Any]     =   None
					_lowercase				: Optional[int]     =   model_class(UpperCAmelCase_   )
					self.assertEqual(len(model.channels   )				,1   )
					self.assertListEqual(model.channels				,[num_features[-1]]   )

					_lowercase				: int     =   copy.deepcopy(UpperCAmelCase_   )
					_lowercase				: Optional[int]     =   None
					_lowercase				: List[str]     =   model_class(UpperCAmelCase_   )
					self.assertEqual(len(model.channels   )				,1   )
					self.assertListEqual(model.channels				,[num_features[-1]]   )






	def    lowerCamelCase__					(     self   ):
			_lowercase     ,  _lowercase				: Optional[Any]     =   self.model_tester.prepare_config_and_inputs_for_common()

			for model_class in self.all_model_classes:
					_lowercase				: Optional[int]     =   model_class(UpperCAmelCase_   )
					model.to(UpperCAmelCase_   )
					model.eval()
					_lowercase				: Optional[int]     =   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
					_lowercase				: str     =   copy.deepcopy(UpperCAmelCase_   )
					_lowercase				: Dict     =   None
					_lowercase				: Union[str, Any]     =   model_class(UpperCAmelCase_   )
					model.to(UpperCAmelCase_   )
					model.eval()
					_lowercase				: int     =   model(**UpperCAmelCase_   )

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

					_lowercase				: List[str]     =   copy.deepcopy(UpperCAmelCase_   )
					_lowercase				: Any     =   None
					_lowercase				: int     =   model_class(UpperCAmelCase_   )
					model.to(UpperCAmelCase_   )
					model.eval()
					_lowercase				: Optional[int]     =   model(**UpperCAmelCase_   )

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

					# Check backbone can be initialized with fresh weights
					_lowercase				: int     =   copy.deepcopy(UpperCAmelCase_   )
					_lowercase				: int     =   False
					_lowercase				: int     =   model_class(UpperCAmelCase_   )
					model.to(UpperCAmelCase_   )
					model.eval()
					_lowercase				: Optional[int]     =   model(**UpperCAmelCase_   )






	def    lowerCamelCase__					(     self   ):
			_lowercase     ,  _lowercase				: Optional[int]     =   self.model_tester.prepare_config_and_inputs_for_common()

			for backbone_class in self.all_model_classes:
					_lowercase				: List[Any]     =   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    lowerCamelCase__					(     self   ):
			_lowercase     ,  _lowercase				: int     =   self.model_tester.prepare_config_and_inputs_for_common()
			_lowercase				: int     =   inputs_dict["""pixel_values"""].shape[0]

			for backbone_class in self.all_model_classes:
					_lowercase				: List[str]     =   backbone_class(UpperCAmelCase_   )
					backbone.to(UpperCAmelCase_   )
					backbone.eval()

					_lowercase				: str     =   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
					_lowercase				: List[Any]     =   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:
							_lowercase				: Any     =   backbone(**UpperCAmelCase_				,output_attentions=UpperCAmelCase_   )
							self.assertIsNotNone(outputs.attentions   )








"""simple docstring"""







import os
import pickle
import unittest
from collections import UserDict, namedtuple

import torch

from accelerate.test_utils.testing import require_cuda, require_torch_min_version
from accelerate.test_utils.training import RegressionModel
from accelerate.utils import (
    convert_outputs_to_fpaa,
    extract_model_from_parallel,
    find_device,
    listify,
    patch_environment,
    recursively_apply,
    send_to_device,
)


UpperCAmelCase:  Union[str, Any]			     =				namedtuple("""ExampleNamedTuple""", """a b c""")





class   UpperCamelCase	(     unittest.TestCase       ):




	"""simple docstring"""






	def    lowerCamelCase__					(     self   ):
			_lowercase				: List[Any]     =   torch.randn(5				,2   )
			_lowercase				: List[Any]     =   torch.device("""cuda"""   ) if torch.cuda.is_available() else torch.device("""cpu"""   )

			_lowercase				: int     =   send_to_device(UpperCAmelCase_				,UpperCAmelCase_   )
			self.assertTrue(torch.equal(resulta.cpu()				,UpperCAmelCase_   )   )

			_lowercase				: int     =   send_to_device((tensor, [tensor, tensor], 1)				,UpperCAmelCase_   )
			self.assertIsInstance(UpperCAmelCase_				,UpperCAmelCase_   )
			self.assertTrue(torch.equal(resulta[0].cpu()				,UpperCAmelCase_   )   )
			self.assertIsInstance(resulta[1]				,UpperCAmelCase_   )
			self.assertTrue(torch.equal(resulta[1][0].cpu()				,UpperCAmelCase_   )   )
			self.assertTrue(torch.equal(resulta[1][1].cpu()				,UpperCAmelCase_   )   )
			self.assertEqual(resulta[2]				,1   )

			_lowercase				: Any     =   send_to_device({"""a""": tensor, """b""": [tensor, tensor], """c""": 1}				,UpperCAmelCase_   )
			self.assertIsInstance(UpperCAmelCase_				,UpperCAmelCase_   )
			self.assertTrue(torch.equal(resulta["""a"""].cpu()				,UpperCAmelCase_   )   )
			self.assertIsInstance(resulta["""b"""]				,UpperCAmelCase_   )
			self.assertTrue(torch.equal(resulta["""b"""][0].cpu()				,UpperCAmelCase_   )   )
			self.assertTrue(torch.equal(resulta["""b"""][1].cpu()				,UpperCAmelCase_   )   )
			self.assertEqual(resulta["""c"""]				,1   )

			_lowercase				: Optional[int]     =   send_to_device(ExampleNamedTuple(a=UpperCAmelCase_				,b=[tensor, tensor]				,c=1   )				,UpperCAmelCase_   )
			self.assertIsInstance(UpperCAmelCase_				,UpperCAmelCase_   )
			self.assertTrue(torch.equal(resulta.a.cpu()				,UpperCAmelCase_   )   )
			self.assertIsInstance(resulta.b				,UpperCAmelCase_   )
			self.assertTrue(torch.equal(resulta.b[0].cpu()				,UpperCAmelCase_   )   )
			self.assertTrue(torch.equal(resulta.b[1].cpu()				,UpperCAmelCase_   )   )
			self.assertEqual(resulta.c				,1   )

			_lowercase				: str     =   send_to_device(UserDict({"""a""": tensor, """b""": [tensor, tensor], """c""": 1}   )				,UpperCAmelCase_   )
			self.assertIsInstance(UpperCAmelCase_				,UpperCAmelCase_   )
			self.assertTrue(torch.equal(resulta["""a"""].cpu()				,UpperCAmelCase_   )   )
			self.assertIsInstance(resulta["""b"""]				,UpperCAmelCase_   )
			self.assertTrue(torch.equal(resulta["""b"""][0].cpu()				,UpperCAmelCase_   )   )
			self.assertTrue(torch.equal(resulta["""b"""][1].cpu()				,UpperCAmelCase_   )   )
			self.assertEqual(resulta["""c"""]				,1   )






	def    lowerCamelCase__					(     self   ):
			with self.assertRaises(UpperCAmelCase_   ) as cm:
					_lowercase				: str     =   recursively_apply(torch.tensor				,(torch.tensor(1   ), 1)				,error_on_other_type=UpperCAmelCase_   )
			self.assertEqual(
			    str(cm.exception   )				,"""Unsupported types (<class 'int'>) passed to `tensor`. Only nested list/tuple/dicts of objects that are valid for `is_torch_tensor` should be passed."""				,)






	def    lowerCamelCase__					(     self   ):
			_lowercase				: Optional[int]     =   torch.tensor([1, 2, 3, 4, 5]   )
			self.assertEqual(listify(UpperCAmelCase_   )				,[1, 2, 3, 4, 5]   )

			_lowercase				: Optional[int]     =   torch.tensor([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]]   )
			self.assertEqual(listify(UpperCAmelCase_   )				,[[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]]   )

			_lowercase				: Optional[Any]     =   torch.tensor([[[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]], [[11, 12, 13, 14, 15], [16, 17, 18, 19, 20]]]   )
			self.assertEqual(
			    listify(UpperCAmelCase_   )				,[[[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]], [[11, 12, 13, 14, 15], [16, 17, 18, 19, 20]]]   )






	def    lowerCamelCase__					(     self   ):
			with patch_environment(aa=1				,BB=2   ):
					self.assertEqual(os.environ.get("""AA"""   )				,"""1"""   )
					self.assertEqual(os.environ.get("""BB"""   )				,"""2"""   )

			self.assertNotIn("""AA"""				,os.environ   )
			self.assertNotIn("""BB"""				,os.environ   )






	def    lowerCamelCase__					(     self   ):
			_lowercase				: Optional[Any]     =   RegressionModel()
			_lowercase				: List[Any]     =   model.forward
			_lowercase				: Optional[Any]     =   convert_outputs_to_fpaa(model.forward   )
			_lowercase				: Any     =   extract_model_from_parallel(UpperCAmelCase_				,keep_fpaa_wrapper=UpperCAmelCase_   )
			_lowercase				: Tuple     =   pickle.dumps(UpperCAmelCase_   )






	@require_cuda
	def    lowerCamelCase__					(     self   ):
			_lowercase				: str     =   RegressionModel()
			_lowercase				: Any     =   model.forward
			_lowercase				: Any     =   torch.cuda.amp.autocast(dtype=torch.floataa   )(model.forward   )
			_lowercase				: Optional[Any]     =   convert_outputs_to_fpaa(model.forward   )
			_lowercase				: Any     =   extract_model_from_parallel(UpperCAmelCase_				,keep_fpaa_wrapper=UpperCAmelCase_   )
			_lowercase				: Tuple     =   pickle.dumps(UpperCAmelCase_   )






	@require_cuda
	@require_torch_min_version(version="""2.0"""   )
	def    lowerCamelCase__					(     self   ):
			_lowercase				: str     =   RegressionModel()
			_lowercase				: Any     =   model.forward
			_lowercase				: Union[str, Any]     =   torch.cuda.amp.autocast(dtype=torch.floataa   )(model.forward   )
			_lowercase				: Optional[Any]     =   convert_outputs_to_fpaa(model.forward   )
			_lowercase				: Union[str, Any]     =   torch.compile(model.forward				,backend="""inductor"""   )
			_lowercase				: Any     =   torch.randn(4				,10   ).cuda()
			_lowercase				: int     =   model(UpperCAmelCase_   )






	def    lowerCamelCase__					(     self   ):
			_lowercase				: List[str]     =   RegressionModel()
			# could also do a test with DistributedDataParallel, but difficult to run on CPU or single GPU
			_lowercase				: Any     =   torch.nn.parallel.DataParallel(UpperCAmelCase_   )
			_lowercase				: List[Any]     =   extract_model_from_parallel(UpperCAmelCase_   )

			self.assertEqual(UpperCAmelCase_				,UpperCAmelCase_   )






	@require_torch_min_version(version="""2.0"""   )
	def    lowerCamelCase__					(     self   ):
			_lowercase				: int     =   RegressionModel()
			_lowercase				: List[str]     =   torch.compile(UpperCAmelCase_   )

			# could also do a test with DistributedDataParallel, but difficult to run on CPU or single GPU
			_lowercase				: Optional[int]     =   torch.nn.parallel.DataParallel(UpperCAmelCase_   )
			_lowercase				: int     =   torch.compile(UpperCAmelCase_   )
			_lowercase				: Dict     =   extract_model_from_parallel(UpperCAmelCase_   )

			self.assertEqual(compiled_model._orig_mod				,compiled_model_unwrapped._orig_mod   )






	def    lowerCamelCase__					(     self   ):
			self.assertEqual(find_device([1, """a""", torch.tensor([1, 2, 3]   )]   )				,torch.device("""cpu"""   )   )
			self.assertEqual(find_device({"""a""": 1, """b""": torch.tensor([1, 2, 3]   )}   )				,torch.device("""cpu"""   )   )
			self.assertIsNone(find_device([1, """a"""]   )   )



