






import unittest

import numpy as np
import timeout_decorator  # noqa

from transformers import MBartConfig, is_flax_available
from transformers.testing_utils import require_flax, require_sentencepiece, require_tokenizers, slow
from transformers.utils import cached_property

from ...generation.test_flax_utils import FlaxGenerationTesterMixin
from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor


if is_flax_available():
					import os

					# The slow tests are often failing with OOM error on GPU
					# This makes JAX allocate exactly what is needed on demand, and deallocate memory that is no longer needed
					# but will be slower as stated here https://jax.readthedocs.io/en/latest/gpu_memory_allocation.html
					__snake_case     :     Dict       =  "platform"

					import jax
					import jax.numpy as jnp

					from transformers import AutoTokenizer
					from transformers.models.mbart.modeling_flax_mbart import (
					    FlaxMBartForConditionalGeneration,
					    FlaxMBartForQuestionAnswering,
					    FlaxMBartForSequenceClassification,
					    FlaxMBartModel,
					    shift_tokens_right,
					)







def 						_UpperCamelCase (     UpperCamelCase_							:       Optional[int]     ,							UpperCamelCase_							:       int     ,							UpperCamelCase_							:       Union[str, Any]=None     ,							UpperCamelCase_							:       Optional[int]=None     ,							UpperCamelCase_							:       Tuple=None     ,							UpperCamelCase_							:       List[Any]=None     ,							UpperCamelCase_							:       Any=None     ,							UpperCamelCase_							:       Union[str, Any]=None     ,							)	-> List[str]:

						"""simple docstring"""



						if attention_mask is None:
												lowerCAmelCase__         =    np.where(input_ids != config.pad_token_id     ,							1     ,							0		)
						if decoder_attention_mask is None:
												lowerCAmelCase__         =    np.where(decoder_input_ids != config.pad_token_id     ,							1     ,							0		)
						if head_mask is None:
												lowerCAmelCase__         =    np.ones((config.encoder_layers, config.encoder_attention_heads)		)
						if decoder_head_mask is None:
												lowerCAmelCase__         =    np.ones((config.decoder_layers, config.decoder_attention_heads)		)
						if cross_attn_head_mask is None:
												lowerCAmelCase__         =    np.ones((config.decoder_layers, config.decoder_attention_heads)		)
						return {
						    "input_ids": input_ids,
						    "decoder_input_ids": decoder_input_ids,
						    "attention_mask": attention_mask,
						    "decoder_attention_mask": decoder_attention_mask,
						}


class      __SCREAMING_SNAKE_CASE       ( unittest.TestCase):






						def __init__(						self  ,    _UpperCamelCase  ,    _UpperCamelCase=13  ,    _UpperCamelCase=7  ,    _UpperCamelCase=True  ,    _UpperCamelCase=False  ,    _UpperCamelCase=99  ,    _UpperCamelCase=16  ,    _UpperCamelCase=2  ,    _UpperCamelCase=4  ,    _UpperCamelCase=4  ,    _UpperCamelCase="gelu"  ,    _UpperCamelCase=0.1  ,    _UpperCamelCase=0.1  ,    _UpperCamelCase=32  ,    _UpperCamelCase=2  ,    _UpperCamelCase=1  ,    _UpperCamelCase=0  ,    _UpperCamelCase=2  ,    _UpperCamelCase=0.02  ,    ):






												"""simple docstring"""
												lowerCAmelCase__         =    parent
												lowerCAmelCase__         =    batch_size
												lowerCAmelCase__         =    seq_length
												lowerCAmelCase__         =    is_training
												lowerCAmelCase__         =    use_labels
												lowerCAmelCase__         =    vocab_size
												lowerCAmelCase__         =    hidden_size
												lowerCAmelCase__         =    num_hidden_layers
												lowerCAmelCase__         =    num_attention_heads
												lowerCAmelCase__         =    intermediate_size
												lowerCAmelCase__         =    hidden_act
												lowerCAmelCase__         =    hidden_dropout_prob
												lowerCAmelCase__         =    attention_probs_dropout_prob
												lowerCAmelCase__         =    max_position_embeddings
												lowerCAmelCase__         =    eos_token_id
												lowerCAmelCase__         =    pad_token_id
												lowerCAmelCase__         =    bos_token_id
												lowerCAmelCase__         =    decoder_start_token_id
												lowerCAmelCase__         =    initializer_range






						def    UpperCamelCase__   (						self ):






												"""simple docstring"""
												lowerCAmelCase__         =    np.clip(ids_tensor([self.batch_size, self.seq_length - 1]  ,    self.vocab_size )  ,    3  ,    self.vocab_size )
												lowerCAmelCase__         =    np.concatenate((input_ids, 2 * np.ones((self.batch_size, 1)  ,    dtype=np.intaa ))  ,    -1 )

												lowerCAmelCase__         =    shift_tokens_right(_UpperCamelCase  ,    1 )

												lowerCAmelCase__         =    MBartConfig(
												    vocab_size=self.vocab_size  ,    d_model=self.hidden_size  ,    encoder_layers=self.num_hidden_layers  ,    decoder_layers=self.num_hidden_layers  ,    encoder_attention_heads=self.num_attention_heads  ,    decoder_attention_heads=self.num_attention_heads  ,    encoder_ffn_dim=self.intermediate_size  ,    decoder_ffn_dim=self.intermediate_size  ,    dropout=self.hidden_dropout_prob  ,    attention_dropout=self.attention_probs_dropout_prob  ,    max_position_embeddings=self.max_position_embeddings  ,    eos_token_id=self.eos_token_id  ,    bos_token_id=self.bos_token_id  ,    pad_token_id=self.pad_token_id  ,    decoder_start_token_id=self.decoder_start_token_id  ,    initializer_range=self.initializer_range  ,    use_cache=_UpperCamelCase  ,    )
												lowerCAmelCase__         =    prepare_mbart_inputs_dict(_UpperCamelCase  ,    _UpperCamelCase  ,    _UpperCamelCase )
												return config, inputs_dict






						def    UpperCamelCase__   (						self ):






												"""simple docstring"""
												lowerCAmelCase__         =    self.prepare_config_and_inputs()
												return config, inputs_dict






						def    UpperCamelCase__   (						self  ,    _UpperCamelCase  ,    _UpperCamelCase  ,    _UpperCamelCase ):






												"""simple docstring"""
												lowerCAmelCase__         =    20
												lowerCAmelCase__         =    model_class_name(_UpperCamelCase )

												lowerCAmelCase__         =    model.encode(inputs_dict['input_ids'] )

												lowerCAmelCase__         =    (
												    inputs_dict['''decoder_input_ids'''],
												    inputs_dict['''decoder_attention_mask'''],
												)

												lowerCAmelCase__         =    model.init_cache(decoder_input_ids.shape[0]  ,    _UpperCamelCase  ,    _UpperCamelCase )
												lowerCAmelCase__         =    jnp.ones((decoder_input_ids.shape[0], max_decoder_length)  ,    dtype='i4' )

												lowerCAmelCase__         =    jnp.broadcast_to(
												    jnp.arange(decoder_input_ids.shape[-1] - 1 )[None, :]  ,    (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)  ,    )
												lowerCAmelCase__         =    model.decode(
												    decoder_input_ids[:, :-1]  ,    _UpperCamelCase  ,    decoder_attention_mask=_UpperCamelCase  ,    past_key_values=_UpperCamelCase  ,    decoder_position_ids=_UpperCamelCase  ,    )

												lowerCAmelCase__         =    jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]  ,    dtype='i4' )
												lowerCAmelCase__         =    model.decode(
												    decoder_input_ids[:, -1:]  ,    _UpperCamelCase  ,    decoder_attention_mask=_UpperCamelCase  ,    past_key_values=outputs_cache.past_key_values  ,    decoder_position_ids=_UpperCamelCase  ,    )

												lowerCAmelCase__         =    model.decode(_UpperCamelCase  ,    _UpperCamelCase )

												lowerCAmelCase__         =    np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5]) ) )
												self.parent.assertTrue(diff < 1E-3  ,    msg=F"Max diff is {diff}" )







						def    UpperCamelCase__   (						self  ,    _UpperCamelCase  ,    _UpperCamelCase  ,    _UpperCamelCase ):






												"""simple docstring"""
												lowerCAmelCase__         =    20
												lowerCAmelCase__         =    model_class_name(_UpperCamelCase )

												lowerCAmelCase__         =    model.encode(inputs_dict['input_ids'] )

												lowerCAmelCase__         =    (
												    inputs_dict['''decoder_input_ids'''],
												    inputs_dict['''decoder_attention_mask'''],
												)

												lowerCAmelCase__         =    jnp.concatenate(
												    [
												        decoder_attention_mask,
												        jnp.zeros((decoder_attention_mask.shape[0], max_decoder_length - decoder_attention_mask.shape[1]) ),
												    ]  ,    axis=-1  ,    )

												lowerCAmelCase__         =    model.init_cache(decoder_input_ids.shape[0]  ,    _UpperCamelCase  ,    _UpperCamelCase )
												lowerCAmelCase__         =    jnp.broadcast_to(
												    jnp.arange(decoder_input_ids.shape[-1] - 1 )[None, :]  ,    (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)  ,    )

												lowerCAmelCase__         =    model.decode(
												    decoder_input_ids[:, :-1]  ,    _UpperCamelCase  ,    decoder_attention_mask=_UpperCamelCase  ,    past_key_values=_UpperCamelCase  ,    decoder_position_ids=_UpperCamelCase  ,    )
												lowerCAmelCase__         =    jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]  ,    dtype='i4' )
												lowerCAmelCase__         =    model.decode(
												    decoder_input_ids[:, -1:]  ,    _UpperCamelCase  ,    past_key_values=outputs_cache.past_key_values  ,    decoder_attention_mask=_UpperCamelCase  ,    decoder_position_ids=_UpperCamelCase  ,    )

												lowerCAmelCase__         =    model.decode(_UpperCamelCase  ,    _UpperCamelCase  ,    decoder_attention_mask=_UpperCamelCase )

												lowerCAmelCase__         =    np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5]) ) )
												self.parent.assertTrue(diff < 1E-3  ,    msg=F"Max diff is {diff}" )




@require_flax
class      __SCREAMING_SNAKE_CASE       ( unittest.TestCase):
						_SCREAMING_SNAKE_CASE						:							Dict				=       99






						def    UpperCamelCase__   (						self ):






												"""simple docstring"""
												lowerCAmelCase__         =    np.array(
												    [
												        [71, 82, 18, 33, 46, 91, 2],
												        [68, 34, 26, 58, 30, 82, 2],
												        [5, 97, 17, 39, 94, 40, 2],
												        [76, 83, 94, 25, 70, 78, 2],
												        [87, 59, 41, 35, 48, 66, 2],
												        [55, 13, 16, 58, 5, 2, 1],  # note padding
												        [64, 27, 31, 51, 12, 75, 2],
												        [52, 64, 86, 17, 83, 39, 2],
												        [48, 61, 9, 24, 71, 82, 2],
												        [26, 1, 60, 48, 22, 13, 2],
												        [21, 5, 62, 28, 14, 76, 2],
												        [45, 98, 37, 86, 59, 48, 2],
												        [70, 70, 50, 9, 28, 0, 2],
												    ]  ,    dtype=np.intaa  ,    )

												lowerCAmelCase__         =    input_ids.shape[0]
												lowerCAmelCase__         =    MBartConfig(
												    vocab_size=self.vocab_size  ,    d_model=24  ,    encoder_layers=2  ,    decoder_layers=2  ,    encoder_attention_heads=2  ,    decoder_attention_heads=2  ,    encoder_ffn_dim=32  ,    decoder_ffn_dim=32  ,    max_position_embeddings=48  ,    eos_token_id=2  ,    pad_token_id=1  ,    bos_token_id=0  ,    )
												return config, input_ids, batch_size






						def    UpperCamelCase__   (						self ):






												"""simple docstring"""
												lowerCAmelCase__         =    self._get_config_and_data()
												lowerCAmelCase__         =    FlaxMBartForSequenceClassification(_UpperCamelCase )
												lowerCAmelCase__         =    model(input_ids=_UpperCamelCase  ,    decoder_input_ids=_UpperCamelCase )
												lowerCAmelCase__         =    (batch_size, config.num_labels)
												self.assertEqual(outputs['logits'].shape  ,    _UpperCamelCase )






						def    UpperCamelCase__   (						self ):






												"""simple docstring"""
												lowerCAmelCase__         =    self._get_config_and_data()
												lowerCAmelCase__         =    FlaxMBartForQuestionAnswering(_UpperCamelCase )
												lowerCAmelCase__         =    model(input_ids=_UpperCamelCase )

												self.assertEqual(outputs['start_logits'].shape  ,    input_ids.shape )
												self.assertEqual(outputs['end_logits'].shape  ,    input_ids.shape )






						def    UpperCamelCase__   (						self ):






												"""simple docstring"""
												lowerCAmelCase__         =    self._get_config_and_data()
												lowerCAmelCase__         =    FlaxMBartForConditionalGeneration(_UpperCamelCase )
												lowerCAmelCase__         =    lm_model(input_ids=_UpperCamelCase )
												lowerCAmelCase__         =    (batch_size, input_ids.shape[1], config.vocab_size)
												self.assertEqual(outputs['logits'].shape  ,    _UpperCamelCase )






						def    UpperCamelCase__   (						self ):






												"""simple docstring"""
												lowerCAmelCase__         =    MBartConfig(
												    vocab_size=self.vocab_size  ,    d_model=14  ,    encoder_layers=2  ,    decoder_layers=2  ,    encoder_attention_heads=2  ,    decoder_attention_heads=2  ,    encoder_ffn_dim=8  ,    decoder_ffn_dim=8  ,    max_position_embeddings=48  ,    )
												lowerCAmelCase__         =    FlaxMBartForConditionalGeneration(_UpperCamelCase )
												lowerCAmelCase__         =    np.array([[71, 82, 18, 33, 46, 91, 2], [68, 34, 26, 58, 30, 2, 1]]  ,    dtype=np.intaa )
												lowerCAmelCase__         =    np.array([[82, 71, 82, 18, 2], [58, 68, 2, 1, 1]]  ,    dtype=np.intaa )
												lowerCAmelCase__         =    lm_model(input_ids=_UpperCamelCase  ,    decoder_input_ids=_UpperCamelCase )
												lowerCAmelCase__         =    (*summary.shape, config.vocab_size)
												self.assertEqual(outputs['logits'].shape  ,    _UpperCamelCase )







						def    UpperCamelCase__   (						self ):






												"""simple docstring"""
												lowerCAmelCase__         =    np.array([[71, 82, 18, 33, 2, 1, 1], [68, 34, 26, 58, 30, 82, 2]]  ,    dtype=np.intaa )
												lowerCAmelCase__         =    shift_tokens_right(_UpperCamelCase  ,    1 )
												lowerCAmelCase__         =    np.equal(_UpperCamelCase  ,    1 ).astype(np.floataa ).sum()
												lowerCAmelCase__         =    np.equal(_UpperCamelCase  ,    1 ).astype(np.floataa ).sum()
												self.assertEqual(shifted.shape  ,    input_ids.shape )
												self.assertEqual(_UpperCamelCase  ,    n_pad_before - 1 )
												self.assertTrue(np.equal(shifted[:, 0]  ,    2 ).all() )




@require_flax
class      __SCREAMING_SNAKE_CASE       ( _a		,       unittest.TestCase		,       _a):
						_SCREAMING_SNAKE_CASE						:							Optional[Any]				=       True
						_SCREAMING_SNAKE_CASE						:							Tuple				=       (
						    (
						        FlaxMBartModel,
						        FlaxMBartForConditionalGeneration,
						        FlaxMBartForSequenceClassification,
						        FlaxMBartForQuestionAnswering,
						    )
						    if is_flax_available()
						    else ()
						)
						_SCREAMING_SNAKE_CASE						:							Union[str, Any]				=       (FlaxMBartForConditionalGeneration,) if is_flax_available() else ()






						def    UpperCamelCase__   (						self ):






												"""simple docstring"""
												lowerCAmelCase__         =    FlaxMBartModelTester(self )






						def    UpperCamelCase__   (						self ):






												"""simple docstring"""
												lowerCAmelCase__         =    self.model_tester.prepare_config_and_inputs()
												for model_class in self.all_model_classes:
																		self.model_tester.check_use_cache_forward(_UpperCamelCase  ,    _UpperCamelCase  ,    _UpperCamelCase )






						def    UpperCamelCase__   (						self ):






												"""simple docstring"""
												lowerCAmelCase__         =    self.model_tester.prepare_config_and_inputs()
												for model_class in self.all_model_classes:
																		self.model_tester.check_use_cache_forward_with_attn_mask(_UpperCamelCase  ,    _UpperCamelCase  ,    _UpperCamelCase )






						def    UpperCamelCase__   (						self ):






												"""simple docstring"""
												lowerCAmelCase__         =    self.model_tester.prepare_config_and_inputs_for_common()

												for model_class in self.all_model_classes:
																		with self.subTest(model_class.__name__ ):
																								lowerCAmelCase__         =    self._prepare_for_class(_UpperCamelCase  ,    _UpperCamelCase )
																								lowerCAmelCase__         =    model_class(_UpperCamelCase )

																								@jax.jit
																								def encode_jitted(_UpperCamelCase  ,    _UpperCamelCase=None  ,    **_UpperCamelCase ):
																														return model.encode(input_ids=_UpperCamelCase  ,    attention_mask=_UpperCamelCase )

																								with self.subTest('JIT Enabled' ):
																														lowerCAmelCase__         =    encode_jitted(**_UpperCamelCase ).to_tuple()

																								with self.subTest('JIT Disabled' ):
																														with jax.disable_jit():
																																				lowerCAmelCase__         =    encode_jitted(**_UpperCamelCase ).to_tuple()

																								self.assertEqual(len(_UpperCamelCase )  ,    len(_UpperCamelCase ) )
																								for jitted_output, output in zip(_UpperCamelCase  ,    _UpperCamelCase ):
																														self.assertEqual(jitted_output.shape  ,    output.shape )






						def    UpperCamelCase__   (						self ):






												"""simple docstring"""
												lowerCAmelCase__         =    self.model_tester.prepare_config_and_inputs_for_common()

												for model_class in self.all_model_classes:
																		with self.subTest(model_class.__name__ ):
																								lowerCAmelCase__         =    model_class(_UpperCamelCase )
																								lowerCAmelCase__         =    model.encode(inputs_dict['input_ids']  ,    inputs_dict['attention_mask'] )

																								lowerCAmelCase__         =    {
																								    '''decoder_input_ids''': inputs_dict['''decoder_input_ids'''],
																								    '''decoder_attention_mask''': inputs_dict['''decoder_attention_mask'''],
																								    '''encoder_outputs''': encoder_outputs,
																								}

																								@jax.jit
																								def decode_jitted(_UpperCamelCase  ,    _UpperCamelCase  ,    _UpperCamelCase ):
																														return model.decode(
																														    decoder_input_ids=_UpperCamelCase  ,    decoder_attention_mask=_UpperCamelCase  ,    encoder_outputs=_UpperCamelCase  ,    )

																								with self.subTest('JIT Enabled' ):
																														lowerCAmelCase__         =    decode_jitted(**_UpperCamelCase ).to_tuple()

																								with self.subTest('JIT Disabled' ):
																														with jax.disable_jit():
																																				lowerCAmelCase__         =    decode_jitted(**_UpperCamelCase ).to_tuple()

																								self.assertEqual(len(_UpperCamelCase )  ,    len(_UpperCamelCase ) )
																								for jitted_output, output in zip(_UpperCamelCase  ,    _UpperCamelCase ):
																														self.assertEqual(jitted_output.shape  ,    output.shape )







						@slow
						def    UpperCamelCase__   (						self ):






												"""simple docstring"""
												for model_class_name in self.all_model_classes:
																		lowerCAmelCase__         =    model_class_name.from_pretrained('facebook/mbart-large-cc25'  ,    from_pt=_UpperCamelCase )
																		# FlaxMBartForSequenceClassification expects eos token in input_ids
																		lowerCAmelCase__         =    np.ones((1, 1) ) * model.config.eos_token_id
																		lowerCAmelCase__         =    model(_UpperCamelCase )
																		self.assertIsNotNone(_UpperCamelCase )




@require_flax
@require_sentencepiece
@require_tokenizers
class      __SCREAMING_SNAKE_CASE       ( unittest.TestCase):
						_SCREAMING_SNAKE_CASE						:							str				=       [
						    " UN Chief Says There Is No Military Solution in Syria",
						]
						_SCREAMING_SNAKE_CASE						:							Dict				=       [
						    "Şeful ONU declară că nu există o soluţie militară în Siria",
						]
						_SCREAMING_SNAKE_CASE						:							List[str]				=       "facebook/mbart-large-en-ro"






						@cached_property
						def    UpperCamelCase__   (						self ):






												"""simple docstring"""
												return AutoTokenizer.from_pretrained(self.model_name )






						@cached_property
						def    UpperCamelCase__   (						self ):






												"""simple docstring"""
												lowerCAmelCase__         =    FlaxMBartForConditionalGeneration.from_pretrained(self.model_name  ,    from_pt=_UpperCamelCase )
												return model






						def    UpperCamelCase__   (						self  ,    **_UpperCamelCase ):






												"""simple docstring"""
												lowerCAmelCase__         =    self.translate_src_text(**_UpperCamelCase )
												self.assertListEqual(self.expected_text  ,    _UpperCamelCase )






						def    UpperCamelCase__   (						self  ,    **_UpperCamelCase ):






												"""simple docstring"""
												lowerCAmelCase__         =    self.tokenizer(self.src_text  ,    **_UpperCamelCase  ,    return_tensors='np' )
												lowerCAmelCase__         =    self.model.generate(
												    model_inputs.input_ids  ,    attention_mask=model_inputs.attention_mask  ,    decoder_start_token_id=self.tokenizer.lang_code_to_id['ro_RO']  ,    early_stopping=_UpperCamelCase  ,    num_beams=2  ,    ).sequences
												lowerCAmelCase__         =    self.tokenizer.batch_decode(_UpperCamelCase  ,    skip_special_tokens=_UpperCamelCase )
												return generated_words







						@slow
						def    UpperCamelCase__   (						self ):






												"""simple docstring"""
												self._assert_generated_batch_equal_expected()









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


     """simple docstring"""






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

     def 					lowerCamelCase__					(							self	:						Dict     )		->				Tuple:
          __UpperCAmelCase      :					Tuple    				=     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]     )

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

          __UpperCAmelCase      :					int    				=     self.get_config()
          return config, pixel_values, labels

     def 					lowerCamelCase__					(							self	:						str     )		->				Dict:
          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	:						Any				,					snake_case	:						Tuple				,					snake_case	:						Tuple				,					snake_case	:						Optional[int]     )		->				Union[str, Any]:
          __UpperCAmelCase      :					Union[str, Any]    				=     EfficientNetModel(config=snake_case     )
          model.to(snake_case     )
          model.eval()
          __UpperCAmelCase      :					Union[str, 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 					lowerCamelCase__					(							self	:						List[str]				,					snake_case	:						Optional[int]				,					snake_case	:						List[str]				,					snake_case	:						List[str]     )		->				Optional[int]:
          __UpperCAmelCase      :					List[str]    				=     EfficientNetForImageClassification(snake_case     )
          model.to(snake_case     )
          model.eval()
          __UpperCAmelCase      :					Any    				=     model(snake_case				,					labels=snake_case     )
          self.parent.assertEqual(result.logits.shape				,					(self.batch_size, self.num_labels)     )






     def 					lowerCamelCase__					(							self	:						str     )		->				Tuple:
          __UpperCAmelCase      :					List[Any]    				=     self.prepare_config_and_inputs()
          __UpperCAmelCase				,  __UpperCAmelCase				,  __UpperCAmelCase      :					Union[str, Any]    				=     config_and_inputs
          __UpperCAmelCase      :					Union[str, Any]    				=     {'''pixel_values''': pixel_values}
          return config, inputs_dict



@require_torch
class       a							(						_a      ,    _a      ,    unittest.TestCase			):


     """simple docstring"""






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

     SCREAMING_SNAKE_CASE			:					Union[str, Any]				  =  False
     SCREAMING_SNAKE_CASE			:					Optional[int]				  =  False
     SCREAMING_SNAKE_CASE			:					Optional[int]				  =  False
     SCREAMING_SNAKE_CASE			:					List[Any]				  =  False
     SCREAMING_SNAKE_CASE			:					List[str]				  =  False

     def 					lowerCamelCase__					(							self	:						List[str]     )		->				List[str]:
          __UpperCAmelCase      :					Dict    				=     EfficientNetModelTester(self     )
          __UpperCAmelCase      :					Optional[Any]    				=     ConfigTester(
              self				,					config_class=snake_case				,					has_text_modality=snake_case				,					hidden_size=37     )

     def 					lowerCamelCase__					(							self	:						List[str]     )		->				str:
          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	:						Dict     )		->				str:
          return

     @unittest.skip(reason='''EfficientNet does not use inputs_embeds'''     )
     def 					lowerCamelCase__					(							self	:						List[Any]     )		->				Optional[int]:
          pass

     @unittest.skip(reason='''EfficientNet does not support input and output embeddings'''     )
     def 					lowerCamelCase__					(							self	:						List[str]     )		->				Dict:
          pass

     @unittest.skip(reason='''EfficientNet does not use feedforward chunking'''     )
     def 					lowerCamelCase__					(							self	:						Union[str, Any]     )		->				Optional[int]:
          pass

     def 					lowerCamelCase__					(							self	:						List[str]     )		->				Optional[Any]:
          __UpperCAmelCase				,  __UpperCAmelCase      :					List[str]    				=     self.model_tester.prepare_config_and_inputs_for_common()

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

               __UpperCAmelCase      :					Union[str, Any]    				=     ['''pixel_values''']
               self.assertListEqual(arg_names[:1]				,					snake_case     )

     def 					lowerCamelCase__					(							self	:						int     )		->				List[str]:
          __UpperCAmelCase      :					Union[str, Any]    				=     self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*snake_case     )

     def 					lowerCamelCase__					(							self	:						int     )		->				str:
          def check_hidden_states_output(snake_case	:						Union[str, Any]				,					snake_case	:						str				,					snake_case	:						Tuple     ):
               __UpperCAmelCase      :					List[str]    				=     model_class(snake_case     )
               model.to(snake_case     )
               model.eval()

               with torch.no_grad():
                    __UpperCAmelCase      :					int    				=     model(**self._prepare_for_class(snake_case				,					snake_case     )     )

               __UpperCAmelCase      :					Optional[int]    				=     outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states
               __UpperCAmelCase      :					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]				,					)

          __UpperCAmelCase				,  __UpperCAmelCase      :					Union[str, Any]    				=     self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
               __UpperCAmelCase      :					int    				=     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"]
               __UpperCAmelCase      :					Union[str, Any]    				=     True

               check_hidden_states_output(snake_case				,					snake_case				,					snake_case     )

     def 					lowerCamelCase__					(							self	:						str     )		->				Any:
          __UpperCAmelCase      :					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	:						List[Any]     )		->				Tuple:
          pass

     @slow
     def 					lowerCamelCase__					(							self	:						Optional[int]     )		->				List[str]:
          for model_name in EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               __UpperCAmelCase      :					str    				=     EfficientNetModel.from_pretrained(snake_case     )
               self.assertIsNotNone(snake_case     )






     @is_pipeline_test
     @require_vision
     @slow
     def 					lowerCamelCase__					(							self	:						Union[str, Any]     )		->				List[str]:
          super().test_pipeline_image_classification()




def       _a      (		):





     '''simple docstring'''






     __UpperCAmelCase      :					Any    				=     Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''    )
     return image



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


     """simple docstring"""






     @cached_property
     def 					lowerCamelCase__					(							self	:						List[str]     )		->				Dict:
          return AutoImageProcessor.from_pretrained('''google/efficientnet-b7'''     ) if is_vision_available() else None






     @slow
     def 					lowerCamelCase__					(							self	:						str     )		->				Any:
          __UpperCAmelCase      :					Tuple    				=     EfficientNetForImageClassification.from_pretrained('''google/efficientnet-b7'''     ).to(snake_case     )

          __UpperCAmelCase      :					List[str]    				=     self.default_image_processor
          __UpperCAmelCase      :					List[Any]    				=     prepare_img()
          __UpperCAmelCase      :					Union[str, Any]    				=     image_processor(images=snake_case				,					return_tensors='''pt'''     ).to(snake_case     )

          # forward pass
          with torch.no_grad():
               __UpperCAmelCase      :					Optional[Any]    				=     model(**snake_case     )

          # verify the logits
          __UpperCAmelCase      :					Any    				=     torch.Size((1, 1000)     )
          self.assertEqual(outputs.logits.shape				,					snake_case     )

          __UpperCAmelCase      :					Dict    				=     torch.tensor([0.0_001, 0.0_002, 0.0_002]     ).to(snake_case     )
          self.assertTrue(torch.allclose(outputs.logits[0, :3]				,					snake_case				,					atol=1E-4     )     )