



'''simple docstring'''


import glob
import os
from typing import Dict, List, Union

import torch

from diffusers.utils import is_safetensors_available


if is_safetensors_available():
     import safetensors.torch

from huggingface_hub import snapshot_download

from diffusers import DiffusionPipeline, __version__
from diffusers.schedulers.scheduling_utils import SCHEDULER_CONFIG_NAME
from diffusers.utils import CONFIG_NAME, DIFFUSERS_CACHE, ONNX_WEIGHTS_NAME, WEIGHTS_NAME






class 	lowerCAmelCase_  (					UpperCAmelCase_       ):







  '''simple docstring'''

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







       '''simple docstring'''



       self.register_to_config()
       super().__init__()



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







       '''simple docstring'''



       if dicta == dicta:
            return True
       else:
            A:		List[Any]        =		self._remove_meta_keys(__lowerCamelCase  )
            A:		Tuple        =		self._remove_meta_keys(__lowerCamelCase  )
            if configa == configa:
                 print(f"""Warning !: Mismatch in keys {meta_keysa} and {meta_keysa}."""  )
                 return True
       return False



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







       '''simple docstring'''



       A:		Any        =		[]
       A:		List[Any]        =		config_dict.copy()
       for key in config_dict.keys():
            if key.startswith('''_'''  ):
                 temp_dict.pop(__lowerCamelCase  )
                 meta_keys.append(__lowerCamelCase  )
       return (temp_dict, meta_keys)



  @torch.no_grad()
  def 				_snake_case    (   self							:       int				,     SCREAMING_SNAKE_CASE_							:       Optional[Any]				,     **SCREAMING_SNAKE_CASE_							:       Any  ) ->		List[Any]:







       '''simple docstring'''



       A:		Any        =		kwargs.pop('''cache_dir'''				,     __lowerCamelCase  )
       A:		List[Any]        =		kwargs.pop('''resume_download'''				,     __lowerCamelCase  )
       A:		int        =		kwargs.pop('''force_download'''				,     __lowerCamelCase  )
       A:		List[Any]        =		kwargs.pop('''proxies'''				,     __lowerCamelCase  )
       A:		Optional[int]        =		kwargs.pop('''local_files_only'''				,     __lowerCamelCase  )
       A:		Union[str, Any]        =		kwargs.pop('''use_auth_token'''				,     __lowerCamelCase  )
       A:		int        =		kwargs.pop('''revision'''				,     __lowerCamelCase  )
       A:		Tuple        =		kwargs.pop('''torch_dtype'''				,     __lowerCamelCase  )
       A:		List[Any]        =		kwargs.pop('''device_map'''				,     __lowerCamelCase  )

       A:		List[Any]        =		kwargs.pop('''alpha'''				,     0.5  )
       A:		Any        =		kwargs.pop('''interp'''				,     __lowerCamelCase  )

       print('''Received list'''				,     __lowerCamelCase  )
       print(f"""Combining with alpha={alpha}, interpolation mode={interp}"""  )

       A:		Tuple        =		len(__lowerCamelCase  )
       # Ignore result from model_index_json comparision of the two checkpoints
       A:		Tuple        =		kwargs.pop('''force'''				,     __lowerCamelCase  )

       # If less than 2 checkpoints, nothing to merge. If more than 3, not supported for now.
       if checkpoint_count > 3 or checkpoint_count < 2:
            raise ValueError(
                '''Received incorrect number of checkpoints to merge. Ensure that either 2 or 3 checkpoints are being'''
                ''' passed.'''  )

       print('''Received the right number of checkpoints'''  )
       # chkpt0, chkpt1 = pretrained_model_name_or_path_list[0:2]
       # chkpt2 = pretrained_model_name_or_path_list[2] if checkpoint_count == 3 else None

       # Validate that the checkpoints can be merged
       # Step 1: Load the model config and compare the checkpoints. We'll compare the model_index.json first while ignoring the keys starting with '_'
       A:		Union[str, Any]        =		[]
       for pretrained_model_name_or_path in pretrained_model_name_or_path_list:
            A:		Dict        =		DiffusionPipeline.load_config(
                __lowerCamelCase				,     cache_dir=__lowerCamelCase				,     resume_download=__lowerCamelCase				,     force_download=__lowerCamelCase				,     proxies=__lowerCamelCase				,     local_files_only=__lowerCamelCase				,     use_auth_token=__lowerCamelCase				,     revision=__lowerCamelCase				,     )
            config_dicts.append(__lowerCamelCase  )

       A:		Any        =		True
       for idx in range(1				,     len(__lowerCamelCase  )  ):
            comparison_result &= self._compare_model_configs(config_dicts[idx - 1]				,     config_dicts[idx]  )
            if not force and comparison_result is False:
                 raise ValueError('''Incompatible checkpoints. Please check model_index.json for the models.'''  )
                 print(config_dicts[0]				,     config_dicts[1]  )
       print('''Compatible model_index.json files found'''  )
       # Step 2: Basic Validation has succeeded. Let's download the models and save them into our local files.
       A:		Optional[Any]        =		[]
       for pretrained_model_name_or_path, config_dict in zip(__lowerCamelCase				,     __lowerCamelCase  ):
            A:		int        =		[k for k in config_dict.keys() if not k.startswith('''_'''  )]
            A:		Any        =		[os.path.join(__lowerCamelCase				,     '''*'''  ) for k in folder_names]
            allow_patterns += [
                WEIGHTS_NAME,
                SCHEDULER_CONFIG_NAME,
                CONFIG_NAME,
                ONNX_WEIGHTS_NAME,
                DiffusionPipeline.config_name,
            ]
            A:		int        =		config_dict.get('''_class_name'''  )
            A:		int        =		{"diffusers": __version__, "pipeline_class": requested_pipeline_class}

            A:		Tuple        =		(
                pretrained_model_name_or_path
                if os.path.isdir(__lowerCamelCase  )
                else snapshot_download(
                    __lowerCamelCase				,     cache_dir=__lowerCamelCase				,     resume_download=__lowerCamelCase				,     proxies=__lowerCamelCase				,     local_files_only=__lowerCamelCase				,     use_auth_token=__lowerCamelCase				,     revision=__lowerCamelCase				,     allow_patterns=__lowerCamelCase				,     user_agent=__lowerCamelCase				,     )
            )
            print('''Cached Folder'''				,     __lowerCamelCase  )
            cached_folders.append(__lowerCamelCase  )

       # Step 3:-
       # Load the first checkpoint as a diffusion pipeline and modify its module state_dict in place
       A:		str        =		DiffusionPipeline.from_pretrained(
           cached_folders[0]				,     torch_dtype=__lowerCamelCase				,     device_map=__lowerCamelCase  )
       final_pipe.to(self.device  )

       A:		Any        =		None
       if len(__lowerCamelCase  ) > 2:
            A:		Optional[Any]        =		os.path.join(cached_folders[2]  )

       if interp == "sigmoid":
            A:		List[str]        =		CheckpointMergerPipeline.sigmoid
       elif interp == "inv_sigmoid":
            A:		Dict        =		CheckpointMergerPipeline.inv_sigmoid
       elif interp == "add_diff":
            A:		Dict        =		CheckpointMergerPipeline.add_difference
       else:
            A:		List[str]        =		CheckpointMergerPipeline.weighted_sum

       # Find each module's state dict.
       for attr in final_pipe.config.keys():
            if not attr.startswith('''_'''  ):
                 A:		Optional[int]        =		os.path.join(cached_folders[1]				,     __lowerCamelCase  )
                 if os.path.exists(__lowerCamelCase  ):
                      A:		Dict        =		[
                          *glob.glob(os.path.join(__lowerCamelCase				,     '''*.safetensors'''  )  ),
                          *glob.glob(os.path.join(__lowerCamelCase				,     '''*.bin'''  )  ),
                      ]
                      A:		Tuple        =		files[0] if len(__lowerCamelCase  ) > 0 else None
                 if len(__lowerCamelCase  ) < 3:
                      A:		int        =		None
                 else:
                      A:		int        =		os.path.join(cached_folders[2]				,     __lowerCamelCase  )
                      if os.path.exists(__lowerCamelCase  ):
                           A:		Any        =		[
                               *glob.glob(os.path.join(__lowerCamelCase				,     '''*.safetensors'''  )  ),
                               *glob.glob(os.path.join(__lowerCamelCase				,     '''*.bin'''  )  ),
                           ]
                           A:		Dict        =		files[0] if len(__lowerCamelCase  ) > 0 else None
                # For an attr if both checkpoint_path_1 and 2 are None, ignore.
                # If atleast one is present, deal with it according to interp method, of course only if the state_dict keys match.
                 if checkpoint_path_a is None and checkpoint_path_a is None:
                      print(f"""Skipping {attr}: not present in 2nd or 3d model"""  )
                      continue
                 try:
                      A:		Any        =		getattr(__lowerCamelCase				,     __lowerCamelCase  )
                      if isinstance(__lowerCamelCase				,     __lowerCamelCase  ):  # ignore requires_safety_checker boolean
                           continue
                      A:		Dict        =		getattr(__lowerCamelCase				,     '''state_dict'''  )
                      A:		List[str]        =		theta_a()

                      A:		List[str]        =		getattr(__lowerCamelCase				,     '''load_state_dict'''  )
                      A:		List[Any]        =		(
                          safetensors.torch.load_file(__lowerCamelCase  )
                          if (is_safetensors_available() and checkpoint_path_a.endswith('''.safetensors'''  ))
                          else torch.load(__lowerCamelCase				,     map_location='''cpu'''  )
                      )
                      A:		List[str]        =		None
                      if checkpoint_path_a:
                           A:		Union[str, Any]        =		(
                               safetensors.torch.load_file(__lowerCamelCase  )
                               if (is_safetensors_available() and checkpoint_path_a.endswith('''.safetensors'''  ))
                               else torch.load(__lowerCamelCase				,     map_location='''cpu'''  )
                           )

                      if not theta_a.keys() == theta_a.keys():
                           print(f"""Skipping {attr}: key mismatch"""  )
                           continue
                      if theta_a and not theta_a.keys() == theta_a.keys():
                           print(f"""Skipping {attr}:y mismatch"""  )
                 except Exception as e:
                      print(f"""Skipping {attr} do to an unexpected error: {str(__lowerCamelCase  )}"""  )
                      continue
                 print(f"""MERGING {attr}"""  )

                 for key in theta_a.keys():
                      if theta_a:
                           A:		List[str]        =		theta_func(theta_a[key]				,     theta_a[key]				,     theta_a[key]				,     __lowerCamelCase  )
                      else:
                           A:		Optional[int]        =		theta_func(theta_a[key]				,     theta_a[key]				,     __lowerCamelCase				,     __lowerCamelCase  )

                 del theta_a
                 del theta_a
                 update_theta_a(__lowerCamelCase  )

                 del theta_a
       return final_pipe



  @staticmethod
  def 				_snake_case    (   SCREAMING_SNAKE_CASE_							:       Dict				,     SCREAMING_SNAKE_CASE_							:       int				,     SCREAMING_SNAKE_CASE_							:       Tuple				,     SCREAMING_SNAKE_CASE_							:       Optional[int]  ) ->		str:







       '''simple docstring'''



       return ((1 - alpha) * thetaa) + (alpha * thetaa)



  @staticmethod
  def 				_snake_case    (   SCREAMING_SNAKE_CASE_							:       Dict				,     SCREAMING_SNAKE_CASE_							:       Union[str, Any]				,     SCREAMING_SNAKE_CASE_							:       Tuple				,     SCREAMING_SNAKE_CASE_							:       Any  ) ->		List[Any]:







       '''simple docstring'''



       A:		Tuple        =		alpha * alpha * (3 - (2 * alpha))
       return thetaa + ((thetaa - thetaa) * alpha)



  @staticmethod
  def 				_snake_case    (   SCREAMING_SNAKE_CASE_							:       Union[str, Any]				,     SCREAMING_SNAKE_CASE_							:       int				,     SCREAMING_SNAKE_CASE_							:       List[Any]				,     SCREAMING_SNAKE_CASE_							:       List[Any]  ) ->		Union[str, Any]:







       '''simple docstring'''



       import math

       A:		Optional[int]        =		0.5 - math.sin(math.asin(1.0 - 2.0 * alpha  ) / 3.0  )
       return thetaa + ((thetaa - thetaa) * alpha)




  @staticmethod
  def 				_snake_case    (   SCREAMING_SNAKE_CASE_							:       List[str]				,     SCREAMING_SNAKE_CASE_							:       Optional[int]				,     SCREAMING_SNAKE_CASE_							:       str				,     SCREAMING_SNAKE_CASE_							:       Optional[Any]  ) ->		Optional[Any]:







       '''simple docstring'''



       return thetaa + (thetaa - thetaa) * (1.0 - alpha)












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






