


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





							'''simple docstring'''


							def __init__(					self					,      __snake_case					,      __snake_case=13					,      __snake_case=32					,      __snake_case=3					,      __snake_case=[3, 3, 5]					,      __snake_case=[32, 16, 24]					,      __snake_case=[16, 24, 40]					,      __snake_case=[1, 1, 2]					,      __snake_case=[1, 1, 2]					,      __snake_case=[1, 6, 6]					,      __snake_case=True					,      __snake_case=True					,      __snake_case=37					,      __snake_case="gelu"					,      __snake_case=10					,      ):
											_SCREAMING_SNAKE_CASE				: int  	=   parent
											_SCREAMING_SNAKE_CASE				: Any  	=   batch_size
											_SCREAMING_SNAKE_CASE				: List[Any]  	=   image_size
											_SCREAMING_SNAKE_CASE				: Optional[Any]  	=   num_channels
											_SCREAMING_SNAKE_CASE				: List[str]  	=   kernel_sizes
											_SCREAMING_SNAKE_CASE				: Optional[Any]  	=   in_channels
											_SCREAMING_SNAKE_CASE				: Tuple  	=   out_channels
											_SCREAMING_SNAKE_CASE				: List[Any]  	=   strides
											_SCREAMING_SNAKE_CASE				: Any  	=   num_block_repeats
											_SCREAMING_SNAKE_CASE				: List[Any]  	=   expand_ratios
											_SCREAMING_SNAKE_CASE				: str  	=   is_training
											_SCREAMING_SNAKE_CASE				: int  	=   hidden_act
											_SCREAMING_SNAKE_CASE				: Union[str, Any]  	=   num_labels
											_SCREAMING_SNAKE_CASE				: Optional[int]  	=   use_labels






							def UpperCAmelCase_			(					self						):
											_SCREAMING_SNAKE_CASE				: List[Any]  	=   floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

											_SCREAMING_SNAKE_CASE				: List[str]  	=   None
											if self.use_labels:
															_SCREAMING_SNAKE_CASE				: Union[str, Any]  	=   ids_tensor([self.batch_size]					,      self.num_labels						)

											_SCREAMING_SNAKE_CASE				: Optional[int]  	=   self.get_config()
											return config, pixel_values, labels






							def UpperCAmelCase_			(					self						):
											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 UpperCAmelCase_			(					self					,      __snake_case					,      __snake_case					,      __snake_case						):
											_SCREAMING_SNAKE_CASE				: Dict  	=   EfficientNetModel(config=__snake_case						)
											model.to(__snake_case						)
											model.eval()
											_SCREAMING_SNAKE_CASE				: Any  	=   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 UpperCAmelCase_			(					self					,      __snake_case					,      __snake_case					,      __snake_case						):
											_SCREAMING_SNAKE_CASE				: Dict  	=   EfficientNetForImageClassification(__snake_case						)
											model.to(__snake_case						)
											model.eval()
											_SCREAMING_SNAKE_CASE				: Any  	=   model(__snake_case					,      labels=__snake_case						)
											self.parent.assertEqual(result.logits.shape					,      (self.batch_size, self.num_labels)						)






							def UpperCAmelCase_			(					self						):
											_SCREAMING_SNAKE_CASE				: Optional[Any]  	=   self.prepare_config_and_inputs()
											_SCREAMING_SNAKE_CASE	, _SCREAMING_SNAKE_CASE	, _SCREAMING_SNAKE_CASE				: int  	=   config_and_inputs
											_SCREAMING_SNAKE_CASE				: Union[str, Any]  	=   {"""pixel_values""": pixel_values}
											return config, inputs_dict





@require_torch
class 					lowercase__						(		_snake_case  ,  _snake_case  ,  unittest.TestCase      ):





							'''simple docstring'''


							A_							:   Optional[Any]   			=						(EfficientNetModel, EfficientNetForImageClassification) if is_torch_available() else ()
							A_							:   List[Any]   			=						(
							    {"""feature-extraction""": EfficientNetModel, """image-classification""": EfficientNetForImageClassification}
							    if is_torch_available()
							    else {}
							)

							A_							:   Optional[Any]   			=						False
							A_							:   int   			=						False
							A_							:   Dict   			=						False
							A_							:   List[str]   			=						False
							A_							:   Optional[Any]   			=						False






							def UpperCAmelCase_			(					self						):
											_SCREAMING_SNAKE_CASE				: List[Any]  	=   EfficientNetModelTester(self						)
											_SCREAMING_SNAKE_CASE				: str  	=   ConfigTester(
											    self					,      config_class=__snake_case					,      has_text_modality=__snake_case					,      hidden_size=37						)






							def UpperCAmelCase_			(					self						):
											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 UpperCAmelCase_			(					self						):
											return






							@unittest.skip(reason="""EfficientNet does not use inputs_embeds"""						)
							def UpperCAmelCase_			(					self						):
											pass






							@unittest.skip(reason="""EfficientNet does not support input and output embeddings"""						)
							def UpperCAmelCase_			(					self						):
											pass






							@unittest.skip(reason="""EfficientNet does not use feedforward chunking"""						)
							def UpperCAmelCase_			(					self						):
											pass






							def UpperCAmelCase_			(					self						):
											_SCREAMING_SNAKE_CASE	, _SCREAMING_SNAKE_CASE				: Optional[int]  	=   self.model_tester.prepare_config_and_inputs_for_common()

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

															_SCREAMING_SNAKE_CASE				: Union[str, Any]  	=   ["""pixel_values"""]
															self.assertListEqual(arg_names[:1]					,      __snake_case						)






							def UpperCAmelCase_			(					self						):
											_SCREAMING_SNAKE_CASE				: List[str]  	=   self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*__snake_case						)






							def UpperCAmelCase_			(					self						):
											def check_hidden_states_output(__snake_case					,      __snake_case					,      __snake_case						):
															_SCREAMING_SNAKE_CASE				: Union[str, Any]  	=   model_class(__snake_case						)
															model.to(__snake_case						)
															model.eval()

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

															_SCREAMING_SNAKE_CASE				: List[str]  	=   outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states
															_SCREAMING_SNAKE_CASE				: Union[str, Any]  	=   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]					,      )

											_SCREAMING_SNAKE_CASE	, _SCREAMING_SNAKE_CASE				: Optional[int]  	=   self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
															_SCREAMING_SNAKE_CASE				: List[str]  	=   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"]
															_SCREAMING_SNAKE_CASE				: int  	=   True

															check_hidden_states_output(__snake_case					,      __snake_case					,      __snake_case						)






							def UpperCAmelCase_			(					self						):
											_SCREAMING_SNAKE_CASE				: Dict  	=   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 UpperCAmelCase_			(					self						):
											pass






							@slow
							def UpperCAmelCase_			(					self						):
											for model_name in EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															_SCREAMING_SNAKE_CASE				: Tuple  	=   EfficientNetModel.from_pretrained(__snake_case						)
															self.assertIsNotNone(__snake_case						)






							@is_pipeline_test
							@require_vision
							@slow
							def UpperCAmelCase_			(					self						):
											super().test_pipeline_image_classification()







def     snake_case_     (						):







				"""simple docstring"""





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







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





							'''simple docstring'''


							@cached_property
							def UpperCAmelCase_			(					self						):
											return AutoImageProcessor.from_pretrained("""google/efficientnet-b7"""						) if is_vision_available() else None






							@slow
							def UpperCAmelCase_			(					self						):
											_SCREAMING_SNAKE_CASE				: List[Any]  	=   EfficientNetForImageClassification.from_pretrained("""google/efficientnet-b7"""						).to(__snake_case						)

											_SCREAMING_SNAKE_CASE				: Dict  	=   self.default_image_processor
											_SCREAMING_SNAKE_CASE				: Union[str, Any]  	=   prepare_img()
											_SCREAMING_SNAKE_CASE				: str  	=   image_processor(images=__snake_case					,      return_tensors="""pt"""						).to(__snake_case						)

											# forward pass
											with torch.no_grad():
															_SCREAMING_SNAKE_CASE				: Tuple  	=   model(**__snake_case						)

											# verify the logits
											_SCREAMING_SNAKE_CASE				: List[Any]  	=   torch.Size((1, 1000)						)
											self.assertEqual(outputs.logits.shape					,      __snake_case						)

											_SCREAMING_SNAKE_CASE				: Optional[Any]  	=   torch.tensor([0.0001, 0.0002, 0.0002]						).to(__snake_case						)
											self.assertTrue(torch.allclose(outputs.logits[0, :3]					,      __snake_case					,      atol=1e-4						)						)








'''simple docstring'''


from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


UpperCAmelCase_	:     Any							     =	{
    'configuration_musicgen': [
        'MUSICGEN_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'MusicgenConfig',
        'MusicgenDecoderConfig',
    ],
    'processing_musicgen': ['MusicgenProcessor'],
}

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				UpperCAmelCase_	:     Any							     =	[
				    'MUSICGEN_PRETRAINED_MODEL_ARCHIVE_LIST',
				    'MusicgenForConditionalGeneration',
				    'MusicgenForCausalLM',
				    'MusicgenModel',
				    'MusicgenPreTrainedModel',
				]

if TYPE_CHECKING:
				from .configuration_musicgen import (
				    MUSICGEN_PRETRAINED_CONFIG_ARCHIVE_MAP,
				    MusicgenConfig,
				    MusicgenDecoderConfig,
				)
				from .processing_musicgen import MusicgenProcessor

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_musicgen import (
								    MUSICGEN_PRETRAINED_MODEL_ARCHIVE_LIST,
								    MusicgenForCausalLM,
								    MusicgenForConditionalGeneration,
								    MusicgenModel,
								    MusicgenPreTrainedModel,
								)

else:
				import sys

				UpperCAmelCase_	:     Tuple							     =	_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)




