




'''simple docstring'''


import csv
from collections import defaultdict
from dataclasses import dataclass, field
from typing import List, Optional

import matplotlib.pyplot as plt
import numpy as np
from matplotlib.ticker import ScalarFormatter

from transformers import HfArgumentParser
def 				SCREAMING_SNAKE_CASE(      __lowercase=None		,							__lowercase=None  ) ->   Optional[Any]:
     return field(default_factory=lambda: default		,							metadata=__lowercase  )






@dataclass
class 	lowerCAmelCase_  :







  '''simple docstring'''

  UpperCamelCase_ :			str        =							field(
      metadata={"""help""": """The csv file to plot."""}					,				)
  UpperCamelCase_ :			bool        =							field(
      default=UpperCAmelCase_					,				metadata={"""help""": """Whether to plot along batch size or sequence length. Defaults to sequence length."""}					,				)
  UpperCamelCase_ :			bool        =							field(
      default=UpperCAmelCase_					,				metadata={"""help""": """Whether the csv file has time results or memory results. Defaults to memory results."""}					,				)
  UpperCamelCase_ :			bool        =							field(
      default=UpperCAmelCase_					,				metadata={"""help""": """Disable logarithmic scale when plotting"""}					,				)
  UpperCamelCase_ :			bool        =							field(
      default=UpperCAmelCase_					,				metadata={
          """help""": """Whether the csv file has training results or inference results. Defaults to inference results."""
      }					,				)
  UpperCamelCase_ :			Optional[str]        =							field(
      default=UpperCAmelCase_					,				metadata={"""help""": """Filename under which the plot will be saved. If unused no plot is saved."""}					,				)
  UpperCamelCase_ :			Optional[List[str]]        =							list_field(
      default=UpperCAmelCase_					,				metadata={"""help""": """List of model names that are used instead of the ones in the csv file."""}       )






def 				SCREAMING_SNAKE_CASE(      __lowercase  ) ->   Dict:
     try:
          int(__lowercase  )
          return True
     except ValueError:
          return False
def 				SCREAMING_SNAKE_CASE(      __lowercase  ) ->   Optional[Any]:
     try:
          float(__lowercase  )
          return True
     except ValueError:
          return False






class 	lowerCAmelCase_  :







  '''simple docstring'''

  def __init__(   self							:       int				,     SCREAMING_SNAKE_CASE_							:       List[str]  ) ->		Union[str, Any]:







       '''simple docstring'''



       A:		Optional[Any]        =		args
       A:		int        =		defaultdict(lambda: {"bsz": [], "seq_len": [], "result": {}}  )

       with open(self.args.csv_file				,     newline=''''''  ) as csv_file:
            A:		List[str]        =		csv.DictReader(SCREAMING_SNAKE_CASE_  )
            for row in reader:
                 A:		Any        =		row['''model''']
                 self.result_dict[model_name]["bsz"].append(int(row['''batch_size''']  )  )
                 self.result_dict[model_name]["seq_len"].append(int(row['''sequence_length''']  )  )
                 if can_convert_to_int(row['''result''']  ):
                      # value is not None
                      A:		Optional[Any]        =		int(row['''result''']  )
                 elif can_convert_to_float(row['''result''']  ):
                      # value is not None
                      A:		List[str]        =		float(row['''result''']  )




  def 				_snake_case    (   self							:       Any  ) ->		Tuple:







       '''simple docstring'''



       A    ,						A:		Optional[int]        =		plt.subplots()
       A:		Optional[int]        =		'''Time usage''' if self.args.is_time else '''Memory usage'''
       A:		Union[str, Any]        =		title_str + ''' for training''' if self.args.is_train else title_str + ''' for inference'''

       if not self.args.no_log_scale:
            # set logarithm scales
            ax.set_xscale('''log'''  )
            ax.set_yscale('''log'''  )

       for axis in [ax.xaxis, ax.yaxis]:
            axis.set_major_formatter(ScalarFormatter()  )

       for model_name_idx, model_name in enumerate(self.result_dict.keys()  ):
            A:		List[Any]        =		sorted(set(self.result_dict[model_name]['''bsz''']  )  )
            A:		List[Any]        =		sorted(set(self.result_dict[model_name]['''seq_len''']  )  )
            A:		int        =		self.result_dict[model_name]['''result''']

            ((A)    ,						(A)):		int        =		(
                (batch_sizes, sequence_lengths) if self.args.plot_along_batch else (sequence_lengths, batch_sizes)
            )

            A:		Tuple        =		(
                model_name if self.args.short_model_names is None else self.args.short_model_names[model_name_idx]
            )

            for inner_loop_value in inner_loop_array:
                 if self.args.plot_along_batch:
                      A:		Any        =		np.asarray(
                          [results[(x, inner_loop_value)] for x in x_axis_array if (x, inner_loop_value) in results]				,     dtype=SCREAMING_SNAKE_CASE_				,     )
                 else:
                      A:		Optional[int]        =		np.asarray(
                          [results[(inner_loop_value, x)] for x in x_axis_array if (inner_loop_value, x) in results]				,     dtype=np.floataa				,     )

                 ((A)    ,						(A)):		Optional[Any]        =		(
                     ('''batch_size''', '''len''') if self.args.plot_along_batch else ('''in #tokens''', '''bsz''')
                 )

                 A:		List[Any]        =		np.asarray(SCREAMING_SNAKE_CASE_				,     SCREAMING_SNAKE_CASE_  )[: len(SCREAMING_SNAKE_CASE_  )]
                 plt.scatter(
                     SCREAMING_SNAKE_CASE_				,     SCREAMING_SNAKE_CASE_				,     label=f"""{label_model_name} - {inner_loop_label}: {inner_loop_value}"""  )
                 plt.plot(SCREAMING_SNAKE_CASE_				,     SCREAMING_SNAKE_CASE_				,     '''--'''  )

            title_str += f""" {label_model_name} vs."""

       A:		Dict        =		title_str[:-4]
       A:		Union[str, Any]        =		'''Time in s''' if self.args.is_time else '''Memory in MB'''

       # plot
       plt.title(SCREAMING_SNAKE_CASE_  )
       plt.xlabel(SCREAMING_SNAKE_CASE_  )
       plt.ylabel(SCREAMING_SNAKE_CASE_  )
       plt.legend()

       if self.args.figure_png_file is not None:
            plt.savefig(self.args.figure_png_file  )
       else:
            plt.show()






def 				SCREAMING_SNAKE_CASE(      ) ->   List[Any]:
     A:		Optional[Any]        =		HfArgumentParser(__lowercase  )
     A:		Optional[int]        =		parser.parse_args_into_dataclasses()[0]
     A:		Union[str, Any]        =		Plot(args=__lowercase  )
     plot.plot()


if __name__ == "__main__":
     main()












'''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  )  )






