


'''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 					__magic_name__							:
       UpperCAmelCase						      =()
       UpperCAmelCase						      =True






       def 			lowerCAmelCase		(			self)						->  Optional[int]:




          '''simple docstring'''
          _UpperCAmelCase   :   Union[str, Any]							    =self.config_class

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






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




          '''simple docstring'''
          _UpperCAmelCase   :   Tuple							    =self.model_tester.prepare_config_and_inputs_for_common()

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






       def 			lowerCAmelCase		(			self)						->  List[str]:




          '''simple docstring'''
          _UpperCAmelCase   :   str							    =self.model_tester.prepare_config_and_inputs_for_common()

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

             _UpperCAmelCase   :   Tuple							    =copy.deepcopy(lowerCAmelCase__)
             _UpperCAmelCase   :   Dict							    =None
             _UpperCAmelCase   :   Optional[Any]							    =model_class(lowerCAmelCase__)
             self.assertEqual(len(model.channels)  ,							1)
             self.assertListEqual(model.channels  ,							[num_features[-1]])

             _UpperCAmelCase   :   Dict							    =copy.deepcopy(lowerCAmelCase__)
             _UpperCAmelCase   :   Tuple							    =None
             _UpperCAmelCase   :   int							    =model_class(lowerCAmelCase__)
             self.assertEqual(len(model.channels)  ,							1)
             self.assertListEqual(model.channels  ,							[num_features[-1]])






       def 			lowerCAmelCase		(			self)						->  List[str]:




          '''simple docstring'''
          _UpperCAmelCase   :   Optional[Any]							    =self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
             _UpperCAmelCase   :   Optional[Any]							    =model_class(lowerCAmelCase__)
             model.to(lowerCAmelCase__)
             model.eval()
             _UpperCAmelCase   :   Optional[Any]							    =model(**lowerCAmelCase__)

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

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

             _UpperCAmelCase   :   Tuple							    =copy.deepcopy(lowerCAmelCase__)
             _UpperCAmelCase   :   int							    =None
             _UpperCAmelCase   :   Dict							    =model_class(lowerCAmelCase__)
             model.to(lowerCAmelCase__)
             model.eval()
             _UpperCAmelCase   :   List[str]							    =model(**lowerCAmelCase__)

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

             # Check backbone can be initialized with fresh weights
             _UpperCAmelCase   :   Tuple							    =copy.deepcopy(lowerCAmelCase__)
             _UpperCAmelCase   :   Dict							    =False
             _UpperCAmelCase   :   Optional[Any]							    =model_class(lowerCAmelCase__)
             model.to(lowerCAmelCase__)
             model.eval()
             _UpperCAmelCase   :   str							    =model(**lowerCAmelCase__)






       def 			lowerCAmelCase		(			self)						->  Tuple:




          '''simple docstring'''
          _UpperCAmelCase   :   Optional[Any]							    =self.model_tester.prepare_config_and_inputs_for_common()

          for backbone_class in self.all_model_classes:
             _UpperCAmelCase   :   List[str]							    =backbone_class(lowerCAmelCase__)

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

             self.assertIsInstance(backbone.backbone_type  ,							lowerCAmelCase__)
             # 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)						->  str:




          '''simple docstring'''
          _UpperCAmelCase   :   List[str]							    =self.model_tester.prepare_config_and_inputs_for_common()
          _UpperCAmelCase   :   Tuple							    =inputs_dict['pixel_values'].shape[0]

          for backbone_class in self.all_model_classes:
             _UpperCAmelCase   :   Optional[int]							    =backbone_class(lowerCAmelCase__)
             backbone.to(lowerCAmelCase__)
             backbone.eval()

             _UpperCAmelCase   :   Dict							    =backbone(**lowerCAmelCase__)

             # Test default outputs and verify feature maps
             self.assertIsInstance(outputs.feature_maps  ,							lowerCAmelCase__)
             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
             _UpperCAmelCase   :   List[Any]							    =backbone(**lowerCAmelCase__  ,							output_hidden_states=lowerCAmelCase__)
             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:
                _UpperCAmelCase   :   Tuple							    =backbone(**lowerCAmelCase__  ,							output_attentions=lowerCAmelCase__)
                self.assertIsNotNone(outputs.attentions)





# as due to their complexity multi-gpu tests could impact other tests, and to aid debug we have those in a separate module.

import os
import sys

from transformers.testing_utils import TestCasePlus, execute_subprocess_async, get_gpu_count, require_torch_gpu, slow

from .utils import load_json







class      __lowercase  (__SCREAMING_SNAKE_CASE   ):





							"""simple docstring"""







							@classmethod
							def  UpperCamelCase__			(	cls    ):





										"""simple docstring"""




										return cls






							@slow
							@require_torch_gpu
							def  UpperCamelCase__			(	self    ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_						:			List[str]       						= self.get_auto_remove_tmp_dir()
										SCREAMING_SNAKE_CASE_						:			Tuple       						= F'''
            --model_name Helsinki-NLP/opus-mt-en-ro
            --save_dir {output_dir}
            --data_dir {self.test_file_dir_str}/test_data/wmt_en_ro
            --num_beams 2
            --task translation
        '''.split()

										# we want this test to run even if there is only one GPU, but if there are more we use them all
										SCREAMING_SNAKE_CASE_						:			Dict       						= get_gpu_count()
										SCREAMING_SNAKE_CASE_						:			int       						= F'''
            -m torch.distributed.launch
            --nproc_per_node={n_gpu}
            {self.test_file_dir}/run_distributed_eval.py
        '''.split()
										SCREAMING_SNAKE_CASE_						:			Optional[Any]       						= [sys.executable] + distributed_args + args
										execute_subprocess_async(lowerCAmelCase__       ,		env=self.get_env()    )

										SCREAMING_SNAKE_CASE_						:			List[str]       						= os.path.join(lowerCAmelCase__       ,		'test_bleu.json'    )
										SCREAMING_SNAKE_CASE_						:			Optional[int]       						= load_json(lowerCAmelCase__    )
										# print(metrics)
										self.assertGreaterEqual(metrics['bleu']       ,		2_5    )





