


import unittest

from transformers import ElectraConfig, is_torch_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
    import torch

    from transformers import (
        MODEL_FOR_PRETRAINING_MAPPING,
        ElectraForCausalLM,
        ElectraForMaskedLM,
        ElectraForMultipleChoice,
        ElectraForPreTraining,
        ElectraForQuestionAnswering,
        ElectraForSequenceClassification,
        ElectraForTokenClassification,
        ElectraModel,
    )
    from transformers.models.electra.modeling_electra import ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST







class      _lowercase					:


       """simple docstring"""




       def __init__(  self				:     Dict   , __lowerCamelCase				:     Dict   , __lowerCamelCase				:     int=13   , __lowerCamelCase				:     Optional[int]=7   , __lowerCamelCase				:     Optional[Any]=True   , __lowerCamelCase				:     Union[str, Any]=True   , __lowerCamelCase				:     List[str]=True   , __lowerCamelCase				:     Tuple=True   , __lowerCamelCase				:     Union[str, Any]=99   , __lowerCamelCase				:     Union[str, Any]=32   , __lowerCamelCase				:     Any=5   , __lowerCamelCase				:     List[str]=4   , __lowerCamelCase				:     Optional[Any]=37   , __lowerCamelCase				:     Any="gelu"   , __lowerCamelCase				:     List[Any]=0.1   , __lowerCamelCase				:     Any=0.1   , __lowerCamelCase				:     int=512   , __lowerCamelCase				:     str=16   , __lowerCamelCase				:     List[str]=2   , __lowerCamelCase				:     Tuple=0.0_2   , __lowerCamelCase				:     Any=3   , __lowerCamelCase				:     Dict=4   , __lowerCamelCase				:     List[str]=None   , ):


             '''simple docstring'''



             lowerCamelCase__						:							int       =    parent
             lowerCamelCase__						:							List[Any]       =    batch_size
             lowerCamelCase__						:							List[str]       =    seq_length
             lowerCamelCase__						:							Union[str, Any]       =    is_training
             lowerCamelCase__						:							Any       =    use_input_mask
             lowerCamelCase__						:							int       =    use_token_type_ids
             lowerCamelCase__						:							List[str]       =    use_labels
             lowerCamelCase__						:							str       =    vocab_size
             lowerCamelCase__						:							Tuple       =    hidden_size
             lowerCamelCase__						:							Optional[Any]       =    num_hidden_layers
             lowerCamelCase__						:							Any       =    num_attention_heads
             lowerCamelCase__						:							Optional[Any]       =    intermediate_size
             lowerCamelCase__						:							Tuple       =    hidden_act
             lowerCamelCase__						:							List[str]       =    hidden_dropout_prob
             lowerCamelCase__						:							Tuple       =    attention_probs_dropout_prob
             lowerCamelCase__						:							Any       =    max_position_embeddings
             lowerCamelCase__						:							Any       =    type_vocab_size
             lowerCamelCase__						:							Tuple       =    type_sequence_label_size
             lowerCamelCase__						:							str       =    initializer_range
             lowerCamelCase__						:							List[Any]       =    num_labels
             lowerCamelCase__						:							List[str]       =    num_choices
             lowerCamelCase__						:							Union[str, Any]       =    scope





       def 		lowerCAmelCase	(  self				:     Any			):


             '''simple docstring'''



             lowerCamelCase__						:							Dict       =    ids_tensor([self.batch_size, self.seq_length]   , self.vocab_size			)

             lowerCamelCase__						:							List[str]       =    None
             if self.use_input_mask:
                   lowerCamelCase__						:							Any       =    random_attention_mask([self.batch_size, self.seq_length]			)

             lowerCamelCase__						:							List[str]       =    None
             if self.use_token_type_ids:
                   lowerCamelCase__						:							Optional[int]       =    ids_tensor([self.batch_size, self.seq_length]   , self.type_vocab_size			)

             lowerCamelCase__						:							Optional[Any]       =    None
             lowerCamelCase__						:							Tuple       =    None
             lowerCamelCase__						:							str       =    None
             if self.use_labels:
                   lowerCamelCase__						:							Optional[int]       =    ids_tensor([self.batch_size]   , self.type_sequence_label_size			)
                   lowerCamelCase__						:							Union[str, Any]       =    ids_tensor([self.batch_size, self.seq_length]   , self.num_labels			)
                   lowerCamelCase__						:							Tuple       =    ids_tensor([self.batch_size]   , self.num_choices			)
                   lowerCamelCase__						:							str       =    ids_tensor([self.batch_size, self.seq_length]   , 1			)

             lowerCamelCase__						:							Optional[Any]       =    self.get_config()

             return (
                 config,
                 input_ids,
                 token_type_ids,
                 input_mask,
                 sequence_labels,
                 token_labels,
                 choice_labels,
                 fake_token_labels,
             )





       def 		lowerCAmelCase	(  self				:     int			):


             '''simple docstring'''



             return ElectraConfig(
                 vocab_size=self.vocab_size   , hidden_size=self.hidden_size   , num_hidden_layers=self.num_hidden_layers   , num_attention_heads=self.num_attention_heads   , intermediate_size=self.intermediate_size   , hidden_act=self.hidden_act   , hidden_dropout_prob=self.hidden_dropout_prob   , attention_probs_dropout_prob=self.attention_probs_dropout_prob   , max_position_embeddings=self.max_position_embeddings   , type_vocab_size=self.type_vocab_size   , is_decoder=__lowerCamelCase   , initializer_range=self.initializer_range   , )





       def 		lowerCAmelCase	(  self				:     Optional[Any]			):


             '''simple docstring'''



             (
                 (
                 lowerCamelCase__
             )       ,  (
                 lowerCamelCase__
             )       ,  (
                 lowerCamelCase__
             )       ,  (
                 lowerCamelCase__
             )       ,  (
                 lowerCamelCase__
             )       ,  (
                 lowerCamelCase__
             )       ,  (
                 lowerCamelCase__
             )       ,  (
                 lowerCamelCase__
             )       ,  
             )						:							int       =    self.prepare_config_and_inputs()

             lowerCamelCase__						:							str       =    True
             lowerCamelCase__						:							Tuple       =    floats_tensor([self.batch_size, self.seq_length, self.hidden_size]			)
             lowerCamelCase__						:							Optional[Any]       =    ids_tensor([self.batch_size, self.seq_length]   , vocab_size=2			)

             return (
                 config,
                 input_ids,
                 token_type_ids,
                 input_mask,
                 sequence_labels,
                 token_labels,
                 choice_labels,
                 encoder_hidden_states,
                 encoder_attention_mask,
             )





       def 		lowerCAmelCase	(  self				:     Optional[Any]   , __lowerCamelCase				:     int   , __lowerCamelCase				:     Union[str, Any]   , __lowerCamelCase				:     Optional[Any]   , __lowerCamelCase				:     Dict   , __lowerCamelCase				:     List[str]   , __lowerCamelCase				:     str   , __lowerCamelCase				:     str   , __lowerCamelCase				:     List[Any]   , ):


             '''simple docstring'''



             lowerCamelCase__						:							Tuple       =    ElectraModel(config=__lowerCamelCase			)
             model.to(__lowerCamelCase			)
             model.eval()
             lowerCamelCase__						:							Optional[int]       =    model(__lowerCamelCase   , attention_mask=__lowerCamelCase   , token_type_ids=__lowerCamelCase			)
             lowerCamelCase__						:							Any       =    model(__lowerCamelCase   , token_type_ids=__lowerCamelCase			)
             lowerCamelCase__						:							Optional[int]       =    model(__lowerCamelCase			)
             self.parent.assertEqual(result.last_hidden_state.shape   , (self.batch_size, self.seq_length, self.hidden_size)			)





       def 		lowerCAmelCase	(  self				:     int   , __lowerCamelCase				:     Any   , __lowerCamelCase				:     str   , __lowerCamelCase				:     Optional[Any]   , __lowerCamelCase				:     Tuple   , __lowerCamelCase				:     Union[str, Any]   , __lowerCamelCase				:     str   , __lowerCamelCase				:     Dict   , __lowerCamelCase				:     Optional[int]   , __lowerCamelCase				:     List[Any]   , ):


             '''simple docstring'''



             lowerCamelCase__						:							List[str]       =    True
             lowerCamelCase__						:							Any       =    ElectraModel(__lowerCamelCase			)
             model.to(__lowerCamelCase			)
             model.eval()
             lowerCamelCase__						:							List[Any]       =    model(
                 __lowerCamelCase   , attention_mask=__lowerCamelCase   , token_type_ids=__lowerCamelCase   , encoder_hidden_states=__lowerCamelCase   , encoder_attention_mask=__lowerCamelCase   , )
             lowerCamelCase__						:							Optional[int]       =    model(
                 __lowerCamelCase   , attention_mask=__lowerCamelCase   , token_type_ids=__lowerCamelCase   , encoder_hidden_states=__lowerCamelCase   , )
             lowerCamelCase__						:							Any       =    model(__lowerCamelCase   , attention_mask=__lowerCamelCase   , token_type_ids=__lowerCamelCase			)
             self.parent.assertEqual(result.last_hidden_state.shape   , (self.batch_size, self.seq_length, self.hidden_size)			)





       def 		lowerCAmelCase	(  self				:     str   , __lowerCamelCase				:     Optional[Any]   , __lowerCamelCase				:     List[Any]   , __lowerCamelCase				:     Optional[int]   , __lowerCamelCase				:     str   , __lowerCamelCase				:     Dict   , __lowerCamelCase				:     Any   , __lowerCamelCase				:     Union[str, Any]   , __lowerCamelCase				:     List[str]   , ):


             '''simple docstring'''



             lowerCamelCase__						:							int       =    ElectraForMaskedLM(config=__lowerCamelCase			)
             model.to(__lowerCamelCase			)
             model.eval()
             lowerCamelCase__						:							int       =    model(__lowerCamelCase   , attention_mask=__lowerCamelCase   , token_type_ids=__lowerCamelCase   , labels=__lowerCamelCase			)
             self.parent.assertEqual(result.logits.shape   , (self.batch_size, self.seq_length, self.vocab_size)			)





       def 		lowerCAmelCase	(  self				:     Any   , __lowerCamelCase				:     int   , __lowerCamelCase				:     int   , __lowerCamelCase				:     Optional[Any]   , __lowerCamelCase				:     List[Any]   , __lowerCamelCase				:     Dict   , __lowerCamelCase				:     Dict   , __lowerCamelCase				:     Optional[Any]   , __lowerCamelCase				:     Optional[Any]   , __lowerCamelCase				:     Optional[Any]   , ):


             '''simple docstring'''



             lowerCamelCase__						:							List[str]       =    ElectraForCausalLM(config=__lowerCamelCase			)
             model.to(__lowerCamelCase			)
             model.eval()
             lowerCamelCase__						:							Optional[int]       =    model(__lowerCamelCase   , attention_mask=__lowerCamelCase   , token_type_ids=__lowerCamelCase   , labels=__lowerCamelCase			)
             self.parent.assertEqual(result.logits.shape   , (self.batch_size, self.seq_length, self.vocab_size)			)





       def 		lowerCAmelCase	(  self				:     Union[str, Any]   , __lowerCamelCase				:     List[str]   , __lowerCamelCase				:     Optional[Any]   , __lowerCamelCase				:     List[str]   , __lowerCamelCase				:     Optional[Any]   , __lowerCamelCase				:     Tuple   , __lowerCamelCase				:     Optional[int]   , __lowerCamelCase				:     Tuple   , __lowerCamelCase				:     List[Any]   , ):


             '''simple docstring'''



             lowerCamelCase__						:							Optional[int]       =    self.num_labels
             lowerCamelCase__						:							str       =    ElectraForTokenClassification(config=__lowerCamelCase			)
             model.to(__lowerCamelCase			)
             model.eval()
             lowerCamelCase__						:							Union[str, Any]       =    model(__lowerCamelCase   , attention_mask=__lowerCamelCase   , token_type_ids=__lowerCamelCase   , labels=__lowerCamelCase			)
             self.parent.assertEqual(result.logits.shape   , (self.batch_size, self.seq_length, self.num_labels)			)





       def 		lowerCAmelCase	(  self				:     Any   , __lowerCamelCase				:     str   , __lowerCamelCase				:     Tuple   , __lowerCamelCase				:     Dict   , __lowerCamelCase				:     str   , __lowerCamelCase				:     Optional[Any]   , __lowerCamelCase				:     str   , __lowerCamelCase				:     Optional[int]   , __lowerCamelCase				:     Union[str, Any]   , ):


             '''simple docstring'''



             lowerCamelCase__						:							Optional[Any]       =    self.num_labels
             lowerCamelCase__						:							Any       =    ElectraForPreTraining(config=__lowerCamelCase			)
             model.to(__lowerCamelCase			)
             model.eval()
             lowerCamelCase__						:							int       =    model(__lowerCamelCase   , attention_mask=__lowerCamelCase   , token_type_ids=__lowerCamelCase   , labels=__lowerCamelCase			)
             self.parent.assertEqual(result.logits.shape   , (self.batch_size, self.seq_length)			)





       def 		lowerCAmelCase	(  self				:     Dict   , __lowerCamelCase				:     List[str]   , __lowerCamelCase				:     str   , __lowerCamelCase				:     str   , __lowerCamelCase				:     Tuple   , __lowerCamelCase				:     int   , __lowerCamelCase				:     List[Any]   , __lowerCamelCase				:     int   , __lowerCamelCase				:     List[str]   , ):


             '''simple docstring'''



             lowerCamelCase__						:							Any       =    self.num_labels
             lowerCamelCase__						:							Tuple       =    ElectraForSequenceClassification(__lowerCamelCase			)
             model.to(__lowerCamelCase			)
             model.eval()
             lowerCamelCase__						:							Optional[Any]       =    model(__lowerCamelCase   , attention_mask=__lowerCamelCase   , token_type_ids=__lowerCamelCase   , labels=__lowerCamelCase			)
             self.parent.assertEqual(result.logits.shape   , (self.batch_size, self.num_labels)			)





       def 		lowerCAmelCase	(  self				:     Optional[Any]   , __lowerCamelCase				:     Dict   , __lowerCamelCase				:     Union[str, Any]   , __lowerCamelCase				:     Optional[Any]   , __lowerCamelCase				:     Tuple   , __lowerCamelCase				:     Union[str, Any]   , __lowerCamelCase				:     Any   , __lowerCamelCase				:     Dict   , __lowerCamelCase				:     List[str]   , ):


             '''simple docstring'''



             lowerCamelCase__						:							List[Any]       =    ElectraForQuestionAnswering(config=__lowerCamelCase			)
             model.to(__lowerCamelCase			)
             model.eval()
             lowerCamelCase__						:							Union[str, Any]       =    model(
                 __lowerCamelCase   , attention_mask=__lowerCamelCase   , token_type_ids=__lowerCamelCase   , start_positions=__lowerCamelCase   , end_positions=__lowerCamelCase   , )
             self.parent.assertEqual(result.start_logits.shape   , (self.batch_size, self.seq_length)			)
             self.parent.assertEqual(result.end_logits.shape   , (self.batch_size, self.seq_length)			)





       def 		lowerCAmelCase	(  self				:     List[str]   , __lowerCamelCase				:     List[str]   , __lowerCamelCase				:     Optional[int]   , __lowerCamelCase				:     Any   , __lowerCamelCase				:     Optional[Any]   , __lowerCamelCase				:     Optional[int]   , __lowerCamelCase				:     Dict   , __lowerCamelCase				:     Optional[Any]   , __lowerCamelCase				:     List[str]   , ):


             '''simple docstring'''



             lowerCamelCase__						:							int       =    self.num_choices
             lowerCamelCase__						:							Dict       =    ElectraForMultipleChoice(config=__lowerCamelCase			)
             model.to(__lowerCamelCase			)
             model.eval()
             lowerCamelCase__						:							Optional[Any]       =    input_ids.unsqueeze(1			).expand(-1   , self.num_choices   , -1			).contiguous()
             lowerCamelCase__						:							Optional[int]       =    token_type_ids.unsqueeze(1			).expand(-1   , self.num_choices   , -1			).contiguous()
             lowerCamelCase__						:							Any       =    input_mask.unsqueeze(1			).expand(-1   , self.num_choices   , -1			).contiguous()
             lowerCamelCase__						:							int       =    model(
                 __lowerCamelCase   , attention_mask=__lowerCamelCase   , token_type_ids=__lowerCamelCase   , labels=__lowerCamelCase   , )
             self.parent.assertEqual(result.logits.shape   , (self.batch_size, self.num_choices)			)





       def 		lowerCAmelCase	(  self				:     Union[str, Any]			):


             '''simple docstring'''



             lowerCamelCase__						:							Tuple       =    self.prepare_config_and_inputs()
             (
                 (
                 lowerCamelCase__
             )       ,  (
                 lowerCamelCase__
             )       ,  (
                 lowerCamelCase__
             )       ,  (
                 lowerCamelCase__
             )       ,  (
                 lowerCamelCase__
             )       ,  (
                 lowerCamelCase__
             )       ,  (
                 lowerCamelCase__
             )       ,  (
                 lowerCamelCase__
             )       ,  
             )						:							Dict       =    config_and_inputs
             lowerCamelCase__						:							Tuple       =    {"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
             return config, inputs_dict







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


       """simple docstring"""




       A__   		=     (
           (
               ElectraModel,
               ElectraForPreTraining,
               ElectraForMaskedLM,
               ElectraForCausalLM,
               ElectraForMultipleChoice,
               ElectraForTokenClassification,
               ElectraForSequenceClassification,
               ElectraForQuestionAnswering,
           )
           if is_torch_available()
           else ()
       )
       A__   		=     (
           {
               "feature-extraction": ElectraModel,
               "fill-mask": ElectraForMaskedLM,
               "question-answering": ElectraForQuestionAnswering,
               "text-classification": ElectraForSequenceClassification,
               "text-generation": ElectraForCausalLM,
               "token-classification": ElectraForTokenClassification,
               "zero-shot": ElectraForSequenceClassification,
           }
           if is_torch_available()
           else {}
       )
       A__   		=     True





       def 		lowerCAmelCase	(  self				:     Optional[Any]   , __lowerCamelCase				:     Union[str, Any]   , __lowerCamelCase				:     Optional[int]   , __lowerCamelCase				:     str=False			):


             '''simple docstring'''



             lowerCamelCase__						:							int       =    super()._prepare_for_class(__lowerCamelCase   , __lowerCamelCase   , return_labels=__lowerCamelCase			)

             if return_labels:
                   if model_class in get_values(__lowerCamelCase			):
                         lowerCamelCase__						:							str       =    torch.zeros(
                             (self.model_tester.batch_size, self.model_tester.seq_length)   , dtype=torch.long   , device=__lowerCamelCase			)
             return inputs_dict





       def 		lowerCAmelCase	(  self				:     Tuple			):


             '''simple docstring'''



             lowerCamelCase__						:							List[Any]       =    ElectraModelTester(self			)
             lowerCamelCase__						:							Union[str, Any]       =    ConfigTester(self   , config_class=__lowerCamelCase   , hidden_size=37			)





       def 		lowerCAmelCase	(  self				:     Dict			):


             '''simple docstring'''



             self.config_tester.run_common_tests()





       def 		lowerCAmelCase	(  self				:     str			):


             '''simple docstring'''



             lowerCamelCase__						:							List[Any]       =    self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_electra_model(*__lowerCamelCase			)





       def 		lowerCAmelCase	(  self				:     Any			):


             '''simple docstring'''



             lowerCamelCase__						:							Tuple       =    self.model_tester.prepare_config_and_inputs_for_decoder()
             self.model_tester.create_and_check_electra_model_as_decoder(*__lowerCamelCase			)





       def 		lowerCAmelCase	(  self				:     Optional[int]			):


             '''simple docstring'''



             lowerCamelCase__						:							str       =    self.model_tester.prepare_config_and_inputs()
             for type in ["absolute", "relative_key", "relative_key_query"]:
                   lowerCamelCase__						:							List[str]       =    type
                   self.model_tester.create_and_check_electra_model(*__lowerCamelCase			)





       def 		lowerCAmelCase	(  self				:     Tuple			):


             '''simple docstring'''



             lowerCamelCase__						:							Optional[Any]       =    self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_electra_for_masked_lm(*__lowerCamelCase			)





       def 		lowerCAmelCase	(  self				:     Any			):


             '''simple docstring'''



             lowerCamelCase__						:							Dict       =    self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_electra_for_token_classification(*__lowerCamelCase			)





       def 		lowerCAmelCase	(  self				:     int			):


             '''simple docstring'''



             lowerCamelCase__						:							List[Any]       =    self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_electra_for_pretraining(*__lowerCamelCase			)





       def 		lowerCAmelCase	(  self				:     int			):


             '''simple docstring'''



             lowerCamelCase__						:							Optional[Any]       =    self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_electra_for_sequence_classification(*__lowerCamelCase			)





       def 		lowerCAmelCase	(  self				:     Any			):


             '''simple docstring'''



             lowerCamelCase__						:							Optional[Any]       =    self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_electra_for_question_answering(*__lowerCamelCase			)





       def 		lowerCAmelCase	(  self				:     Tuple			):


             '''simple docstring'''



             lowerCamelCase__						:							Dict       =    self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_electra_for_multiple_choice(*__lowerCamelCase			)





       @slow
       def 		lowerCAmelCase	(  self				:     Any			):


             '''simple docstring'''



             for model_name in ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                   lowerCamelCase__						:							Dict       =    ElectraModel.from_pretrained(__lowerCamelCase			)
                   self.assertIsNotNone(__lowerCamelCase			)





       def 		lowerCAmelCase	(  self				:     Optional[Any]			):


             '''simple docstring'''



             lowerCamelCase__						:							Any       =    self.model_tester.prepare_config_and_inputs_for_decoder()
             self.model_tester.create_and_check_electra_for_causal_lm(*__lowerCamelCase			)







@require_torch
class      _lowercase					(				unittest.TestCase):


       """simple docstring"""




       @slow
       def 		lowerCAmelCase	(  self				:     Any			):


             '''simple docstring'''



             lowerCamelCase__						:							int       =    ElectraModel.from_pretrained("google/electra-small-discriminator"			)
             lowerCamelCase__						:							Optional[Any]       =    torch.tensor([[0, 345, 232, 328, 740, 140, 1695, 69, 6078, 1588, 2]]			)
             lowerCamelCase__						:							Optional[int]       =    torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]			)
             lowerCamelCase__						:							int       =    model(__lowerCamelCase   , attention_mask=__lowerCamelCase			)[0]
             lowerCamelCase__						:							int       =    torch.Size((1, 11, 256)			)
             self.assertEqual(output.shape   , __lowerCamelCase			)
             lowerCamelCase__						:							Tuple       =    torch.tensor(
                 [[[0.4_4_7_1, 0.6_8_2_1, -0.3_2_6_5], [0.4_6_2_7, 0.5_2_5_5, -0.3_6_6_8], [0.4_5_3_2, 0.3_3_1_3, -0.4_3_4_4]]]			)

             self.assertTrue(torch.allclose(output[:, 1:4, 1:4]   , __lowerCamelCase   , atol=1E-4			)			)






import inspect
import unittest

from transformers import ResNetConfig, is_flax_available
from transformers.testing_utils import require_flax, slow
from transformers.utils import cached_property, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor


if is_flax_available():
    import jax
    import jax.numpy as jnp

    from transformers.models.resnet.modeling_flax_resnet import FlaxResNetForImageClassification, FlaxResNetModel

if is_vision_available():
    from PIL import Image

    from transformers import AutoImageProcessor







class      _lowercase					(				unittest.TestCase):


       """simple docstring"""




       def __init__(  self				:     Dict   , __lowerCamelCase				:     int   , __lowerCamelCase				:     List[Any]=3   , __lowerCamelCase				:     Dict=32   , __lowerCamelCase				:     Optional[Any]=3   , __lowerCamelCase				:     List[str]=10   , __lowerCamelCase				:     List[str]=[10, 20, 30, 40]   , __lowerCamelCase				:     List[Any]=[1, 1, 2, 1]   , __lowerCamelCase				:     Any=True   , __lowerCamelCase				:     Optional[int]=True   , __lowerCamelCase				:     int="relu"   , __lowerCamelCase				:     List[str]=3   , __lowerCamelCase				:     Any=None   , ):


             '''simple docstring'''



             lowerCamelCase__						:							int       =    parent
             lowerCamelCase__						:							Optional[int]       =    batch_size
             lowerCamelCase__						:							List[Any]       =    image_size
             lowerCamelCase__						:							Union[str, Any]       =    num_channels
             lowerCamelCase__						:							Any       =    embeddings_size
             lowerCamelCase__						:							Tuple       =    hidden_sizes
             lowerCamelCase__						:							Tuple       =    depths
             lowerCamelCase__						:							List[str]       =    is_training
             lowerCamelCase__						:							Optional[Any]       =    use_labels
             lowerCamelCase__						:							str       =    hidden_act
             lowerCamelCase__						:							Any       =    num_labels
             lowerCamelCase__						:							List[str]       =    scope
             lowerCamelCase__						:							Any       =    len(__lowerCamelCase			)





       def 		lowerCAmelCase	(  self				:     List[str]			):


             '''simple docstring'''



             lowerCamelCase__						:							Any       =    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]			)

             lowerCamelCase__						:							Any       =    self.get_config()

             return config, pixel_values





       def 		lowerCAmelCase	(  self				:     Optional[int]			):


             '''simple docstring'''



             return ResNetConfig(
                 num_channels=self.num_channels   , embeddings_size=self.embeddings_size   , hidden_sizes=self.hidden_sizes   , depths=self.depths   , hidden_act=self.hidden_act   , num_labels=self.num_labels   , image_size=self.image_size   , )





       def 		lowerCAmelCase	(  self				:     str   , __lowerCamelCase				:     List[Any]   , __lowerCamelCase				:     Tuple			):


             '''simple docstring'''



             lowerCamelCase__						:							Any       =    FlaxResNetModel(config=__lowerCamelCase			)
             lowerCamelCase__						:							str       =    model(__lowerCamelCase			)

             # Output shape (b, c, h, w)
             self.parent.assertEqual(
                 result.last_hidden_state.shape   , (self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)   , )





       def 		lowerCAmelCase	(  self				:     int   , __lowerCamelCase				:     Optional[Any]   , __lowerCamelCase				:     List[str]			):


             '''simple docstring'''



             lowerCamelCase__						:							Optional[Any]       =    self.num_labels
             lowerCamelCase__						:							int       =    FlaxResNetForImageClassification(config=__lowerCamelCase			)
             lowerCamelCase__						:							Optional[int]       =    model(__lowerCamelCase			)
             self.parent.assertEqual(result.logits.shape   , (self.batch_size, self.num_labels)			)





       def 		lowerCAmelCase	(  self				:     Dict			):


             '''simple docstring'''



             lowerCamelCase__						:							Tuple       =    self.prepare_config_and_inputs()
             lowerCamelCase__       ,  lowerCamelCase__						:							Tuple       =    config_and_inputs
             lowerCamelCase__						:							Optional[int]       =    {"pixel_values": pixel_values}
             return config, inputs_dict







@require_flax
class      _lowercase					(				lowercase__				,    unittest.TestCase):


       """simple docstring"""




       A__   		=     (FlaxResNetModel, FlaxResNetForImageClassification) if is_flax_available() else ()

       A__   		=     False
       A__   		=     False
       A__   		=     False





       def 		lowerCAmelCase	(  self				:     List[str]			):


             '''simple docstring'''



             lowerCamelCase__						:							List[str]       =    FlaxResNetModelTester(self			)
             lowerCamelCase__						:							Dict       =    ConfigTester(self   , config_class=__lowerCamelCase   , has_text_modality=__lowerCamelCase			)





       def 		lowerCAmelCase	(  self				:     Optional[Any]			):


             '''simple docstring'''



             self.create_and_test_config_common_properties()
             self.config_tester.create_and_test_config_to_json_string()
             self.config_tester.create_and_test_config_to_json_file()
             self.config_tester.create_and_test_config_from_and_save_pretrained()
             self.config_tester.create_and_test_config_with_num_labels()
             self.config_tester.check_config_can_be_init_without_params()
             self.config_tester.check_config_arguments_init()





       def 		lowerCAmelCase	(  self				:     Dict			):


             '''simple docstring'''



             return





       def 		lowerCAmelCase	(  self				:     Dict			):


             '''simple docstring'''



             lowerCamelCase__						:							str       =    self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_model(*__lowerCamelCase			)





       def 		lowerCAmelCase	(  self				:     List[Any]			):


             '''simple docstring'''



             lowerCamelCase__						:							str       =    self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_image_classification(*__lowerCamelCase			)





       @unittest.skip(reason="ResNet does not use inputs_embeds"			)
       def 		lowerCAmelCase	(  self				:     Dict			):


             '''simple docstring'''



             pass





       @unittest.skip(reason="ResNet does not support input and output embeddings"			)
       def 		lowerCAmelCase	(  self				:     int			):


             '''simple docstring'''



             pass





       def 		lowerCAmelCase	(  self				:     Any			):


             '''simple docstring'''



             lowerCamelCase__       ,  lowerCamelCase__						:							Tuple       =    self.model_tester.prepare_config_and_inputs_for_common()

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

                   lowerCamelCase__						:							List[Any]       =    ["pixel_values"]
                   self.assertListEqual(arg_names[:1]   , __lowerCamelCase			)





       def 		lowerCAmelCase	(  self				:     Any			):


             '''simple docstring'''



             def check_hidden_states_output(__lowerCamelCase				:     List[str]   , __lowerCamelCase				:     Optional[int]   , __lowerCamelCase				:     str			):
                   lowerCamelCase__						:							Any       =    model_class(__lowerCamelCase			)

                   lowerCamelCase__						:							Dict       =    model(**self._prepare_for_class(__lowerCamelCase   , __lowerCamelCase			)			)

                   lowerCamelCase__						:							str       =    outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

                   lowerCamelCase__						:							Tuple       =    self.model_tester.num_stages
                   self.assertEqual(len(__lowerCamelCase			)   , expected_num_stages + 1			)





       @unittest.skip(reason="ResNet does not use feedforward chunking"			)
       def 		lowerCAmelCase	(  self				:     Any			):


             '''simple docstring'''



             pass





       def 		lowerCAmelCase	(  self				:     int			):


             '''simple docstring'''



             lowerCamelCase__       ,  lowerCamelCase__						:							Dict       =    self.model_tester.prepare_config_and_inputs_for_common()

             for model_class in self.all_model_classes:
                   with self.subTest(model_class.__name__			):
                         lowerCamelCase__						:							Any       =    self._prepare_for_class(__lowerCamelCase   , __lowerCamelCase			)
                         lowerCamelCase__						:							Optional[int]       =    model_class(__lowerCamelCase			)

                         @jax.jit
                         def model_jitted(__lowerCamelCase				:     Optional[Any]   , **__lowerCamelCase				:     List[Any]			):
                               return model(pixel_values=__lowerCamelCase   , **__lowerCamelCase			)

                         with self.subTest("JIT Enabled"			):
                               lowerCamelCase__						:							Any       =    model_jitted(**__lowerCamelCase			).to_tuple()

                         with self.subTest("JIT Disabled"			):
                               with jax.disable_jit():
                                     lowerCamelCase__						:							Union[str, Any]       =    model_jitted(**__lowerCamelCase			).to_tuple()

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



def  lowercase_						(						):

      """simple docstring"""




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







@require_flax
class      _lowercase					(				unittest.TestCase):


       """simple docstring"""




       @cached_property
       def 		lowerCAmelCase	(  self				:     Tuple			):


             '''simple docstring'''



             return AutoImageProcessor.from_pretrained("microsoft/resnet-50"			) if is_vision_available() else None





       @slow
       def 		lowerCAmelCase	(  self				:     List[str]			):


             '''simple docstring'''



             lowerCamelCase__						:							List[Any]       =    FlaxResNetForImageClassification.from_pretrained("microsoft/resnet-50"			)

             lowerCamelCase__						:							List[str]       =    self.default_image_processor
             lowerCamelCase__						:							Optional[Any]       =    prepare_img()
             lowerCamelCase__						:							str       =    image_processor(images=__lowerCamelCase   , return_tensors="np"			)

             lowerCamelCase__						:							str       =    model(**__lowerCamelCase			)

             # verify the logits
             lowerCamelCase__						:							int       =    (1, 1000)
             self.assertEqual(outputs.logits.shape   , __lowerCamelCase			)

             lowerCamelCase__						:							Optional[int]       =    jnp.array([-1_1.1_0_6_9, -9.7_8_7_7, -8.3_7_7_7]			)

             self.assertTrue(jnp.allclose(outputs.logits[0, :3]   , __lowerCamelCase   , atol=1E-4			)			)


