code: 
  
  
  
  
  """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]			,				snake_case_		: int			,				snake_case_		: Dict=13			,				snake_case_		: Tuple=32			,				snake_case_		: Union[str, Any]=3			,				snake_case_		: List[str]=[3, 3, 5]			,				snake_case_		: Tuple=[32, 16, 24]			,				snake_case_		: Optional[Any]=[16, 24, 40]			,				snake_case_		: str=[1, 1, 2]			,				snake_case_		: Union[str, Any]=[1, 1, 2]			,				snake_case_		: str=[1, 6, 6]			,				snake_case_		: int=True			,				snake_case_		: str=True			,				snake_case_		: List[Any]=37			,				snake_case_		: List[str]="gelu"			,				snake_case_		: Tuple=10			,				)   ->							Union[str, Any]:
  
  
  
  
       '''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 							__magic_name__							(					self		: Dict   )   ->							Tuple:
  
  
  
  
       '''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 							__magic_name__							(					self		: Optional[int]   )   ->							List[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 							__magic_name__							(					self		: Optional[Any]			,				snake_case_		: List[Any]			,				snake_case_		: int			,				snake_case_		: Dict   )   ->							Optional[Any]:
  
  
  
  
       '''simple docstring'''
  
       A__ =       EfficientNetModel(config=snake_case_   )
       model.to(snake_case_   )
       model.eval()
       A__ =       model(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 							__magic_name__							(					self		: Optional[int]			,				snake_case_		: Tuple			,				snake_case_		: Tuple			,				snake_case_		: Optional[Any]   )   ->							List[str]:
  
  
  
  
       '''simple docstring'''
  
       A__ =       EfficientNetForImageClassification(snake_case_   )
       model.to(snake_case_   )
       model.eval()
       A__ =       model(snake_case_			,				labels=snake_case_   )
       self.parent.assertEqual(result.logits.shape			,				(self.batch_size, self.num_labels)   )
  
  
  
  
      def 							__magic_name__							(					self		: Union[str, Any]   )   ->							Optional[int]:
  
  
  
  
       '''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_						(		A_,     A_,     unittest.TestCase							):
      lowercase__		      =   (EfficientNetModel, EfficientNetForImageClassification) if is_torch_available() else ()
      lowercase__		      =   (
          {'''feature-extraction''': EfficientNetModel, '''image-classification''': EfficientNetForImageClassification}
          if is_torch_available()
          else {}
      )
  
      lowercase__		      =   False
      lowercase__		      =   False
      lowercase__		      =   False
      lowercase__		      =   False
      lowercase__		      =   False
  
  
  
  
      def 							__magic_name__							(					self		: str   )   ->							Any:
  
  
  
  
       '''simple docstring'''
  
       A__ =       EfficientNetModelTester(self   )
       A__ =       ConfigTester(
           self			,				config_class=snake_case_			,				has_text_modality=snake_case_			,				hidden_size=37   )
  
  
  
  
      def 							__magic_name__							(					self		: int   )   ->							Any:
  
  
  
  
       '''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 							__magic_name__							(					self		: Union[str, Any]   )   ->							Tuple:
  
  
  
  
       '''simple docstring'''
  
       return
  
  
  
  
      @unittest.skip(reason="EfficientNet does not use inputs_embeds"   )
      def 							__magic_name__							(					self		: List[Any]   )   ->							Tuple:
  
  
  
  
       '''simple docstring'''
  
       pass
  
  
  
  
      @unittest.skip(reason="EfficientNet does not support input and output embeddings"   )
      def 							__magic_name__							(					self		: List[Any]   )   ->							List[str]:
  
  
  
  
       '''simple docstring'''
  
       pass
  
  
  
  
      @unittest.skip(reason="EfficientNet does not use feedforward chunking"   )
      def 							__magic_name__							(					self		: int   )   ->							str:
  
  
  
  
       '''simple docstring'''
  
       pass
  
  
  
  
      def 							__magic_name__							(					self		: Tuple   )   ->							Any:
  
  
  
  
       '''simple docstring'''
  
       A__,   A__ =       self.model_tester.prepare_config_and_inputs_for_common()
  
       for model_class in self.all_model_classes:
        A__ =       model_class(snake_case_   )
        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]			,				snake_case_   )
  
  
  
  
      def 							__magic_name__							(					self		: str   )   ->							List[Any]:
  
  
  
  
       '''simple docstring'''
  
       A__ =       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*snake_case_   )
  
  
  
  
      def 							__magic_name__							(					self		: str   )   ->							str:
  
  
  
  
       '''simple docstring'''
  
       def check_hidden_states_output(snake_case_		: List[str]			,				snake_case_		: Any			,				snake_case_		: List[str]   ):
        A__ =       model_class(snake_case_   )
        model.to(snake_case_   )
        model.eval()
  
        with torch.no_grad():
         A__ =       model(**self._prepare_for_class(snake_case_			,				snake_case_   )   )
  
        A__ =       outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states
        A__ =       sum(config.num_block_repeats   ) * 4
        self.assertEqual(len(snake_case_   )			,				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__ =       self.model_tester.prepare_config_and_inputs_for_common()
  
       for model_class in self.all_model_classes:
        A__ =       True
        check_hidden_states_output(snake_case_			,				snake_case_			,				snake_case_   )
  
        # check that output_hidden_states also work using config
        del inputs_dict["output_hidden_states"]
        A__ =       True
  
        check_hidden_states_output(snake_case_			,				snake_case_			,				snake_case_   )
  
  
  
  
      def 							__magic_name__							(					self		: Optional[int]   )   ->							Optional[Any]:
  
  
  
  
       '''simple docstring'''
  
       A__ =       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*snake_case_   )
  
  
  
  
      @unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."   )
      def 							__magic_name__							(					self		: Any   )   ->							Union[str, Any]:
  
  
  
  
       '''simple docstring'''
  
       pass
  
  
  
  
      @slow
      def 							__magic_name__							(					self		: List[str]   )   ->							Optional[Any]:
  
  
  
  
       '''simple docstring'''
  
       for model_name in EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        A__ =       EfficientNetModel.from_pretrained(snake_case_   )
        self.assertIsNotNone(snake_case_   )
  
  
  
  
      @is_pipeline_test
      @require_vision
      @slow
      def 							__magic_name__							(					self		: Optional[int]   )   ->							str:
  
  
  
  
       '''simple docstring'''
  
       super().test_pipeline_image_classification()
  
  
  
  
  
  
  
  def 						_SCREAMING_SNAKE_CASE     (							)		->	Optional[Any]:
   A__ =       Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"		)
   return image
  
  
  
  
  
  
  @require_torch
  @require_vision
  class 			UpperCAmelCase_						(		unittest.TestCase							):
  
  
  
  
      @cached_property
      def 							__magic_name__							(					self		: Dict   )   ->							List[str]:
  
  
  
  
       '''simple docstring'''
  
       return AutoImageProcessor.from_pretrained("google/efficientnet-b7"   ) if is_vision_available() else None
  
  
  
  
      @slow
      def 							__magic_name__							(					self		: Dict   )   ->							Union[str, Any]:
  
  
  
  
       '''simple docstring'''
  
       A__ =       EfficientNetForImageClassification.from_pretrained("google/efficientnet-b7"   ).to(snake_case_   )
  
       A__ =       self.default_image_processor
       A__ =       prepare_img()
       A__ =       image_processor(images=snake_case_			,				return_tensors="pt"   ).to(snake_case_   )
  
       # forward pass
       with torch.no_grad():
        A__ =       model(**snake_case_   )
  
       # verify the logits
       A__ =       torch.Size((1, 1_000)   )
       self.assertEqual(outputs.logits.shape			,				snake_case_   )
  
       A__ =       torch.tensor([0.0001, 0.0002, 0.0002]   ).to(snake_case_   )
       self.assertTrue(torch.allclose(outputs.logits[0, :3]			,				snake_case_			,				atol=1e-4   )   )
  
  
  
  
  
  
style_context: 
  
  
  
  
  """simple docstring"""
  
  
  
  from typing import Optional, Union
  
  from ...file_utils import TensorType
  from ...processing_utils import ProcessorMixin
  from ...tokenization_utils_base import BatchEncoding, PaddingStrategy, TruncationStrategy
  
  
  
  
  class 			UpperCAmelCase_						(		A_							):
      lowercase__		      =   '''MarkupLMFeatureExtractor'''
      lowercase__		      =   ('''MarkupLMTokenizer''', '''MarkupLMTokenizerFast''')
      lowercase__		      =   True
  
  
  
  
      def __call__(					self		: Dict			,				snake_case_		: Optional[int]=None			,				snake_case_		: Union[str, Any]=None			,				snake_case_		: Tuple=None			,				snake_case_		: str=None			,				snake_case_		: Optional[Any]=None			,				snake_case_		: bool = True			,				snake_case_		: Union[bool, str, PaddingStrategy] = False			,				snake_case_		: Union[bool, str, TruncationStrategy] = None			,				snake_case_		: Optional[int] = None			,				snake_case_		: int = 0			,				snake_case_		: Optional[int] = None			,				snake_case_		: Optional[bool] = None			,				snake_case_		: Optional[bool] = None			,				snake_case_		: bool = False			,				snake_case_		: bool = False			,				snake_case_		: bool = False			,				snake_case_		: bool = False			,				snake_case_		: bool = True			,				snake_case_		: Optional[Union[str, TensorType]] = None			,				**snake_case_		: Dict			,				)   ->							BatchEncoding:
  
  
  
  
       '''simple docstring'''
  
       if self.parse_html:
        if html_strings is None:
         raise ValueError("Make sure to pass HTML strings in case `parse_html` is set to `True`"   )
  
        if nodes is not None or xpaths is not None or node_labels is not None:
         raise ValueError(
             "Please don't pass nodes, xpaths nor node labels in case `parse_html` is set to `True`"   )
  
        A__ =       self.feature_extractor(snake_case_   )
        A__ =       features["nodes"]
        A__ =       features["xpaths"]
       else:
        if html_strings is not None:
         raise ValueError("You have passed HTML strings but `parse_html` is set to `False`."   )
        if nodes is None or xpaths is None:
         raise ValueError("Make sure to pass nodes and xpaths in case `parse_html` is set to `False`"   )
  
          # # second, apply the tokenizer
       if questions is not None and self.parse_html:
        if isinstance(snake_case_			,				snake_case_   ):
         A__ =       [questions]  # add batch dimension (as the feature extractor always adds a batch dimension)
  
       A__ =       self.tokenizer(
           text=questions if questions is not None else nodes			,				text_pair=nodes if questions is not None else None			,				xpaths=snake_case_			,				node_labels=snake_case_			,				add_special_tokens=snake_case_			,				padding=snake_case_			,				truncation=snake_case_			,				max_length=snake_case_			,				stride=snake_case_			,				pad_to_multiple_of=snake_case_			,				return_token_type_ids=snake_case_			,				return_attention_mask=snake_case_			,				return_overflowing_tokens=snake_case_			,				return_special_tokens_mask=snake_case_			,				return_offsets_mapping=snake_case_			,				return_length=snake_case_			,				verbose=snake_case_			,				return_tensors=snake_case_			,				**snake_case_			,				)
  
       return encoded_inputs
  
  
  
  
      def 							__magic_name__							(					self		: Optional[Any]			,				*snake_case_		: Any			,				**snake_case_		: Any   )   ->							int:
  
  
  
  
       '''simple docstring'''
  
       return self.tokenizer.batch_decode(*snake_case_			,				**snake_case_   )
  
  
  
  
      def 							__magic_name__							(					self		: Tuple			,				*snake_case_		: Optional[Any]			,				**snake_case_		: List[Any]   )   ->							Any:
  
  
  
  
       '''simple docstring'''
  
       return self.tokenizer.decode(*snake_case_			,				**snake_case_   )
  
  
  
  
      @property
      def 							__magic_name__							(					self		: List[Any]   )   ->							Optional[int]:
  
  
  
  
       '''simple docstring'''
  
       A__ =       self.tokenizer.model_input_names
       return tokenizer_input_names
  
  
  
  
  
  