




'''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 				_snake_case	:
			lowerCAmelCase_  :   Any		 =					()
			lowerCAmelCase_  :   List[Any]		 =					True




			def      lowerCAmelCase__       (      self							)       ->       Dict:

										'''simple docstring'''




										snake_case_			      =   self.config_class

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




			def      lowerCAmelCase__       (      self							)       ->       Tuple:

										'''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(a__							)
																	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]       ,							a__							)




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

										'''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(a__							)
																	self.assertEqual(len(model.channels							)       ,							len(config.out_features							)							)
																	snake_case_			      =   model.num_features
																	snake_case_			      =   [config.stage_names.index(a__							) for feat in config.out_features]
																	snake_case_			      =   [num_features[idx] for idx in out_indices]
																	self.assertListEqual(model.channels       ,							a__							)

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

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




			def      lowerCAmelCase__       (      self							)       ->       Dict:

										'''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(a__							)
																	model.to(a__							)
																	model.eval()
																	snake_case_			      =   model(**a__							)

																	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(a__							)
																	snake_case_			      =   None
																	snake_case_			      =   model_class(a__							)
																	model.to(a__							)
																	model.eval()
																	snake_case_			      =   model(**a__							)

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

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

																	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(a__							)
																	snake_case_			      =   False
																	snake_case_			      =   model_class(a__							)
																	model.to(a__							)
																	model.eval()
																	snake_case_			      =   model(**a__							)




			def      lowerCAmelCase__       (      self							)       ->       List[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(a__							)

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

																	self.assertIsInstance(backbone.backbone_type       ,							a__							)
																	# 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							)       ->       Optional[int]:

										'''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(a__							)
																	backbone.to(a__							)
																	backbone.eval()

																	snake_case_			      =   backbone(**a__							)

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










'''simple docstring'''





import random
from typing import List, Optional, Union

import numpy as np
import torch

from ..state import AcceleratorState
from .constants import CUDA_DISTRIBUTED_TYPES
from .dataclasses import DistributedType, RNGType
from .imports import is_npu_available, is_tpu_available, is_xpu_available


if is_tpu_available(check_device=False):
		import torch_xla.core.xla_model as xm


def   UpperCamelCase_(			snake_case							: int							,       snake_case							: bool = False  ):

							'''simple docstring'''






							if device_specific:
														seed += AcceleratorState().process_index
							random.seed(snake_case  )
							np.random.seed(snake_case  )
							torch.manual_seed(snake_case  )
							if is_xpu_available():
														torch.xpu.manual_seed_all(snake_case  )
							elif is_npu_available():
														torch.npu.manual_seed_all(snake_case  )
							else:
														torch.cuda.manual_seed_all(snake_case  )
							# ^^ safe to call this function even if cuda is not available
							if is_tpu_available():
														xm.set_rng_state(snake_case  )


def   UpperCamelCase_(			snake_case							: Optional[RNGType] = None							,       snake_case							: Optional[torch.Generator] = None  ):

							'''simple docstring'''






							if rng_type == RNGType.TORCH:
														snake_case_			      =   torch.get_rng_state()
							elif rng_type == RNGType.CUDA:
														snake_case_			      =   torch.cuda.get_rng_state()
							elif rng_type == RNGType.XLA:
														assert is_tpu_available(), "Can't synchronize XLA seeds on an environment without TPUs."
														snake_case_			      =   torch.tensor(xm.get_rng_state()  )
							elif rng_type == RNGType.NPU:
														assert is_npu_available(), "Can't synchronize NPU seeds on an environment without NPUs."
														snake_case_			      =   torch.npu.get_rng_state()
							elif rng_type == RNGType.XPU:
														assert is_xpu_available(), "Can't synchronize XPU seeds on an environment without XPUs."
														snake_case_			      =   torch.xpu.get_rng_state()
							elif rng_type == RNGType.GENERATOR:
														assert generator is not None, "Need a generator to synchronize its seed."
														snake_case_			      =   generator.get_state()

							# Broadcast the rng state from device 0 to other devices
							snake_case_			      =   AcceleratorState()
							if state.distributed_type == DistributedType.TPU:
														snake_case_			      =   rng_state.to(xm.xla_device()  )
														xm.collective_broadcast([rng_state]  )
														xm.mark_step()
														snake_case_			      =   rng_state.cpu()
							elif (
							    state.distributed_type in CUDA_DISTRIBUTED_TYPES
							    or state.distributed_type == DistributedType.MULTI_NPU
							    or state.distributed_type == DistributedType.MULTI_XPU
							):
														snake_case_			      =   rng_state.to(state.device  )
														torch.distributed.broadcast(snake_case							,       0  )
														snake_case_			      =   rng_state.cpu()
							elif state.distributed_type == DistributedType.MULTI_CPU:
														torch.distributed.broadcast(snake_case							,       0  )

							# Set the broadcast rng state
							if rng_type == RNGType.TORCH:
														torch.set_rng_state(snake_case  )
							elif rng_type == RNGType.CUDA:
														torch.cuda.set_rng_state(snake_case  )
							elif rng_type == RNGType.NPU:
														torch.npu.set_rng_state(snake_case  )
							elif rng_type == RNGType.XPU:
														torch.xpu.set_rng_state(snake_case  )
							elif rng_type == RNGType.XLA:
														xm.set_rng_state(rng_state.item()  )
							elif rng_type == RNGType.GENERATOR:
														generator.set_state(snake_case  )




def   UpperCamelCase_(			snake_case							: List[Union[str, RNGType]]							,       snake_case							: Optional[torch.Generator] = None  ):

							'''simple docstring'''






							for rng_type in rng_types:
														synchronize_rng_state(RNGType(snake_case  )							,       generator=snake_case  )




