





"""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    :



      '''simple docstring'''

      def __init__(	self   , snake_case_   , snake_case_=1_3   , snake_case_=3_2   , snake_case_=3   , snake_case_=[3, 3, 5]   , snake_case_=[3_2, 1_6, 2_4]   , snake_case_=[1_6, 2_4, 4_0]   , snake_case_=[1, 1, 2]   , snake_case_=[1, 1, 2]   , snake_case_=[1, 6, 6]   , snake_case_=True   , snake_case_=True   , snake_case_=3_7   , snake_case_="gelu"   , snake_case_=1_0   , ):

        """simple docstring"""

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

      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        A_    :			Union[str, Any]									=    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]    )

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

        A_    :			List[Any]									=    self.get_config()
        return config, pixel_values, labels

      def    lowerCamelCase_     (	self    ):

        """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    lowerCamelCase_     (	self   , snake_case_   , snake_case_   , snake_case_    ):

        """simple docstring"""

        A_    :			List[str]									=    EfficientNetModel(config=snake_case_    )
        model.to(snake_case_    )
        model.eval()
        A_    :			Dict									=    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    lowerCamelCase_     (	self   , snake_case_   , snake_case_   , snake_case_    ):

        """simple docstring"""

        A_    :			int									=    EfficientNetForImageClassification(snake_case_    )
        model.to(snake_case_    )
        model.eval()
        A_    :			Optional[int]									=    model(snake_case_   , labels=snake_case_    )
        self.parent.assertEqual(result.logits.shape   , (self.batch_size, self.num_labels)    )

      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        A_    :			int									=    self.prepare_config_and_inputs()
        A_		,			A_		,			A_    :			List[str]									=    config_and_inputs
        A_    :			Tuple									=    {'pixel_values': pixel_values}
        return config, inputs_dict


@require_torch
class 					_UpperCAmelCase    (  UpperCAmelCase__     ,  UpperCAmelCase__     ,  unittest.TestCase						):



      '''simple docstring'''
      lowercase_ :					Union[str, Any]             =  (EfficientNetModel, EfficientNetForImageClassification) if is_torch_available() else ()
      lowercase_ :					List[str]             =  (
          {"""feature-extraction""": EfficientNetModel, """image-classification""": EfficientNetForImageClassification}
          if is_torch_available()
          else {}
      )

      lowercase_ :					Optional[Any]             =  False
      lowercase_ :					Optional[int]             =  False
      lowercase_ :					Optional[int]             =  False
      lowercase_ :					Tuple             =  False
      lowercase_ :					Optional[int]             =  False

      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        A_    :			List[Any]									=    EfficientNetModelTester(self    )
        A_    :			List[Any]									=    ConfigTester(
            self   , config_class=snake_case_   , has_text_modality=snake_case_   , hidden_size=3_7    )

      def    lowerCamelCase_     (	self    ):

        """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    lowerCamelCase_     (	self    ):

        """simple docstring"""

        return

      @unittest.skip(reason='EfficientNet does not use inputs_embeds'    )
      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        pass

      @unittest.skip(reason='EfficientNet does not support input and output embeddings'    )
      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        pass

      @unittest.skip(reason='EfficientNet does not use feedforward chunking'    )
      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        pass

      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        A_		,			A_    :			str									=    self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
          A_    :			Tuple									=    model_class(snake_case_    )
          A_    :			Optional[Any]									=    inspect.signature(model.forward    )
          # signature.parameters is an OrderedDict => so arg_names order is deterministic
          A_    :			Dict									=    [*signature.parameters.keys()]

          A_    :			Tuple									=    ['pixel_values']
          self.assertListEqual(arg_names[:1]   , snake_case_    )

      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        A_    :			List[Any]									=    self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*snake_case_    )

      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        def check_hidden_states_output(snake_case_   , snake_case_   , snake_case_    ):
          A_    :			int									=    model_class(snake_case_    )
          model.to(snake_case_    )
          model.eval()

          with torch.no_grad():
            A_    :			List[Any]									=    model(**self._prepare_for_class(snake_case_   , snake_case_    )    )

          A_    :			Dict									=    outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states
          A_    :			List[str]									=    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_    :			str									=    self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
          A_    :			Dict									=    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_    :			List[Any]									=    True

          check_hidden_states_output(snake_case_   , snake_case_   , snake_case_    )

      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        A_    :			Optional[Any]									=    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    lowerCamelCase_     (	self    ):

        """simple docstring"""

        pass

      @slow
      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        for model_name in EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          A_    :			List[Any]									=    EfficientNetModel.from_pretrained(snake_case_    )
          self.assertIsNotNone(snake_case_    )

      @is_pipeline_test
      @require_vision
      @slow
      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        super().test_pipeline_image_classification()





def 		UpperCAmelCase__						(	):






  """simple docstring"""





  A_    :			Optional[Any]									=    Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'   )
  return image





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



      '''simple docstring'''

      @cached_property
      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

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

      @slow
      def    lowerCamelCase_     (	self    ):

        """simple docstring"""

        A_    :			Dict									=    EfficientNetForImageClassification.from_pretrained('google/efficientnet-b7'    ).to(snake_case_    )

        A_    :			Tuple									=    self.default_image_processor
        A_    :			Tuple									=    prepare_img()
        A_    :			List[Any]									=    image_processor(images=snake_case_   , return_tensors='pt'    ).to(snake_case_    )

        # forward pass
        with torch.no_grad():
          A_    :			Optional[int]									=    model(**snake_case_    )

        # verify the logits
        A_    :			List[Any]									=    torch.Size((1, 1_0_0_0)    )
        self.assertEqual(outputs.logits.shape   , snake_case_    )

        A_    :			Optional[int]									=    torch.tensor([0.00_01, 0.00_02, 0.00_02]    ).to(snake_case_    )
        self.assertTrue(torch.allclose(outputs.logits[0, :3]   , snake_case_   , atol=1E-4    )    )




'''simple docstring'''







import csv
import dataclasses
import json
from dataclasses import dataclass
from typing import List, Optional, Union

from ...utils import is_tf_available, is_torch_available, logging


lowercase__  :	str            =      logging.get_logger(__name__)

@dataclass
class    lowerCamelCase_				:






   '''simple docstring'''

   A			:  str
   A			:  str
   A			:  Optional[str]					=						None
   A			:  Optional[str]					=						None


   def 						_UpperCamelCase							(	self			):
       return json.dumps(dataclasses.asdict(self			)  ,    indent=2			) + "\n"

@dataclass(frozen=lowerCAmelCase_	)
class    lowerCamelCase_				:






   '''simple docstring'''

   A			:  List[int]
   A			:  Optional[List[int]]					=						None
   A			:  Optional[List[int]]					=						None
   A			:  Optional[Union[int, float]]					=						None


   def 						_UpperCamelCase							(	self			):
       return json.dumps(dataclasses.asdict(self			)			) + "\n"

class    lowerCamelCase_				:






   '''simple docstring'''

   def 						_UpperCamelCase							(	self  ,    __UpperCamelCase			):
       raise NotImplementedError()


   def 						_UpperCamelCase							(	self  ,    __UpperCamelCase			):
       raise NotImplementedError()


   def 						_UpperCamelCase							(	self  ,    __UpperCamelCase			):
       raise NotImplementedError()


   def 						_UpperCamelCase							(	self  ,    __UpperCamelCase			):
       raise NotImplementedError()


   def 						_UpperCamelCase							(	self			):
       raise NotImplementedError()


   def 						_UpperCamelCase							(	self  ,    __UpperCamelCase			):
       if len(self.get_labels()			) > 1:
           UpperCamelCase__	     =      self.get_labels()[int(example.label			)]
       return example







   @classmethod
   def 						_UpperCamelCase							(	cls  ,    __UpperCamelCase  ,    __UpperCamelCase=None			):
       with open(__UpperCamelCase  ,    "r"  ,    encoding="utf-8-sig"			) as f:
           return list(csv.reader(__UpperCamelCase  ,    delimiter="\t"  ,    quotechar=__UpperCamelCase			)			)

class    lowerCamelCase_				(						lowerCAmelCase_	):






   '''simple docstring'''

   def __init__(	self  ,    __UpperCamelCase=None  ,    __UpperCamelCase=None  ,    __UpperCamelCase="classification"  ,    __UpperCamelCase=False			):
       UpperCamelCase__	     =      [] if labels is None else labels
       UpperCamelCase__	     =      [] if examples is None else examples
       UpperCamelCase__	     =      mode
       UpperCamelCase__	     =      verbose


   def __len__(	self			):
       return len(self.examples			)


   def __getitem__(	self  ,    __UpperCamelCase			):
       if isinstance(__UpperCamelCase  ,    __UpperCamelCase			):
           return SingleSentenceClassificationProcessor(labels=self.labels  ,    examples=self.examples[idx]			)
       return self.examples[idx]


   @classmethod
   def 						_UpperCamelCase							(	cls  ,    __UpperCamelCase  ,    __UpperCamelCase=""  ,    __UpperCamelCase=0  ,    __UpperCamelCase=1  ,    __UpperCamelCase=None  ,    __UpperCamelCase=False  ,    **__UpperCamelCase			):
       UpperCamelCase__	     =      cls(**__UpperCamelCase			)
       processor.add_examples_from_csv(
           __UpperCamelCase  ,    split_name=__UpperCamelCase  ,    column_label=__UpperCamelCase  ,    column_text=__UpperCamelCase  ,    column_id=__UpperCamelCase  ,    skip_first_row=__UpperCamelCase  ,    overwrite_labels=__UpperCamelCase  ,    overwrite_examples=__UpperCamelCase  ,    )
       return processor


   @classmethod
   def 						_UpperCamelCase							(	cls  ,    __UpperCamelCase  ,    __UpperCamelCase=None  ,    **__UpperCamelCase			):
       UpperCamelCase__	     =      cls(**__UpperCamelCase			)
       processor.add_examples(__UpperCamelCase  ,    labels=__UpperCamelCase			)
       return processor


   def 						_UpperCamelCase							(	self  ,    __UpperCamelCase  ,    __UpperCamelCase=""  ,    __UpperCamelCase=0  ,    __UpperCamelCase=1  ,    __UpperCamelCase=None  ,    __UpperCamelCase=False  ,    __UpperCamelCase=False  ,    __UpperCamelCase=False  ,    ):
       UpperCamelCase__	     =      self._read_tsv(__UpperCamelCase			)
       if skip_first_row:
           UpperCamelCase__	     =      lines[1:]
       UpperCamelCase__	     =      []
       UpperCamelCase__	     =      []
       UpperCamelCase__	     =      []
       for i, line in enumerate(__UpperCamelCase			):
           texts.append(line[column_text]			)
           labels.append(line[column_label]			)
           if column_id is not None:
               ids.append(line[column_id]			)
           else:
               UpperCamelCase__	     =      f'{split_name}-{i}' if split_name else str(__UpperCamelCase			)
               ids.append(__UpperCamelCase			)

       return self.add_examples(
           __UpperCamelCase  ,    __UpperCamelCase  ,    __UpperCamelCase  ,    overwrite_labels=__UpperCamelCase  ,    overwrite_examples=__UpperCamelCase			)


   def 						_UpperCamelCase							(	self  ,    __UpperCamelCase  ,    __UpperCamelCase=None  ,    __UpperCamelCase=None  ,    __UpperCamelCase=False  ,    __UpperCamelCase=False			):
       if labels is not None and len(__UpperCamelCase			) != len(__UpperCamelCase			):
           raise ValueError(
               f'Text and labels have mismatched lengths {len(__UpperCamelCase			)} and {len(__UpperCamelCase			)}'			)
       if ids is not None and len(__UpperCamelCase			) != len(__UpperCamelCase			):
           raise ValueError(f'Text and ids have mismatched lengths {len(__UpperCamelCase			)} and {len(__UpperCamelCase			)}'			)
       if ids is None:
           UpperCamelCase__	     =      [None] * len(__UpperCamelCase			)
       if labels is None:
           UpperCamelCase__	     =      [None] * len(__UpperCamelCase			)
       UpperCamelCase__	     =      []
       UpperCamelCase__	     =      set()
       for text_or_text_and_label, label, guid in zip(__UpperCamelCase  ,    __UpperCamelCase  ,    __UpperCamelCase			):
           if isinstance(__UpperCamelCase  ,    (tuple, list)			) and label is None:
               UpperCamelCase__     ,	UpperCamelCase__	     =      text_or_text_and_label
           else:
               UpperCamelCase__	     =      text_or_text_and_label
           added_labels.add(__UpperCamelCase			)
           examples.append(InputExample(guid=__UpperCamelCase  ,    text_a=__UpperCamelCase  ,    text_b=__UpperCamelCase  ,    label=__UpperCamelCase			)			)

       # Update examples
       if overwrite_examples:
           UpperCamelCase__	     =      examples
       else:
           self.examples.extend(__UpperCamelCase			)

       # Update labels
       if overwrite_labels:
           UpperCamelCase__	     =      list(__UpperCamelCase			)
       else:
           UpperCamelCase__	     =      list(set(self.labels			).union(__UpperCamelCase			)			)

       return self.examples







   def 						_UpperCamelCase							(	self  ,    __UpperCamelCase  ,    __UpperCamelCase=None  ,    __UpperCamelCase=False  ,    __UpperCamelCase=0  ,    __UpperCamelCase=True  ,    __UpperCamelCase=None  ,    ):
       if max_length is None:
           UpperCamelCase__	     =      tokenizer.max_len

       UpperCamelCase__	     =      {label: i for i, label in enumerate(self.labels			)}

       UpperCamelCase__	     =      []
       for ex_index, example in enumerate(self.examples			):
           if ex_index % 1_00_00 == 0:
               logger.info(f'Tokenizing example {ex_index}'			)

           UpperCamelCase__	     =      tokenizer.encode(
               example.text_a  ,    add_special_tokens=__UpperCamelCase  ,    max_length=min(__UpperCamelCase  ,    tokenizer.max_len			)  ,    )
           all_input_ids.append(__UpperCamelCase			)

       UpperCamelCase__	     =      max(len(__UpperCamelCase			) for input_ids in all_input_ids			)

       UpperCamelCase__	     =      []
       for ex_index, (input_ids, example) in enumerate(zip(__UpperCamelCase  ,    self.examples			)			):
           if ex_index % 1_00_00 == 0:
               logger.info(f'Writing example {ex_index}/{len(self.examples			)}'			)
           # The mask has 1 for real tokens and 0 for padding tokens. Only real
           # tokens are attended to.
           UpperCamelCase__	     =      [1 if mask_padding_with_zero else 0] * len(__UpperCamelCase			)

           # Zero-pad up to the sequence length.
           UpperCamelCase__	     =      batch_length - len(__UpperCamelCase			)
           if pad_on_left:
               UpperCamelCase__	     =      ([pad_token] * padding_length) + input_ids
               UpperCamelCase__	     =      ([0 if mask_padding_with_zero else 1] * padding_length) + attention_mask
           else:
               UpperCamelCase__	     =      input_ids + ([pad_token] * padding_length)
               UpperCamelCase__	     =      attention_mask + ([0 if mask_padding_with_zero else 1] * padding_length)

           if len(__UpperCamelCase			) != batch_length:
               raise ValueError(f'Error with input length {len(__UpperCamelCase			)} vs {batch_length}'			)
           if len(__UpperCamelCase			) != batch_length:
               raise ValueError(f'Error with input length {len(__UpperCamelCase			)} vs {batch_length}'			)

           if self.mode == "classification":
               UpperCamelCase__	     =      label_map[example.label]
           elif self.mode == "regression":
               UpperCamelCase__	     =      float(example.label			)
           else:
               raise ValueError(self.mode			)

           if ex_index < 5 and self.verbose:
               logger.info("*** Example ***"			)
               logger.info(f'guid: {example.guid}'			)
               logger.info(f'input_ids: {" ".join([str(__UpperCamelCase			) for x in input_ids]			)}'			)
               logger.info(f'attention_mask: {" ".join([str(__UpperCamelCase			) for x in attention_mask]			)}'			)
               logger.info(f'label: {example.label} (id = {label})'			)

           features.append(InputFeatures(input_ids=__UpperCamelCase  ,    attention_mask=__UpperCamelCase  ,    label=__UpperCamelCase			)			)

       if return_tensors is None:
           return features
       elif return_tensors == "tf":
           if not is_tf_available():
               raise RuntimeError("return_tensors set to 'tf' but TensorFlow 2.0 can't be imported"			)
           import tensorflow as tf

           def gen():
               for ex in features:
                   yield ({"input_ids": ex.input_ids, "attention_mask": ex.attention_mask}, ex.label)

           UpperCamelCase__	     =      tf.data.Dataset.from_generator(
               __UpperCamelCase  ,    ({"input_ids": tf.intaa, "attention_mask": tf.intaa}, tf.intaa)  ,    ({"input_ids": tf.TensorShape([None]			), "attention_mask": tf.TensorShape([None]			)}, tf.TensorShape([]			))  ,    )
           return dataset
       elif return_tensors == "pt":
           if not is_torch_available():
               raise RuntimeError("return_tensors set to 'pt' but PyTorch can't be imported"			)
           import torch
           from torch.utils.data import TensorDataset

           UpperCamelCase__	     =      torch.tensor([f.input_ids for f in features]  ,    dtype=torch.long			)
           UpperCamelCase__	     =      torch.tensor([f.attention_mask for f in features]  ,    dtype=torch.long			)
           if self.mode == "classification":
               UpperCamelCase__	     =      torch.tensor([f.label for f in features]  ,    dtype=torch.long			)
           elif self.mode == "regression":
               UpperCamelCase__	     =      torch.tensor([f.label for f in features]  ,    dtype=torch.float			)

           UpperCamelCase__	     =      TensorDataset(__UpperCamelCase  ,    __UpperCamelCase  ,    __UpperCamelCase			)
           return dataset
       else:
           raise ValueError("return_tensors should be one of 'tf' or 'pt'"			)




