import inspect
import unittest

from transformers import RegNetConfig
from transformers.file_utils import cached_property, is_torch_available, is_vision_available
from transformers.testing_utils import require_torch, require_vision, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
     import torch
     from torch import nn

     from transformers import RegNetForImageClassification, RegNetModel
     from transformers.models.regnet.modeling_regnet import REGNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
     from PIL import Image

     from transformers import AutoImageProcessor



class  UpperCamelCase				:

     '''simple docstring'''

     def __init__(					self				,				A_				,				A_=3				,				A_=32				,				A_=3				,				A_=10				,				A_=[10, 20, 30, 40]				,				A_=[1, 1, 2, 1]				,				A_=True				,				A_=True				,				A_="relu"				,				A_=3				,				A_=None				,				) ->				Tuple:






           """simple docstring"""
           _lowerCamelCase			    =				parent
           _lowerCamelCase			    =				batch_size
           _lowerCamelCase			    =				image_size
           _lowerCamelCase			    =				num_channels
           _lowerCamelCase			    =				embeddings_size
           _lowerCamelCase			    =				hidden_sizes
           _lowerCamelCase			    =				depths
           _lowerCamelCase			    =				is_training
           _lowerCamelCase			    =				use_labels
           _lowerCamelCase			    =				hidden_act
           _lowerCamelCase			    =				num_labels
           _lowerCamelCase			    =				scope
           _lowerCamelCase			    =				len(__a						)



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






           """simple docstring"""
           _lowerCamelCase			    =				floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

           _lowerCamelCase			    =				None
           if self.use_labels:
                 _lowerCamelCase			    =				ids_tensor([self.batch_size]				,				self.num_labels						)

           _lowerCamelCase			    =				self.get_config()

           return config, pixel_values, labels



     def 		UpperCamelCase_						(					self						) ->				Optional[Any]:






           """simple docstring"""
           return RegNetConfig(
               num_channels=self.num_channels				,				embeddings_size=self.embeddings_size				,				hidden_sizes=self.hidden_sizes				,				depths=self.depths				,				hidden_act=self.hidden_act				,				num_labels=self.num_labels				,				)



     def 		UpperCamelCase_						(					self				,				A_				,				A_				,				A_						) ->				Optional[int]:






           """simple docstring"""
           _lowerCamelCase			    =				RegNetModel(config=__a						)
           model.to(__a						)
           model.eval()
           _lowerCamelCase			    =				model(__a						)
           # expected last hidden states: B, C, H // 32, W // 32
           self.parent.assertEqual(
               result.last_hidden_state.shape				,				(self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)				,				)



     def 		UpperCamelCase_						(					self				,				A_				,				A_				,				A_						) ->				List[Any]:






           """simple docstring"""
           _lowerCamelCase			    =				self.num_labels
           _lowerCamelCase			    =				RegNetForImageClassification(__a						)
           model.to(__a						)
           model.eval()
           _lowerCamelCase			    =				model(__a				,				labels=__a						)
           self.parent.assertEqual(result.logits.shape				,				(self.batch_size, self.num_labels)						)





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






           """simple docstring"""
           _lowerCamelCase			    =				self.prepare_config_and_inputs()
           _lowerCamelCase			    =				config_and_inputs
           _lowerCamelCase			    =				{'pixel_values': pixel_values}
           return config, inputs_dict





@require_torch
class  UpperCamelCase				( UpperCamelCase_   ,  UpperCamelCase_   ,  unittest.TestCase ):

     '''simple docstring'''

     A_										=  (RegNetModel, RegNetForImageClassification) if is_torch_available() else ()
     A_										=  (
         {'feature-extraction': RegNetModel, 'image-classification': RegNetForImageClassification}
         if is_torch_available()
         else {}
     )

     A_										=  False
     A_										=  False
     A_										=  False
     A_										=  False



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






           """simple docstring"""
           _lowerCamelCase			    =				RegNetModelTester(self						)
           _lowerCamelCase			    =				ConfigTester(self				,				config_class=__a				,				has_text_modality=__a						)



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






           """simple docstring"""
           self.create_and_test_config_common_properties()
           self.config_tester.create_and_test_config_to_json_string()
           self.config_tester.create_and_test_config_to_json_file()
           self.config_tester.create_and_test_config_from_and_save_pretrained()
           self.config_tester.create_and_test_config_with_num_labels()
           self.config_tester.check_config_can_be_init_without_params()
           self.config_tester.check_config_arguments_init()



     def 		UpperCamelCase_						(					self						) ->				Dict:






           """simple docstring"""
           return



     @unittest.skip(reason='''RegNet does not use inputs_embeds'''						)
     def 		UpperCamelCase_						(					self						) ->				str:






           """simple docstring"""
           pass



     @unittest.skip(reason='''RegNet does not support input and output embeddings'''						)
     def 		UpperCamelCase_						(					self						) ->				str:






           """simple docstring"""
           pass



     def 		UpperCamelCase_						(					self						) ->				int:






           """simple docstring"""
           _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 		UpperCamelCase_						(					self						) ->				List[str]:






           """simple docstring"""
           _lowerCamelCase			    =				self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*__a						)



     def 		UpperCamelCase_						(					self						) ->				Tuple:






           """simple docstring"""
           _lowerCamelCase			    =				self.model_tester.prepare_config_and_inputs_for_common()

           for model_class in self.all_model_classes:
                 _lowerCamelCase			    =				model_class(config=__a						)
                 for name, module in model.named_modules():
                       if isinstance(__a				,				(nn.BatchNormad, nn.GroupNorm)						):
                             self.assertTrue(
                                 torch.all(module.weight == 1						)				,				msg=F'Parameter {name} of model {model_class} seems not properly initialized'				,				)
                             self.assertTrue(
                                 torch.all(module.bias == 0						)				,				msg=F'Parameter {name} of model {model_class} seems not properly initialized'				,				)



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






           """simple docstring"""






           def check_hidden_states_output(A_				,				A_				,				A_						):
                 _lowerCamelCase			    =				model_class(__a						)
                 model.to(__a						)
                 model.eval()

                 with torch.no_grad():
                       _lowerCamelCase			    =				model(**self._prepare_for_class(__a				,				__a						)						)

                 _lowerCamelCase			    =				outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

                 _lowerCamelCase			    =				self.model_tester.num_stages
                 self.assertEqual(len(__a						)				,				expected_num_stages + 1						)

                 # RegNet's feature maps are of shape (batch_size, num_channels, height, width)
                 self.assertListEqual(
                     list(hidden_states[0].shape[-2:]						)				,				[self.model_tester.image_size // 2, self.model_tester.image_size // 2]				,				)

           _lowerCamelCase			    =				self.model_tester.prepare_config_and_inputs_for_common()
           _lowerCamelCase			    =				['basic', 'bottleneck']
           for model_class in self.all_model_classes:
                 for layer_type in layers_type:
                       _lowerCamelCase			    =				layer_type
                       _lowerCamelCase			    =				True
                       check_hidden_states_output(__a				,				__a				,				__a						)

                       # check that output_hidden_states also work using config
                       del inputs_dict["output_hidden_states"]
                       _lowerCamelCase			    =				True

                       check_hidden_states_output(__a				,				__a				,				__a						)



     def 		UpperCamelCase_						(					self						) ->				Union[str, Any]:






           """simple docstring"""
           _lowerCamelCase			    =				self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_image_classification(*__a						)





     @slow
     def 		UpperCamelCase_						(					self						) ->				int:






           """simple docstring"""






           for model_name in REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 _lowerCamelCase			    =				RegNetModel.from_pretrained(__a						)
                 self.assertIsNotNone(__a						)





def       __magic_name__(  )						->    str:



      '''simple docstring'''

      _lowerCamelCase			    =				Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''		)
      return image




@require_torch
@require_vision
class  UpperCamelCase				( unittest.TestCase ):

     '''simple docstring'''

     @cached_property
     def 		UpperCamelCase_						(					self						) ->				Optional[Any]:






           """simple docstring"""
           return (
               AutoImageProcessor.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]						)
               if is_vision_available()
               else None
           )





     @slow
     def 		UpperCamelCase_						(					self						) ->				Union[str, Any]:






           """simple docstring"""
           _lowerCamelCase			    =				RegNetForImageClassification.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]						).to(__a						)

           _lowerCamelCase			    =				self.default_image_processor
           _lowerCamelCase			    =				prepare_img()
           _lowerCamelCase			    =				image_processor(images=__a				,				return_tensors='''pt'''						).to(__a						)

           # forward pass
           with torch.no_grad():
                 _lowerCamelCase			    =				model(**__a						)

           # verify the logits
           _lowerCamelCase			    =				torch.Size((1, 10_00)						)
           self.assertEqual(outputs.logits.shape				,				__a						)

           _lowerCamelCase			    =				torch.tensor([-0.4180, -1.5051, -3.4836]						).to(__a						)

           self.assertTrue(torch.allclose(outputs.logits[0, :3]				,				__a				,				atol=1E-4						)						)
import os
import tempfile
import unittest

from transformers.models.marian.convert_marian_tatoeba_to_pytorch import DEFAULT_REPO, TatoebaConverter
from transformers.testing_utils import slow
from transformers.utils import cached_property



@unittest.skipUnless(os.path.exists(__lowercase )   ,  'Tatoeba directory does not exist.' )
class  UpperCamelCase				( unittest.TestCase ):

     '''simple docstring'''

     @cached_property
     def 		UpperCamelCase_						(					self						) ->				int:






           """simple docstring"""
           _lowerCamelCase			    =				tempfile.mkdtemp()
           return TatoebaConverter(save_dir=A_						)



     @slow
     def 		UpperCamelCase_						(					self						) ->				Any:






           """simple docstring"""
           self.resolver.convert_models(['''heb-eng''']						)





     @slow
     def 		UpperCamelCase_						(					self						) ->				Tuple:






           """simple docstring"""
           _lowerCamelCase    ,					_lowerCamelCase			    =				self.resolver.write_model_card('''opus-mt-he-en'''				,				dry_run=A_						)
           assert mmeta["long_pair"] == "heb-eng"