
'''simple docstring'''





import inspect
import unittest

from transformers import EfficientNetConfig
from transformers.testing_utils import is_pipeline_test, require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

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 transformers import EfficientNetForImageClassification, EfficientNetModel
 from transformers.models.efficientnet.modeling_efficientnet import EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
 from PIL import Image

 from transformers import AutoImageProcessor


class 			UpperCamelCase__	:






 def __init__(      self	:List[str]						,					_A	:List[str]						,					_A	:Any=13						,					_A	:List[Any]=32						,					_A	:str=3						,					_A	:Optional[int]=[3, 3, 5]						,					_A	:Tuple=[32, 16, 24]						,					_A	:Tuple=[16, 24, 40]						,					_A	:Dict=[1, 1, 2]						,					_A	:Any=[1, 1, 2]						,					_A	:Optional[int]=[1, 6, 6]						,					_A	:Dict=True						,					_A	:Any=True						,					_A	:str=37						,					_A	:List[str]="gelu"						,					_A	:Optional[int]=10						,					)					->      str:







       '''simple docstring'''



       __A													=      parent
       __A													=      batch_size
       __A													=      image_size
       __A													=      num_channels
       __A													=      kernel_sizes
       __A													=      in_channels
       __A													=      out_channels
       __A													=      strides
       __A													=      num_block_repeats
       __A													=      expand_ratios
       __A													=      is_training
       __A													=      hidden_act
       __A													=      num_labels
       __A													=      use_labels






 def 						lowercase_    (      self	:str      )					->      Dict:







       '''simple docstring'''



       __A													=      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )

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

       __A													=      self.get_config()
       return config, pixel_values, labels






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







       '''simple docstring'''



       return EfficientNetConfig(
           num_channels=self.num_channels						,					kernel_sizes=self.kernel_sizes						,					in_channels=self.in_channels						,					out_channels=self.out_channels						,					strides=self.strides						,					num_block_repeats=self.num_block_repeats						,					expand_ratios=self.expand_ratios						,					hidden_act=self.hidden_act						,					num_labels=self.num_labels						,					)






 def 						lowercase_    (      self	:int						,					_A	:Union[str, Any]						,					_A	:List[str]						,					_A	:Union[str, Any]      )					->      Optional[Any]:







       '''simple docstring'''



       __A													=      EfficientNetModel(config=_A      )
       model.to(_A      )
       model.eval()
       __A													=      model(_A      )
       # expected last hidden states: B, C, H // 4, W // 4
       self.parent.assertEqual(
           result.last_hidden_state.shape						,					(self.batch_size, config.hidden_dim, self.image_size // 4, self.image_size // 4)						,					)






 def 						lowercase_    (      self	:Tuple						,					_A	:List[Any]						,					_A	:Union[str, Any]						,					_A	:Union[str, Any]      )					->      Any:







       '''simple docstring'''



       __A													=      EfficientNetForImageClassification(_A      )
       model.to(_A      )
       model.eval()
       __A													=      model(_A						,					labels=_A      )
       self.parent.assertEqual(result.logits.shape						,					(self.batch_size, self.num_labels)      )






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







       '''simple docstring'''



       __A													=      self.prepare_config_and_inputs()
       __A						,   __A						,   __A													=      config_and_inputs
       __A													=      {'pixel_values': pixel_values}
       return config, inputs_dict


@require_torch
class 			UpperCamelCase__	(     SCREAMING_SNAKE_CASE   ,  SCREAMING_SNAKE_CASE   ,  unittest.TestCase):
 UpperCAmelCase__     :     Optional[Any]    					=       (EfficientNetModel, EfficientNetForImageClassification) if is_torch_available() else ()
 UpperCAmelCase__     :     Optional[int]    					=       (
     {'feature-extraction': EfficientNetModel, 'image-classification': EfficientNetForImageClassification}
     if is_torch_available()
     else {}
 )

 UpperCAmelCase__     :     Tuple    					=       False
 UpperCAmelCase__     :     Optional[int]    					=       False
 UpperCAmelCase__     :     str    					=       False
 UpperCAmelCase__     :     List[Any]    					=       False
 UpperCAmelCase__     :     Any    					=       False






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







       '''simple docstring'''



       __A													=      EfficientNetModelTester(self      )
       __A													=      ConfigTester(
           self						,					config_class=_A						,					has_text_modality=_A						,					hidden_size=37      )






 def 						lowercase_    (      self	:Optional[int]      )					->      Dict:







       '''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 						lowercase_    (      self	:Optional[Any]      )					->      List[str]:







       '''simple docstring'''



       return






 @unittest.skip(reason='EfficientNet does not use inputs_embeds'      )
 def 						lowercase_    (      self	:List[str]      )					->      Union[str, Any]:







       '''simple docstring'''



       pass






 @unittest.skip(reason='EfficientNet does not support input and output embeddings'      )
 def 						lowercase_    (      self	:Any      )					->      List[str]:







       '''simple docstring'''



       pass






 @unittest.skip(reason='EfficientNet does not use feedforward chunking'      )
 def 						lowercase_    (      self	:Union[str, Any]      )					->      Union[str, Any]:







       '''simple docstring'''



       pass






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







       '''simple docstring'''



       __A						,   __A													=      self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
             __A													=      model_class(_A      )
             __A													=      inspect.signature(model.forward      )
             # signature.parameters is an OrderedDict => so arg_names order is deterministic
             __A													=      [*signature.parameters.keys()]

             __A													=      ['pixel_values']
             self.assertListEqual(arg_names[:1]						,					_A      )






 def 						lowercase_    (      self	:List[Any]      )					->      Optional[Any]:







       '''simple docstring'''



       __A													=      self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*_A      )






 def 						lowercase_    (      self	:Optional[Any]      )					->      List[Any]:







       '''simple docstring'''



       def check_hidden_states_output(_A	:str						,					_A	:Union[str, Any]						,					_A	:Union[str, Any]      ):
             __A													=      model_class(_A      )
             model.to(_A      )
             model.eval()

             with torch.no_grad():
                   __A													=      model(**self._prepare_for_class(_A						,					_A      )      )

             __A													=      outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states
             __A													=      sum(config.num_block_repeats      ) * 4
             self.assertEqual(len(_A      )						,					_A      )

             # EfficientNet'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]						,					)

       __A						,   __A													=      self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
             __A													=      True
             check_hidden_states_output(_A						,					_A						,					_A      )

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

             check_hidden_states_output(_A						,					_A						,					_A      )






 def 						lowercase_    (      self	:List[Any]      )					->      Tuple:







       '''simple docstring'''



       __A													=      self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*_A      )






 @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'      )
 def 						lowercase_    (      self	:Optional[Any]      )					->      str:







       '''simple docstring'''



       pass






 @slow
 def 						lowercase_    (      self	:List[str]      )					->      Optional[int]:







       '''simple docstring'''



       for model_name in EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             __A													=      EfficientNetModel.from_pretrained(_A      )
             self.assertIsNotNone(_A      )






 @is_pipeline_test
 @require_vision
 @slow
 def 						lowercase_    (      self	:List[Any]      )					->      Any:







       '''simple docstring'''



       super().test_pipeline_image_classification()





def 							snake_case				(		)->      List[Any]:







      """simple docstring"""
      __A													=      Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'						)
      return image


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






 @cached_property
 def 						lowercase_    (      self	:Dict      )					->      Dict:







       '''simple docstring'''



       return AutoImageProcessor.from_pretrained('google/efficientnet-b7'      ) if is_vision_available() else None






 @slow
 def 						lowercase_    (      self	:Tuple      )					->      int:







       '''simple docstring'''



       __A													=      EfficientNetForImageClassification.from_pretrained('google/efficientnet-b7'      ).to(_A      )

       __A													=      self.default_image_processor
       __A													=      prepare_img()
       __A													=      image_processor(images=_A						,					return_tensors='pt'      ).to(_A      )

       # forward pass
       with torch.no_grad():
             __A													=      model(**_A      )

       # verify the logits
       __A													=      torch.Size((1, 1_000)      )
       self.assertEqual(outputs.logits.shape						,					_A      )

       __A													=      torch.tensor([0.0_001, 0.0_002, 0.0_002]      ).to(_A      )
       self.assertTrue(torch.allclose(outputs.logits[0, :3]						,					_A						,					atol=1E-4      )      )








'''simple docstring'''





class 			UpperCamelCase__	:






 def __init__(      self	:Optional[Any]						,					_A	:Tuple      )					->      Tuple:







       '''simple docstring'''



       __A													=      data
       __A													=      None
       __A													=      None






 def __str__(      self	:List[str]      )					->      Optional[int]:







       '''simple docstring'''



       return F'{self.data}'


class 			UpperCamelCase__	:






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







       '''simple docstring'''



       __A													=      None
       __A													=      None






 def __iter__(      self	:Optional[int]      )					->      List[Any]:







       '''simple docstring'''



       __A													=      self.head
       while node:
             yield node.data
             __A													=      node.next






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







       '''simple docstring'''



       return "->".join([str(_A      ) for item in self]      )






 def __len__(      self	:int      )					->      List[str]:







       '''simple docstring'''



       return sum(1 for _ in self      )






 def 						lowercase_    (      self	:List[str]						,					_A	:Any      )					->      str:







       '''simple docstring'''



       self.insert_at_nth(0						,					_A      )






 def 						lowercase_    (      self	:Dict						,					_A	:Optional[Any]      )					->      Tuple:







       '''simple docstring'''



       self.insert_at_nth(len(self      )						,					_A      )






 def 						lowercase_    (      self	:Optional[int]						,					_A	:int						,					_A	:Optional[int]      )					->      int:







       '''simple docstring'''



       __A													=      len(self      )

       if not 0 <= index <= length:
             raise IndexError('list index out of range'      )
       __A													=      Node(_A      )
       if self.head is None:
             __A													=      __A													=      new_node
       elif index == 0:
             __A													=      new_node
             __A													=      self.head
             __A													=      new_node
       elif index == length:
             __A													=      new_node
             __A													=      self.tail
             __A													=      new_node
       else:
             __A													=      self.head
             for _ in range(0						,					_A      ):
                   __A													=      temp.next
             __A													=      new_node
             __A													=      temp.previous
             __A													=      temp
             __A													=      new_node






 def 						lowercase_    (      self	:Optional[int]      )					->      List[str]:







       '''simple docstring'''



       return self.delete_at_nth(0      )






 def 						lowercase_    (      self	:Any      )					->      Tuple:







       '''simple docstring'''



       return self.delete_at_nth(len(self      ) - 1      )






 def 						lowercase_    (      self	:Dict						,					_A	:int      )					->      List[str]:







       '''simple docstring'''



       __A													=      len(self      )

       if not 0 <= index <= length - 1:
             raise IndexError('list index out of range'      )
       __A													=      self.head  # default first node
       if length == 1:
             __A													=      __A													=      None
       elif index == 0:
             __A													=      self.head.next
             __A													=      None
       elif index == length - 1:
             __A													=      self.tail
             __A													=      self.tail.previous
             __A													=      None
       else:
             __A													=      self.head
             for _ in range(0						,					_A      ):
                   __A													=      temp.next
             __A													=      temp
             __A													=      temp.previous
             __A													=      temp.next
       return delete_node.data






 def 						lowercase_    (      self	:List[str]						,					_A	:Dict      )					->      str:







       '''simple docstring'''



       __A													=      self.head

       while current.data != data:  # Find the position to delete
             if current.next:
                   __A													=      current.next
             else:  # We have reached the end an no value matches
                   raise ValueError('No data matching given value'      )

       if current == self.head:
             self.delete_head()

       elif current == self.tail:
             self.delete_tail()

       else:  # Before: 1 <--> 2(current) <--> 3
             __A													=      current.next  # 1 --> 3
             __A													=      current.previous  # 1 <--> 3
       return data






 def 						lowercase_    (      self	:List[str]      )					->      Tuple:







       '''simple docstring'''



       return len(self      ) == 0





def 							snake_case				(		)->      None:







      """simple docstring"""
      __A													=      DoublyLinkedList()
      assert linked_list.is_empty() is True
      assert str(UpperCAmelCase						) == ""

      try:
            linked_list.delete_head()
            raise AssertionError  # This should not happen.
      except IndexError:
            assert True  # This should happen.

      try:
            linked_list.delete_tail()
            raise AssertionError  # This should not happen.
      except IndexError:
            assert True  # This should happen.

      for i in range(1_0						):
            assert len(UpperCAmelCase						) == i
            linked_list.insert_at_nth(UpperCAmelCase   ,	i + 1						)
      assert str(UpperCAmelCase						) == "->".join(str(UpperCAmelCase						) for i in range(1   ,	1_1						)						)

      linked_list.insert_at_head(0						)
      linked_list.insert_at_tail(1_1						)
      assert str(UpperCAmelCase						) == "->".join(str(UpperCAmelCase						) for i in range(0   ,	1_2						)						)

      assert linked_list.delete_head() == 0
      assert linked_list.delete_at_nth(9						) == 1_0
      assert linked_list.delete_tail() == 1_1
      assert len(UpperCAmelCase						) == 9
      assert str(UpperCAmelCase						) == "->".join(str(UpperCAmelCase						) for i in range(1   ,	1_0						)						)


if __name__ == "__main__":
 from doctest import testmod

 testmod()






