



'''simple docstring'''


import os
import unittest

from transformers import ElectraTokenizerFast
from transformers.models.electra.tokenization_electra import (
    VOCAB_FILES_NAMES,
    BasicTokenizer,
    ElectraTokenizer,
    WordpieceTokenizer,
    _is_control,
    _is_punctuation,
    _is_whitespace,
)
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english






@require_tokenizers
class 	lowerCAmelCase_  (					UpperCAmelCase_					,				unittest.TestCase       ):







  '''simple docstring'''

  UpperCamelCase_ :			Union[str, Any]        =							ElectraTokenizer
  UpperCamelCase_ :			Tuple        =							ElectraTokenizerFast
  UpperCamelCase_ :			int        =							True
  UpperCamelCase_ :			List[str]        =							True
  UpperCamelCase_ :			Optional[int]        =							filter_non_english



  def 				_snake_case    (   self							:       int  ) ->		str:







       '''simple docstring'''



       super().setUp()

       A:		Union[str, Any]        =		[
           '''[UNK]''',
           '''[CLS]''',
           '''[SEP]''',
           '''[PAD]''',
           '''[MASK]''',
           '''want''',
           '''##want''',
           '''##ed''',
           '''wa''',
           '''un''',
           '''runn''',
           '''##ing''',
           ''',''',
           '''low''',
           '''lowest''',
       ]
       A:		Optional[Any]        =		os.path.join(self.tmpdirname				,     VOCAB_FILES_NAMES['''vocab_file''']  )
       with open(self.vocab_file				,     '''w'''				,     encoding='''utf-8'''  ) as vocab_writer:
            vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens]  )  )



  def 				_snake_case    (   self							:       Optional[Any]				,     SCREAMING_SNAKE_CASE_							:       str  ) ->		Union[str, Any]:







       '''simple docstring'''



       A:		Tuple        =		'''UNwant\u00E9d,running'''
       A:		Optional[Any]        =		'''unwanted, running'''
       return input_text, output_text



  def 				_snake_case    (   self							:       Optional[Any]  ) ->		Tuple:







       '''simple docstring'''



       A:		List[str]        =		self.tokenizer_class(self.vocab_file  )

       A:		List[str]        =		tokenizer.tokenize('''UNwant\u00E9d,running'''  )
       self.assertListEqual(SCREAMING_SNAKE_CASE_				,     ['''un''', '''##want''', '''##ed''', ''',''', '''runn''', '''##ing''']  )
       self.assertListEqual(tokenizer.convert_tokens_to_ids(SCREAMING_SNAKE_CASE_  )				,     [9, 6, 7, 12, 10, 11]  )



  def 				_snake_case    (   self							:       Optional[Any]  ) ->		str:







       '''simple docstring'''



       if not self.test_rust_tokenizer:
            return

       A:		str        =		self.get_tokenizer()
       A:		Union[str, Any]        =		self.get_rust_tokenizer()

       A:		Dict        =		'''UNwant\u00E9d,running'''

       A:		Optional[int]        =		tokenizer.tokenize(SCREAMING_SNAKE_CASE_  )
       A:		List[str]        =		rust_tokenizer.tokenize(SCREAMING_SNAKE_CASE_  )
       self.assertListEqual(SCREAMING_SNAKE_CASE_				,     SCREAMING_SNAKE_CASE_  )

       A:		Any        =		tokenizer.encode(SCREAMING_SNAKE_CASE_				,     add_special_tokens=SCREAMING_SNAKE_CASE_  )
       A:		Tuple        =		rust_tokenizer.encode(SCREAMING_SNAKE_CASE_				,     add_special_tokens=SCREAMING_SNAKE_CASE_  )
       self.assertListEqual(SCREAMING_SNAKE_CASE_				,     SCREAMING_SNAKE_CASE_  )

       A:		List[Any]        =		self.get_rust_tokenizer()
       A:		Dict        =		tokenizer.encode(SCREAMING_SNAKE_CASE_  )
       A:		Dict        =		rust_tokenizer.encode(SCREAMING_SNAKE_CASE_  )
       self.assertListEqual(SCREAMING_SNAKE_CASE_				,     SCREAMING_SNAKE_CASE_  )

       # With lower casing
       A:		Tuple        =		self.get_tokenizer(do_lower_case=SCREAMING_SNAKE_CASE_  )
       A:		List[Any]        =		self.get_rust_tokenizer(do_lower_case=SCREAMING_SNAKE_CASE_  )

       A:		Union[str, Any]        =		'''UNwant\u00E9d,running'''

       A:		List[Any]        =		tokenizer.tokenize(SCREAMING_SNAKE_CASE_  )
       A:		Any        =		rust_tokenizer.tokenize(SCREAMING_SNAKE_CASE_  )
       self.assertListEqual(SCREAMING_SNAKE_CASE_				,     SCREAMING_SNAKE_CASE_  )

       A:		Union[str, Any]        =		tokenizer.encode(SCREAMING_SNAKE_CASE_				,     add_special_tokens=SCREAMING_SNAKE_CASE_  )
       A:		List[Any]        =		rust_tokenizer.encode(SCREAMING_SNAKE_CASE_				,     add_special_tokens=SCREAMING_SNAKE_CASE_  )
       self.assertListEqual(SCREAMING_SNAKE_CASE_				,     SCREAMING_SNAKE_CASE_  )

       A:		Optional[int]        =		self.get_rust_tokenizer()
       A:		Optional[int]        =		tokenizer.encode(SCREAMING_SNAKE_CASE_  )
       A:		Dict        =		rust_tokenizer.encode(SCREAMING_SNAKE_CASE_  )
       self.assertListEqual(SCREAMING_SNAKE_CASE_				,     SCREAMING_SNAKE_CASE_  )



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







       '''simple docstring'''



       A:		List[Any]        =		BasicTokenizer()

       self.assertListEqual(tokenizer.tokenize('''ah\u535A\u63A8zz'''  )				,     ['''ah''', '''\u535A''', '''\u63A8''', '''zz''']  )



  def 				_snake_case    (   self							:       Dict  ) ->		List[Any]:







       '''simple docstring'''



       A:		Tuple        =		BasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_  )

       self.assertListEqual(
           tokenizer.tokenize(''' \tHeLLo!how  \n Are yoU?  '''  )				,     ['''hello''', '''!''', '''how''', '''are''', '''you''', '''?''']  )
       self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''  )				,     ['''hello''']  )



  def 				_snake_case    (   self							:       int  ) ->		int:







       '''simple docstring'''



       A:		Tuple        =		BasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_				,     strip_accents=SCREAMING_SNAKE_CASE_  )

       self.assertListEqual(
           tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''  )				,     ['''hällo''', '''!''', '''how''', '''are''', '''you''', '''?''']  )
       self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''  )				,     ['''h\u00E9llo''']  )



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







       '''simple docstring'''



       A:		Dict        =		BasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_				,     strip_accents=SCREAMING_SNAKE_CASE_  )

       self.assertListEqual(
           tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''  )				,     ['''hallo''', '''!''', '''how''', '''are''', '''you''', '''?''']  )
       self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''  )				,     ['''hello''']  )



  def 				_snake_case    (   self							:       int  ) ->		Any:







       '''simple docstring'''



       A:		int        =		BasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_  )

       self.assertListEqual(
           tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''  )				,     ['''hallo''', '''!''', '''how''', '''are''', '''you''', '''?''']  )
       self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''  )				,     ['''hello''']  )



  def 				_snake_case    (   self							:       Optional[int]  ) ->		Union[str, Any]:







       '''simple docstring'''



       A:		List[str]        =		BasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_  )

       self.assertListEqual(
           tokenizer.tokenize(''' \tHeLLo!how  \n Are yoU?  '''  )				,     ['''HeLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''']  )



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







       '''simple docstring'''



       A:		Any        =		BasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_				,     strip_accents=SCREAMING_SNAKE_CASE_  )

       self.assertListEqual(
           tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''  )				,     ['''HäLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''']  )



  def 				_snake_case    (   self							:       str  ) ->		Optional[Any]:







       '''simple docstring'''



       A:		Dict        =		BasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_				,     strip_accents=SCREAMING_SNAKE_CASE_  )

       self.assertListEqual(
           tokenizer.tokenize(''' \tHäLLo!how  \n Are yoU?  '''  )				,     ['''HaLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''']  )



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







       '''simple docstring'''



       A:		Dict        =		BasicTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_				,     never_split=['''[UNK]''']  )

       self.assertListEqual(
           tokenizer.tokenize(''' \tHeLLo!how  \n Are yoU? [UNK]'''  )				,     ['''HeLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''', '''[UNK]''']  )



  def 				_snake_case    (   self							:       Dict  ) ->		int:







       '''simple docstring'''



       A:		Dict        =		['''[UNK]''', '''[CLS]''', '''[SEP]''', '''want''', '''##want''', '''##ed''', '''wa''', '''un''', '''runn''', '''##ing''']

       A:		Tuple        =		{}
       for i, token in enumerate(SCREAMING_SNAKE_CASE_  ):
            A:		str        =		i
       A:		Optional[Any]        =		WordpieceTokenizer(vocab=SCREAMING_SNAKE_CASE_				,     unk_token='''[UNK]'''  )

       self.assertListEqual(tokenizer.tokenize(''''''  )				,     []  )

       self.assertListEqual(tokenizer.tokenize('''unwanted running'''  )				,     ['''un''', '''##want''', '''##ed''', '''runn''', '''##ing''']  )

       self.assertListEqual(tokenizer.tokenize('''unwantedX running'''  )				,     ['''[UNK]''', '''runn''', '''##ing''']  )



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







       '''simple docstring'''



       self.assertTrue(_is_whitespace(''' '''  )  )
       self.assertTrue(_is_whitespace('''\t'''  )  )
       self.assertTrue(_is_whitespace('''\r'''  )  )
       self.assertTrue(_is_whitespace('''\n'''  )  )
       self.assertTrue(_is_whitespace('''\u00A0'''  )  )

       self.assertFalse(_is_whitespace('''A'''  )  )
       self.assertFalse(_is_whitespace('''-'''  )  )



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







       '''simple docstring'''



       self.assertTrue(_is_control('''\u0005'''  )  )

       self.assertFalse(_is_control('''A'''  )  )
       self.assertFalse(_is_control(''' '''  )  )
       self.assertFalse(_is_control('''\t'''  )  )
       self.assertFalse(_is_control('''\r'''  )  )



  def 				_snake_case    (   self							:       int  ) ->		Any:







       '''simple docstring'''



       self.assertTrue(_is_punctuation('''-'''  )  )
       self.assertTrue(_is_punctuation('''$'''  )  )
       self.assertTrue(_is_punctuation('''`'''  )  )
       self.assertTrue(_is_punctuation('''.'''  )  )

       self.assertFalse(_is_punctuation('''A'''  )  )
       self.assertFalse(_is_punctuation(''' '''  )  )



  def 				_snake_case    (   self							:       str  ) ->		int:







       '''simple docstring'''



       A:		Dict        =		self.get_tokenizer()
       A:		Dict        =		self.get_rust_tokenizer()

       # Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
       self.assertListEqual([tokenizer.tokenize(SCREAMING_SNAKE_CASE_  ) for t in ['''Test''', '''\xad''', '''test''']]				,     [['''[UNK]'''], [], ['''[UNK]''']]  )

       self.assertListEqual(
           [rust_tokenizer.tokenize(SCREAMING_SNAKE_CASE_  ) for t in ['''Test''', '''\xad''', '''test''']]				,     [['''[UNK]'''], [], ['''[UNK]''']]  )



  @slow
  def 				_snake_case    (   self							:       Any  ) ->		Optional[int]:







       '''simple docstring'''



       A:		str        =		self.tokenizer_class.from_pretrained('''google/electra-base-discriminator'''  )

       A:		Dict        =		tokenizer.encode('''sequence builders'''				,     add_special_tokens=SCREAMING_SNAKE_CASE_  )
       A:		Dict        =		tokenizer.encode('''multi-sequence build'''				,     add_special_tokens=SCREAMING_SNAKE_CASE_  )

       A:		Optional[int]        =		tokenizer.build_inputs_with_special_tokens(SCREAMING_SNAKE_CASE_  )
       A:		Optional[int]        =		tokenizer.build_inputs_with_special_tokens(SCREAMING_SNAKE_CASE_				,     SCREAMING_SNAKE_CASE_  )

       assert encoded_sentence == [1_01] + text + [1_02]
       assert encoded_pair == [1_01] + text + [1_02] + text_a + [1_02]



  def 				_snake_case    (   self							:       Dict  ) ->		Any:







       '''simple docstring'''



       for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
            with self.subTest(f"""{tokenizer.__class__.__name__} ({pretrained_name})"""  ):
                 A:		Dict        =		self.rust_tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE_				,     **SCREAMING_SNAKE_CASE_  )

                 A:		Tuple        =		f"""A, naïve {tokenizer_r.mask_token} AllenNLP sentence."""
                 A:		Tuple        =		tokenizer_r.encode_plus(
                     SCREAMING_SNAKE_CASE_				,     return_attention_mask=SCREAMING_SNAKE_CASE_				,     return_token_type_ids=SCREAMING_SNAKE_CASE_				,     return_offsets_mapping=SCREAMING_SNAKE_CASE_				,     add_special_tokens=SCREAMING_SNAKE_CASE_				,     )

                 A:		int        =		tokenizer_r.do_lower_case if hasattr(SCREAMING_SNAKE_CASE_				,     '''do_lower_case'''  ) else False
                 A:		Any        =		(
                     [
                         ((0, 0), tokenizer_r.cls_token),
                         ((0, 1), '''A'''),
                         ((1, 2), ''','''),
                         ((3, 5), '''na'''),
                         ((5, 6), '''##ï'''),
                         ((6, 8), '''##ve'''),
                         ((9, 15), tokenizer_r.mask_token),
                         ((16, 21), '''Allen'''),
                         ((21, 23), '''##NL'''),
                         ((23, 24), '''##P'''),
                         ((25, 33), '''sentence'''),
                         ((33, 34), '''.'''),
                         ((0, 0), tokenizer_r.sep_token),
                     ]
                     if not do_lower_case
                     else [
                         ((0, 0), tokenizer_r.cls_token),
                         ((0, 1), '''a'''),
                         ((1, 2), ''','''),
                         ((3, 8), '''naive'''),
                         ((9, 15), tokenizer_r.mask_token),
                         ((16, 21), '''allen'''),
                         ((21, 23), '''##nl'''),
                         ((23, 24), '''##p'''),
                         ((25, 33), '''sentence'''),
                         ((33, 34), '''.'''),
                         ((0, 0), tokenizer_r.sep_token),
                     ]
                 )

                 self.assertEqual(
                     [e[1] for e in expected_results]				,     tokenizer_r.convert_ids_to_tokens(tokens['''input_ids''']  )  )
                 self.assertEqual([e[0] for e in expected_results]				,     tokens['''offset_mapping''']  )




  def 				_snake_case    (   self							:       str  ) ->		Optional[Any]:







       '''simple docstring'''



       A:		Optional[Any]        =		['''的''', '''人''', '''有''']
       A:		Any        =		''''''.join(SCREAMING_SNAKE_CASE_  )
       for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
            with self.subTest(f"""{tokenizer.__class__.__name__} ({pretrained_name})"""  ):
                 A:		Dict        =		True
                 A:		Tuple        =		self.tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE_				,     **SCREAMING_SNAKE_CASE_  )
                 A:		List[Any]        =		self.rust_tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE_				,     **SCREAMING_SNAKE_CASE_  )

                 A:		List[str]        =		tokenizer_p.encode(SCREAMING_SNAKE_CASE_				,     add_special_tokens=SCREAMING_SNAKE_CASE_  )
                 A:		Dict        =		tokenizer_r.encode(SCREAMING_SNAKE_CASE_				,     add_special_tokens=SCREAMING_SNAKE_CASE_  )

                 A:		str        =		tokenizer_r.convert_ids_to_tokens(SCREAMING_SNAKE_CASE_  )
                 A:		List[Any]        =		tokenizer_p.convert_ids_to_tokens(SCREAMING_SNAKE_CASE_  )

                 # it is expected that each Chinese character is not preceded by "##"
                 self.assertListEqual(SCREAMING_SNAKE_CASE_				,     SCREAMING_SNAKE_CASE_  )
                 self.assertListEqual(SCREAMING_SNAKE_CASE_				,     SCREAMING_SNAKE_CASE_  )

                 A:		List[str]        =		False
                 A:		Tuple        =		self.rust_tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE_				,     **SCREAMING_SNAKE_CASE_  )
                 A:		Optional[int]        =		self.tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE_				,     **SCREAMING_SNAKE_CASE_  )

                 A:		Tuple        =		tokenizer_r.encode(SCREAMING_SNAKE_CASE_				,     add_special_tokens=SCREAMING_SNAKE_CASE_  )
                 A:		Dict        =		tokenizer_p.encode(SCREAMING_SNAKE_CASE_				,     add_special_tokens=SCREAMING_SNAKE_CASE_  )

                 A:		str        =		tokenizer_r.convert_ids_to_tokens(SCREAMING_SNAKE_CASE_  )
                 A:		Union[str, Any]        =		tokenizer_p.convert_ids_to_tokens(SCREAMING_SNAKE_CASE_  )

                 # it is expected that only the first Chinese character is not preceded by "##".
                 A:		Any        =		[
                     f"""##{token}""" if idx != 0 else token for idx, token in enumerate(SCREAMING_SNAKE_CASE_  )
                 ]
                 self.assertListEqual(SCREAMING_SNAKE_CASE_				,     SCREAMING_SNAKE_CASE_  )
                 self.assertListEqual(SCREAMING_SNAKE_CASE_				,     SCREAMING_SNAKE_CASE_  )












'''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 	lowerCAmelCase_  :







  '''simple docstring'''

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







       '''simple docstring'''



       A:		Optional[Any]        =		parent
       A:		int        =		batch_size
       A:		List[str]        =		image_size
       A:		List[str]        =		num_channels
       A:		Any        =		kernel_sizes
       A:		Optional[int]        =		in_channels
       A:		Any        =		out_channels
       A:		Optional[Any]        =		strides
       A:		str        =		num_block_repeats
       A:		List[Any]        =		expand_ratios
       A:		List[Any]        =		is_training
       A:		Any        =		hidden_act
       A:		List[Any]        =		num_labels
       A:		Tuple        =		use_labels



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







       '''simple docstring'''



       A:		str        =		floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

       A:		Optional[int]        =		None
       if self.use_labels:
            A:		List[Any]        =		ids_tensor([self.batch_size]				,     self.num_labels  )

       A:		int        =		self.get_config()
       return config, pixel_values, labels



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







       '''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 				_snake_case    (   self							:       int				,     SCREAMING_SNAKE_CASE_							:       Any				,     SCREAMING_SNAKE_CASE_							:       List[Any]				,     SCREAMING_SNAKE_CASE_							:       List[str]  ) ->		Dict:







       '''simple docstring'''



       A:		int        =		EfficientNetModel(config=SCREAMING_SNAKE_CASE_  )
       model.to(SCREAMING_SNAKE_CASE_  )
       model.eval()
       A:		List[Any]        =		model(SCREAMING_SNAKE_CASE_  )
       # 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 				_snake_case    (   self							:       Union[str, Any]				,     SCREAMING_SNAKE_CASE_							:       str				,     SCREAMING_SNAKE_CASE_							:       List[str]				,     SCREAMING_SNAKE_CASE_							:       List[Any]  ) ->		Tuple:







       '''simple docstring'''



       A:		Optional[Any]        =		EfficientNetForImageClassification(SCREAMING_SNAKE_CASE_  )
       model.to(SCREAMING_SNAKE_CASE_  )
       model.eval()
       A:		Union[str, Any]        =		model(SCREAMING_SNAKE_CASE_				,     labels=SCREAMING_SNAKE_CASE_  )
       self.parent.assertEqual(result.logits.shape				,     (self.batch_size, self.num_labels)  )




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







       '''simple docstring'''



       A:		Any        =		self.prepare_config_and_inputs()
       A    ,						A    ,						A:		str        =		config_and_inputs
       A:		Optional[int]        =		{'''pixel_values''': pixel_values}
       return config, inputs_dict






@require_torch
class 	lowerCAmelCase_  (					UpperCAmelCase_					,				UpperCAmelCase_					,				unittest.TestCase       ):







  '''simple docstring'''

  UpperCamelCase_ :			Dict        =							(EfficientNetModel, EfficientNetForImageClassification) if is_torch_available() else ()
  UpperCamelCase_ :			Dict        =							(
      {"""feature-extraction""": EfficientNetModel, """image-classification""": EfficientNetForImageClassification}
      if is_torch_available()
      else {}
  )

  UpperCamelCase_ :			List[Any]        =							False
  UpperCamelCase_ :			Union[str, Any]        =							False
  UpperCamelCase_ :			Union[str, Any]        =							False
  UpperCamelCase_ :			List[Any]        =							False
  UpperCamelCase_ :			str        =							False



  def 				_snake_case    (   self							:       Any  ) ->		str:







       '''simple docstring'''



       A:		List[Any]        =		EfficientNetModelTester(self  )
       A:		List[Any]        =		ConfigTester(
           self				,     config_class=SCREAMING_SNAKE_CASE_				,     has_text_modality=SCREAMING_SNAKE_CASE_				,     hidden_size=37  )



  def 				_snake_case    (   self							:       Tuple  ) ->		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 				_snake_case    (   self							:       List[Any]  ) ->		str:







       '''simple docstring'''



       return



  @unittest.skip(reason='''EfficientNet does not use inputs_embeds'''  )
  def 				_snake_case    (   self							:       Tuple  ) ->		Any:







       '''simple docstring'''



       pass



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







       '''simple docstring'''



       pass



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







       '''simple docstring'''



       pass



  def 				_snake_case    (   self							:       str  ) ->		int:







       '''simple docstring'''



       A    ,						A:		List[Any]        =		self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
            A:		Optional[int]        =		model_class(SCREAMING_SNAKE_CASE_  )
            A:		Dict        =		inspect.signature(model.forward  )
            # signature.parameters is an OrderedDict => so arg_names order is deterministic
            A:		str        =		[*signature.parameters.keys()]

            A:		Any        =		['''pixel_values''']
            self.assertListEqual(arg_names[:1]				,     SCREAMING_SNAKE_CASE_  )



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







       '''simple docstring'''



       A:		Union[str, Any]        =		self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE_  )



  def 				_snake_case    (   self							:       Union[str, Any]  ) ->		Optional[int]:







       '''simple docstring'''



       def check_hidden_states_output(SCREAMING_SNAKE_CASE_							:       int				,     SCREAMING_SNAKE_CASE_							:       Any				,     SCREAMING_SNAKE_CASE_							:       int  ):
            A:		int        =		model_class(SCREAMING_SNAKE_CASE_  )
            model.to(SCREAMING_SNAKE_CASE_  )
            model.eval()

            with torch.no_grad():
                 A:		List[str]        =		model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_				,     SCREAMING_SNAKE_CASE_  )  )

            A:		Tuple        =		outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states
            A:		Optional[Any]        =		sum(config.num_block_repeats  ) * 4
            self.assertEqual(len(SCREAMING_SNAKE_CASE_  )				,     SCREAMING_SNAKE_CASE_  )

            # 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:		List[Any]        =		self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
            A:		Union[str, Any]        =		True
            check_hidden_states_output(SCREAMING_SNAKE_CASE_				,     SCREAMING_SNAKE_CASE_				,     SCREAMING_SNAKE_CASE_  )

            # check that output_hidden_states also work using config
            del inputs_dict["output_hidden_states"]
            A:		Optional[Any]        =		True

            check_hidden_states_output(SCREAMING_SNAKE_CASE_				,     SCREAMING_SNAKE_CASE_				,     SCREAMING_SNAKE_CASE_  )



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







       '''simple docstring'''



       A:		Dict        =		self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*SCREAMING_SNAKE_CASE_  )



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







       '''simple docstring'''



       pass



  @slow
  def 				_snake_case    (   self							:       Any  ) ->		int:







       '''simple docstring'''



       for model_name in EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
            A:		str        =		EfficientNetModel.from_pretrained(SCREAMING_SNAKE_CASE_  )
            self.assertIsNotNone(SCREAMING_SNAKE_CASE_  )




  @is_pipeline_test
  @require_vision
  @slow
  def 				_snake_case    (   self							:       int  ) ->		str:







       '''simple docstring'''



       super().test_pipeline_image_classification()






def 				SCREAMING_SNAKE_CASE(      ) ->   List[Any]:
     A:		Dict        =		Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''  )
     return image






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







  '''simple docstring'''

  @cached_property
  def 				_snake_case    (   self							:       Dict  ) ->		List[str]:







       '''simple docstring'''



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




  @slow
  def 				_snake_case    (   self							:       Optional[Any]  ) ->		Optional[int]:







       '''simple docstring'''



       A:		str        =		EfficientNetForImageClassification.from_pretrained('''google/efficientnet-b7'''  ).to(SCREAMING_SNAKE_CASE_  )

       A:		Optional[int]        =		self.default_image_processor
       A:		Tuple        =		prepare_img()
       A:		List[Any]        =		image_processor(images=SCREAMING_SNAKE_CASE_				,     return_tensors='''pt'''  ).to(SCREAMING_SNAKE_CASE_  )

       # forward pass
       with torch.no_grad():
            A:		List[str]        =		model(**SCREAMING_SNAKE_CASE_  )

       # verify the logits
       A:		List[str]        =		torch.Size((1, 10_00)  )
       self.assertEqual(outputs.logits.shape				,     SCREAMING_SNAKE_CASE_  )

       A:		Union[str, Any]        =		torch.tensor([0.0001, 0.0002, 0.0002]  ).to(SCREAMING_SNAKE_CASE_  )
       self.assertTrue(torch.allclose(outputs.logits[0, :3]				,     SCREAMING_SNAKE_CASE_				,     atol=1E-4  )  )






