





"""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 	__a   :
     SCREAMING_SNAKE_CASE__ :      Tuple       		=			()
     SCREAMING_SNAKE_CASE__ :      Optional[Any]       		=			True



     def 						snake_case_			(       self   ):
            _lowerCamelCase    	=					self.config_class

            # test default config
            _lowerCamelCase    	=					config_class()
            self.assertIsNotNone(a__   )
            _lowerCamelCase    	=					['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
            _lowerCamelCase    	=					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
            _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(a__   ):
                   _lowerCamelCase    	=					config_class(out_features=['stage1', 'stage2']					,     out_indices=[0, 2]   )



     def 						snake_case_			(       self   ):
            _lowerCamelCase	,	_lowerCamelCase    	=					self.model_tester.prepare_config_and_inputs_for_common()

            for model_class in self.all_model_classes:
                   _lowerCamelCase    	=					model_class(a__   )
                   _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]					,     a__   )



     def 						snake_case_			(       self   ):
            _lowerCamelCase	,	_lowerCamelCase    	=					self.model_tester.prepare_config_and_inputs_for_common()

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

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

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



     def 						snake_case_			(       self   ):
            _lowerCamelCase	,	_lowerCamelCase    	=					self.model_tester.prepare_config_and_inputs_for_common()

            for model_class in self.all_model_classes:
                   _lowerCamelCase    	=					model_class(a__   )
                   model.to(a__   )
                   model.eval()
                   _lowerCamelCase    	=					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
                   _lowerCamelCase    	=					copy.deepcopy(a__   )
                   _lowerCamelCase    	=					None
                   _lowerCamelCase    	=					model_class(a__   )
                   model.to(a__   )
                   model.eval()
                   _lowerCamelCase    	=					model(**a__   )

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

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

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

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



     def 						snake_case_			(       self   ):
            _lowerCamelCase	,	_lowerCamelCase    	=					self.model_tester.prepare_config_and_inputs_for_common()

            for backbone_class in self.all_model_classes:
                   _lowerCamelCase    	=					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 						snake_case_			(       self   ):
            _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(a__   )
                   backbone.to(a__   )
                   backbone.eval()

                   _lowerCamelCase    	=					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
                   _lowerCamelCase    	=					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:
                          _lowerCamelCase    	=					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 SCREAMING_SNAKE_CASE_   (       snake_case   :					int						,  snake_case   :					bool = False		)->		Any:
       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 SCREAMING_SNAKE_CASE_   (       snake_case   :					Optional[RNGType] = None						,  snake_case   :					Optional[torch.Generator] = None		)->		str:
       # Get the proper rng state
       if rng_type == RNGType.TORCH:
              _lowerCamelCase    	=					torch.get_rng_state()
       elif rng_type == RNGType.CUDA:
              _lowerCamelCase    	=					torch.cuda.get_rng_state()
       elif rng_type == RNGType.XLA:
              assert is_tpu_available(), "Can't synchronize XLA seeds on an environment without TPUs."
              _lowerCamelCase    	=					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."
              _lowerCamelCase    	=					torch.npu.get_rng_state()
       elif rng_type == RNGType.XPU:
              assert is_xpu_available(), "Can't synchronize XPU seeds on an environment without XPUs."
              _lowerCamelCase    	=					torch.xpu.get_rng_state()
       elif rng_type == RNGType.GENERATOR:
              assert generator is not None, "Need a generator to synchronize its seed."
              _lowerCamelCase    	=					generator.get_state()

       # Broadcast the rng state from device 0 to other devices
       _lowerCamelCase    	=					AcceleratorState()
       if state.distributed_type == DistributedType.TPU:
              _lowerCamelCase    	=					rng_state.to(xm.xla_device()		)
              xm.collective_broadcast([rng_state]		)
              xm.mark_step()
              _lowerCamelCase    	=					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
       ):
              _lowerCamelCase    	=					rng_state.to(state.device		)
              torch.distributed.broadcast(snake_case						,  0		)
              _lowerCamelCase    	=					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 SCREAMING_SNAKE_CASE_   (       snake_case   :					List[Union[str, RNGType]]						,  snake_case   :					Optional[torch.Generator] = None		)->		int:
       for rng_type in rng_types:
              synchronize_rng_state(RNGType(snake_case		)						,  generator=snake_case		)






