

from __future__ import annotations

import inspect
import unittest
from typing import List, Tuple

from transformers import RegNetConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
    import tensorflow as tf

    from transformers import TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST, TFRegNetForImageClassification, TFRegNetModel


if is_vision_available():
    from PIL import Image

    from transformers import AutoImageProcessor





class 			_SCREAMING_SNAKE_CASE :







   '''simple docstring'''




   def __init__(       self					:			Union[str, Any]     , __lowerCamelCase					:			Dict     , __lowerCamelCase					:			Dict=3     , __lowerCamelCase					:			List[Any]=32     , __lowerCamelCase					:			Optional[Any]=3     , __lowerCamelCase					:			Optional[Any]=10     , __lowerCamelCase					:			Optional[int]=[10, 20, 30, 40]     , __lowerCamelCase					:			Any=[1, 1, 2, 1]     , __lowerCamelCase					:			int=True     , __lowerCamelCase					:			List[str]=True     , __lowerCamelCase					:			int="relu"     , __lowerCamelCase					:			Optional[int]=3     , __lowerCamelCase					:			Optional[int]=None     , ):
       SCREAMING_SNAKE_CASE										=   parent
       SCREAMING_SNAKE_CASE										=   batch_size
       SCREAMING_SNAKE_CASE										=   image_size
       SCREAMING_SNAKE_CASE										=   num_channels
       SCREAMING_SNAKE_CASE										=   embeddings_size
       SCREAMING_SNAKE_CASE										=   hidden_sizes
       SCREAMING_SNAKE_CASE										=   depths
       SCREAMING_SNAKE_CASE										=   is_training
       SCREAMING_SNAKE_CASE										=   use_labels
       SCREAMING_SNAKE_CASE										=   hidden_act
       SCREAMING_SNAKE_CASE										=   num_labels
       SCREAMING_SNAKE_CASE										=   scope
       SCREAMING_SNAKE_CASE										=   len(__lowerCamelCase			)





   def      _snake_case		(       self					:			Optional[Any]			):
       SCREAMING_SNAKE_CASE										=   floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]			)

       SCREAMING_SNAKE_CASE										=   None
       if self.use_labels:
           SCREAMING_SNAKE_CASE										=   ids_tensor([self.batch_size]     , self.num_labels			)

       SCREAMING_SNAKE_CASE										=   self.get_config()
       return config, pixel_values, labels





   def      _snake_case		(       self					:			Optional[int]			):
       return RegNetConfig(
           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     , )





   def      _snake_case		(       self					:			Dict     , __lowerCamelCase					:			int     , __lowerCamelCase					:			Optional[Any]     , __lowerCamelCase					:			Union[str, Any]			):
       SCREAMING_SNAKE_CASE										=   TFRegNetModel(config=__lowerCamelCase			)
       SCREAMING_SNAKE_CASE										=   model(__lowerCamelCase     , training=__lowerCamelCase			)
       # expected last hidden states: B, C, H // 32, W // 32
       self.parent.assertEqual(
           result.last_hidden_state.shape     , (self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)     , )





   def      _snake_case		(       self					:			str     , __lowerCamelCase					:			List[str]     , __lowerCamelCase					:			Dict     , __lowerCamelCase					:			Optional[Any]			):
       SCREAMING_SNAKE_CASE										=   self.num_labels
       SCREAMING_SNAKE_CASE										=   TFRegNetForImageClassification(__lowerCamelCase			)
       SCREAMING_SNAKE_CASE										=   model(__lowerCamelCase     , labels=__lowerCamelCase     , training=__lowerCamelCase			)
       self.parent.assertEqual(result.logits.shape     , (self.batch_size, self.num_labels)			)





   def      _snake_case		(       self					:			Any			):
       SCREAMING_SNAKE_CASE										=   self.prepare_config_and_inputs()
       SCREAMING_SNAKE_CASE							,	SCREAMING_SNAKE_CASE							,	SCREAMING_SNAKE_CASE										=   config_and_inputs
       SCREAMING_SNAKE_CASE										=   {"pixel_values": pixel_values}
       return config, inputs_dict





@require_tf
class 			_SCREAMING_SNAKE_CASE (   __snake_case					,       __snake_case					,       unittest.TestCase		):







   '''simple docstring'''




   lowerCamelCase__				=      (TFRegNetModel, TFRegNetForImageClassification) if is_tf_available() else ()
   lowerCamelCase__				=      (
       {"feature-extraction": TFRegNetModel, "image-classification": TFRegNetForImageClassification}
       if is_tf_available()
       else {}
   )

   lowerCamelCase__				=      False
   lowerCamelCase__				=      False
   lowerCamelCase__				=      False
   lowerCamelCase__				=      False
   lowerCamelCase__				=      False





   def      _snake_case		(       self					:			Union[str, Any]			):
       SCREAMING_SNAKE_CASE										=   TFRegNetModelTester(self			)
       SCREAMING_SNAKE_CASE										=   ConfigTester(self     , config_class=__lowerCamelCase     , has_text_modality=__lowerCamelCase			)





   def      _snake_case		(       self					:			Any			):
       return





   @unittest.skip(reason="RegNet does not use inputs_embeds"			)
   def      _snake_case		(       self					:			Tuple			):
       pass





   @unittest.skipIf(
       not is_tf_available() or len(tf.config.list_physical_devices("GPU"			)			) == 0     , reason="TF does not support backprop for grouped convolutions on CPU."     , )
   @slow
   def      _snake_case		(       self					:			str			):
       super().test_keras_fit()





   @unittest.skip(reason="RegNet does not support input and output embeddings"			)
   def      _snake_case		(       self					:			List[str]			):
       pass





   def      _snake_case		(       self					:			Optional[int]			):
       SCREAMING_SNAKE_CASE							,	SCREAMING_SNAKE_CASE										=   self.model_tester.prepare_config_and_inputs_for_common()

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

           SCREAMING_SNAKE_CASE										=   ["pixel_values"]
           self.assertListEqual(arg_names[:1]     , __lowerCamelCase			)





   def      _snake_case		(       self					:			List[Any]			):
       SCREAMING_SNAKE_CASE										=   self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*__lowerCamelCase			)





   def      _snake_case		(       self					:			Union[str, Any]			):
       def check_hidden_states_output(__lowerCamelCase					:			int     , __lowerCamelCase					:			int     , __lowerCamelCase					:			str			):
           SCREAMING_SNAKE_CASE										=   model_class(__lowerCamelCase			)
           SCREAMING_SNAKE_CASE										=   model(**self._prepare_for_class(__lowerCamelCase     , __lowerCamelCase			)     , training=__lowerCamelCase			)

           SCREAMING_SNAKE_CASE										=   outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

           SCREAMING_SNAKE_CASE										=   self.model_tester.num_stages
           self.assertEqual(len(__lowerCamelCase			)     , expected_num_stages + 1			)

           # RegNet'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										=   self.model_tester.prepare_config_and_inputs_for_common()
       SCREAMING_SNAKE_CASE										=   ["basic", "bottleneck"]
       for model_class in self.all_model_classes:
           for layer_type in layers_type:
               SCREAMING_SNAKE_CASE										=   layer_type
               SCREAMING_SNAKE_CASE										=   True
               check_hidden_states_output(__lowerCamelCase     , __lowerCamelCase     , __lowerCamelCase			)

               # check that output_hidden_states also work using config
               del inputs_dict["output_hidden_states"]
               SCREAMING_SNAKE_CASE										=   True

               check_hidden_states_output(__lowerCamelCase     , __lowerCamelCase     , __lowerCamelCase			)





   def      _snake_case		(       self					:			Optional[int]			):
       SCREAMING_SNAKE_CASE							,	SCREAMING_SNAKE_CASE										=   self.model_tester.prepare_config_and_inputs_for_common()

       def check_equivalence(__lowerCamelCase					:			str     , __lowerCamelCase					:			List[str]     , __lowerCamelCase					:			Optional[Any]     , __lowerCamelCase					:			Dict={}			):
           SCREAMING_SNAKE_CASE										=   model(__lowerCamelCase     , return_dict=__lowerCamelCase     , **__lowerCamelCase			)
           SCREAMING_SNAKE_CASE										=   model(__lowerCamelCase     , return_dict=__lowerCamelCase     , **__lowerCamelCase			).to_tuple()

           def recursive_check(__lowerCamelCase					:			Optional[Any]     , __lowerCamelCase					:			Optional[int]			):
               if isinstance(__lowerCamelCase     , (List, Tuple)			):
                   for tuple_iterable_value, dict_iterable_value in zip(__lowerCamelCase     , __lowerCamelCase			):
                       recursive_check(__lowerCamelCase     , __lowerCamelCase			)
               elif tuple_object is None:
                   return
               else:
                   self.assertTrue(
                       all(tf.equal(__lowerCamelCase     , __lowerCamelCase			)			)     , msg=(
                           "Tuple and dict output are not equal. Difference:"
                           f" {tf.math.reduce_max(tf.abs(tuple_object - dict_object			)			)}"
                       )     , )

               recursive_check(__lowerCamelCase     , __lowerCamelCase			)

       for model_class in self.all_model_classes:
           SCREAMING_SNAKE_CASE										=   model_class(__lowerCamelCase			)

           SCREAMING_SNAKE_CASE										=   self._prepare_for_class(__lowerCamelCase     , __lowerCamelCase			)
           SCREAMING_SNAKE_CASE										=   self._prepare_for_class(__lowerCamelCase     , __lowerCamelCase			)
           check_equivalence(__lowerCamelCase     , __lowerCamelCase     , __lowerCamelCase			)

           SCREAMING_SNAKE_CASE										=   self._prepare_for_class(__lowerCamelCase     , __lowerCamelCase     , return_labels=__lowerCamelCase			)
           SCREAMING_SNAKE_CASE										=   self._prepare_for_class(__lowerCamelCase     , __lowerCamelCase     , return_labels=__lowerCamelCase			)
           check_equivalence(__lowerCamelCase     , __lowerCamelCase     , __lowerCamelCase			)

           SCREAMING_SNAKE_CASE										=   self._prepare_for_class(__lowerCamelCase     , __lowerCamelCase			)
           SCREAMING_SNAKE_CASE										=   self._prepare_for_class(__lowerCamelCase     , __lowerCamelCase			)
           check_equivalence(__lowerCamelCase     , __lowerCamelCase     , __lowerCamelCase     , {"output_hidden_states": True}			)

           SCREAMING_SNAKE_CASE										=   self._prepare_for_class(__lowerCamelCase     , __lowerCamelCase     , return_labels=__lowerCamelCase			)
           SCREAMING_SNAKE_CASE										=   self._prepare_for_class(__lowerCamelCase     , __lowerCamelCase     , return_labels=__lowerCamelCase			)
           check_equivalence(__lowerCamelCase     , __lowerCamelCase     , __lowerCamelCase     , {"output_hidden_states": True}			)





   def      _snake_case		(       self					:			Union[str, Any]			):
       SCREAMING_SNAKE_CASE										=   self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*__lowerCamelCase			)





   @slow
   def      _snake_case		(       self					:			str			):
       for model_name in TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           SCREAMING_SNAKE_CASE										=   TFRegNetModel.from_pretrained(__lowerCamelCase			)
           self.assertIsNotNone(__lowerCamelCase			)





def 	__a     (      ):
    SCREAMING_SNAKE_CASE										=   Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"       )
    return image





@require_tf
@require_vision
class 			_SCREAMING_SNAKE_CASE (   unittest.TestCase		):







   '''simple docstring'''




   @cached_property
   def      _snake_case		(       self					:			Union[str, Any]			):
       return (
           AutoImageProcessor.from_pretrained(TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]			)
           if is_vision_available()
           else None
       )





   @slow
   def      _snake_case		(       self					:			Dict			):
       SCREAMING_SNAKE_CASE										=   TFRegNetForImageClassification.from_pretrained(TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]			)

       SCREAMING_SNAKE_CASE										=   self.default_image_processor
       SCREAMING_SNAKE_CASE										=   prepare_img()
       SCREAMING_SNAKE_CASE										=   image_processor(images=__lowerCamelCase     , return_tensors="tf"			)

       # forward pass
       SCREAMING_SNAKE_CASE										=   model(**__lowerCamelCase     , training=__lowerCamelCase			)

       # verify the logits
       SCREAMING_SNAKE_CASE										=   tf.TensorShape((1, 1000)			)
       self.assertEqual(outputs.logits.shape     , __lowerCamelCase			)

       SCREAMING_SNAKE_CASE										=   tf.constant([-0.4_180, -1.5_051, -3.4_836]			)

       tf.debugging.assert_near(outputs.logits[0, :3]     , __lowerCamelCase     , atol=1e-4			)


from collections import OrderedDict

from ...utils import logging
from .auto_factory import _BaseAutoModelClass, _LazyAutoMapping, auto_class_update
from .configuration_auto import CONFIG_MAPPING_NAMES


__A			:					int						=			logging.get_logger(__name__)


__A			:					List[str]						=			OrderedDict(
    [
        # Base model mapping
        ('albert', 'FlaxAlbertModel'),
        ('bart', 'FlaxBartModel'),
        ('beit', 'FlaxBeitModel'),
        ('bert', 'FlaxBertModel'),
        ('big_bird', 'FlaxBigBirdModel'),
        ('blenderbot', 'FlaxBlenderbotModel'),
        ('blenderbot-small', 'FlaxBlenderbotSmallModel'),
        ('clip', 'FlaxCLIPModel'),
        ('distilbert', 'FlaxDistilBertModel'),
        ('electra', 'FlaxElectraModel'),
        ('gpt-sw3', 'FlaxGPT2Model'),
        ('gpt2', 'FlaxGPT2Model'),
        ('gpt_neo', 'FlaxGPTNeoModel'),
        ('gptj', 'FlaxGPTJModel'),
        ('longt5', 'FlaxLongT5Model'),
        ('marian', 'FlaxMarianModel'),
        ('mbart', 'FlaxMBartModel'),
        ('mt5', 'FlaxMT5Model'),
        ('opt', 'FlaxOPTModel'),
        ('pegasus', 'FlaxPegasusModel'),
        ('regnet', 'FlaxRegNetModel'),
        ('resnet', 'FlaxResNetModel'),
        ('roberta', 'FlaxRobertaModel'),
        ('roberta-prelayernorm', 'FlaxRobertaPreLayerNormModel'),
        ('roformer', 'FlaxRoFormerModel'),
        ('t5', 'FlaxT5Model'),
        ('vision-text-dual-encoder', 'FlaxVisionTextDualEncoderModel'),
        ('vit', 'FlaxViTModel'),
        ('wav2vec2', 'FlaxWav2Vec2Model'),
        ('whisper', 'FlaxWhisperModel'),
        ('xglm', 'FlaxXGLMModel'),
        ('xlm-roberta', 'FlaxXLMRobertaModel'),
    ]
)

__A			:					Optional[Any]						=			OrderedDict(
    [
        # Model for pre-training mapping
        ('albert', 'FlaxAlbertForPreTraining'),
        ('bart', 'FlaxBartForConditionalGeneration'),
        ('bert', 'FlaxBertForPreTraining'),
        ('big_bird', 'FlaxBigBirdForPreTraining'),
        ('electra', 'FlaxElectraForPreTraining'),
        ('longt5', 'FlaxLongT5ForConditionalGeneration'),
        ('mbart', 'FlaxMBartForConditionalGeneration'),
        ('mt5', 'FlaxMT5ForConditionalGeneration'),
        ('roberta', 'FlaxRobertaForMaskedLM'),
        ('roberta-prelayernorm', 'FlaxRobertaPreLayerNormForMaskedLM'),
        ('roformer', 'FlaxRoFormerForMaskedLM'),
        ('t5', 'FlaxT5ForConditionalGeneration'),
        ('wav2vec2', 'FlaxWav2Vec2ForPreTraining'),
        ('whisper', 'FlaxWhisperForConditionalGeneration'),
        ('xlm-roberta', 'FlaxXLMRobertaForMaskedLM'),
    ]
)

__A			:					Tuple						=			OrderedDict(
    [
        # Model for Masked LM mapping
        ('albert', 'FlaxAlbertForMaskedLM'),
        ('bart', 'FlaxBartForConditionalGeneration'),
        ('bert', 'FlaxBertForMaskedLM'),
        ('big_bird', 'FlaxBigBirdForMaskedLM'),
        ('distilbert', 'FlaxDistilBertForMaskedLM'),
        ('electra', 'FlaxElectraForMaskedLM'),
        ('mbart', 'FlaxMBartForConditionalGeneration'),
        ('roberta', 'FlaxRobertaForMaskedLM'),
        ('roberta-prelayernorm', 'FlaxRobertaPreLayerNormForMaskedLM'),
        ('roformer', 'FlaxRoFormerForMaskedLM'),
        ('xlm-roberta', 'FlaxXLMRobertaForMaskedLM'),
    ]
)

__A			:					Dict						=			OrderedDict(
    [
        # Model for Seq2Seq Causal LM mapping
        ('bart', 'FlaxBartForConditionalGeneration'),
        ('blenderbot', 'FlaxBlenderbotForConditionalGeneration'),
        ('blenderbot-small', 'FlaxBlenderbotSmallForConditionalGeneration'),
        ('encoder-decoder', 'FlaxEncoderDecoderModel'),
        ('longt5', 'FlaxLongT5ForConditionalGeneration'),
        ('marian', 'FlaxMarianMTModel'),
        ('mbart', 'FlaxMBartForConditionalGeneration'),
        ('mt5', 'FlaxMT5ForConditionalGeneration'),
        ('pegasus', 'FlaxPegasusForConditionalGeneration'),
        ('t5', 'FlaxT5ForConditionalGeneration'),
    ]
)

__A			:					Any						=			OrderedDict(
    [
        # Model for Image-classsification
        ('beit', 'FlaxBeitForImageClassification'),
        ('regnet', 'FlaxRegNetForImageClassification'),
        ('resnet', 'FlaxResNetForImageClassification'),
        ('vit', 'FlaxViTForImageClassification'),
    ]
)

__A			:					Optional[int]						=			OrderedDict(
    [
        ('vision-encoder-decoder', 'FlaxVisionEncoderDecoderModel'),
    ]
)

__A			:					Union[str, Any]						=			OrderedDict(
    [
        # Model for Causal LM mapping
        ('bart', 'FlaxBartForCausalLM'),
        ('bert', 'FlaxBertForCausalLM'),
        ('big_bird', 'FlaxBigBirdForCausalLM'),
        ('electra', 'FlaxElectraForCausalLM'),
        ('gpt-sw3', 'FlaxGPT2LMHeadModel'),
        ('gpt2', 'FlaxGPT2LMHeadModel'),
        ('gpt_neo', 'FlaxGPTNeoForCausalLM'),
        ('gptj', 'FlaxGPTJForCausalLM'),
        ('opt', 'FlaxOPTForCausalLM'),
        ('roberta', 'FlaxRobertaForCausalLM'),
        ('roberta-prelayernorm', 'FlaxRobertaPreLayerNormForCausalLM'),
        ('xglm', 'FlaxXGLMForCausalLM'),
        ('xlm-roberta', 'FlaxXLMRobertaForCausalLM'),
    ]
)

__A			:					Optional[int]						=			OrderedDict(
    [
        # Model for Sequence Classification mapping
        ('albert', 'FlaxAlbertForSequenceClassification'),
        ('bart', 'FlaxBartForSequenceClassification'),
        ('bert', 'FlaxBertForSequenceClassification'),
        ('big_bird', 'FlaxBigBirdForSequenceClassification'),
        ('distilbert', 'FlaxDistilBertForSequenceClassification'),
        ('electra', 'FlaxElectraForSequenceClassification'),
        ('mbart', 'FlaxMBartForSequenceClassification'),
        ('roberta', 'FlaxRobertaForSequenceClassification'),
        ('roberta-prelayernorm', 'FlaxRobertaPreLayerNormForSequenceClassification'),
        ('roformer', 'FlaxRoFormerForSequenceClassification'),
        ('xlm-roberta', 'FlaxXLMRobertaForSequenceClassification'),
    ]
)

__A			:					str						=			OrderedDict(
    [
        # Model for Question Answering mapping
        ('albert', 'FlaxAlbertForQuestionAnswering'),
        ('bart', 'FlaxBartForQuestionAnswering'),
        ('bert', 'FlaxBertForQuestionAnswering'),
        ('big_bird', 'FlaxBigBirdForQuestionAnswering'),
        ('distilbert', 'FlaxDistilBertForQuestionAnswering'),
        ('electra', 'FlaxElectraForQuestionAnswering'),
        ('mbart', 'FlaxMBartForQuestionAnswering'),
        ('roberta', 'FlaxRobertaForQuestionAnswering'),
        ('roberta-prelayernorm', 'FlaxRobertaPreLayerNormForQuestionAnswering'),
        ('roformer', 'FlaxRoFormerForQuestionAnswering'),
        ('xlm-roberta', 'FlaxXLMRobertaForQuestionAnswering'),
    ]
)

__A			:					Dict						=			OrderedDict(
    [
        # Model for Token Classification mapping
        ('albert', 'FlaxAlbertForTokenClassification'),
        ('bert', 'FlaxBertForTokenClassification'),
        ('big_bird', 'FlaxBigBirdForTokenClassification'),
        ('distilbert', 'FlaxDistilBertForTokenClassification'),
        ('electra', 'FlaxElectraForTokenClassification'),
        ('roberta', 'FlaxRobertaForTokenClassification'),
        ('roberta-prelayernorm', 'FlaxRobertaPreLayerNormForTokenClassification'),
        ('roformer', 'FlaxRoFormerForTokenClassification'),
        ('xlm-roberta', 'FlaxXLMRobertaForTokenClassification'),
    ]
)

__A			:					Dict						=			OrderedDict(
    [
        # Model for Multiple Choice mapping
        ('albert', 'FlaxAlbertForMultipleChoice'),
        ('bert', 'FlaxBertForMultipleChoice'),
        ('big_bird', 'FlaxBigBirdForMultipleChoice'),
        ('distilbert', 'FlaxDistilBertForMultipleChoice'),
        ('electra', 'FlaxElectraForMultipleChoice'),
        ('roberta', 'FlaxRobertaForMultipleChoice'),
        ('roberta-prelayernorm', 'FlaxRobertaPreLayerNormForMultipleChoice'),
        ('roformer', 'FlaxRoFormerForMultipleChoice'),
        ('xlm-roberta', 'FlaxXLMRobertaForMultipleChoice'),
    ]
)

__A			:					Any						=			OrderedDict(
    [
        ('bert', 'FlaxBertForNextSentencePrediction'),
    ]
)

__A			:					Optional[int]						=			OrderedDict(
    [
        ('speech-encoder-decoder', 'FlaxSpeechEncoderDecoderModel'),
        ('whisper', 'FlaxWhisperForConditionalGeneration'),
    ]
)

__A			:					List[str]						=			OrderedDict(
    [
        ('whisper', 'FlaxWhisperForAudioClassification'),
    ]
)

__A			:					Optional[int]						=			_LazyAutoMapping(CONFIG_MAPPING_NAMES, FLAX_MODEL_MAPPING_NAMES)
__A			:					str						=			_LazyAutoMapping(CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_PRETRAINING_MAPPING_NAMES)
__A			:					List[Any]						=			_LazyAutoMapping(CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_MASKED_LM_MAPPING_NAMES)
__A			:					Tuple						=			_LazyAutoMapping(
    CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING_NAMES
)
__A			:					Any						=			_LazyAutoMapping(
    CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING_NAMES
)
__A			:					str						=			_LazyAutoMapping(CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_VISION_2_SEQ_MAPPING_NAMES)
__A			:					Tuple						=			_LazyAutoMapping(CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_CAUSAL_LM_MAPPING_NAMES)
__A			:					Optional[int]						=			_LazyAutoMapping(
    CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING_NAMES
)
__A			:					List[str]						=			_LazyAutoMapping(
    CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_QUESTION_ANSWERING_MAPPING_NAMES
)
__A			:					Union[str, Any]						=			_LazyAutoMapping(
    CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING_NAMES
)
__A			:					List[Any]						=			_LazyAutoMapping(
    CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_MULTIPLE_CHOICE_MAPPING_NAMES
)
__A			:					Optional[int]						=			_LazyAutoMapping(
    CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING_NAMES
)
__A			:					List[Any]						=			_LazyAutoMapping(
    CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING_NAMES
)
__A			:					Tuple						=			_LazyAutoMapping(
    CONFIG_MAPPING_NAMES, FLAX_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING_NAMES
)





class 			_SCREAMING_SNAKE_CASE (   _BaseAutoModelClass		):







   '''simple docstring'''




   lowerCamelCase__				=      FLAX_MODEL_MAPPING




__A			:					Optional[int]						=			auto_class_update(FlaxAutoModel)





class 			_SCREAMING_SNAKE_CASE (   _BaseAutoModelClass		):







   '''simple docstring'''




   lowerCamelCase__				=      FLAX_MODEL_FOR_PRETRAINING_MAPPING




__A			:					Optional[Any]						=			auto_class_update(FlaxAutoModelForPreTraining, head_doc='pretraining')





class 			_SCREAMING_SNAKE_CASE (   _BaseAutoModelClass		):







   '''simple docstring'''




   lowerCamelCase__				=      FLAX_MODEL_FOR_CAUSAL_LM_MAPPING




__A			:					Tuple						=			auto_class_update(FlaxAutoModelForCausalLM, head_doc='causal language modeling')





class 			_SCREAMING_SNAKE_CASE (   _BaseAutoModelClass		):







   '''simple docstring'''




   lowerCamelCase__				=      FLAX_MODEL_FOR_MASKED_LM_MAPPING




__A			:					List[Any]						=			auto_class_update(FlaxAutoModelForMaskedLM, head_doc='masked language modeling')





class 			_SCREAMING_SNAKE_CASE (   _BaseAutoModelClass		):







   '''simple docstring'''




   lowerCamelCase__				=      FLAX_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING




__A			:					int						=			auto_class_update(
    FlaxAutoModelForSeqaSeqLM, head_doc='sequence-to-sequence language modeling', checkpoint_for_example='t5-base'
)





class 			_SCREAMING_SNAKE_CASE (   _BaseAutoModelClass		):







   '''simple docstring'''




   lowerCamelCase__				=      FLAX_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING




__A			:					Optional[int]						=			auto_class_update(
    FlaxAutoModelForSequenceClassification, head_doc='sequence classification'
)





class 			_SCREAMING_SNAKE_CASE (   _BaseAutoModelClass		):







   '''simple docstring'''




   lowerCamelCase__				=      FLAX_MODEL_FOR_QUESTION_ANSWERING_MAPPING




__A			:					int						=			auto_class_update(FlaxAutoModelForQuestionAnswering, head_doc='question answering')





class 			_SCREAMING_SNAKE_CASE (   _BaseAutoModelClass		):







   '''simple docstring'''




   lowerCamelCase__				=      FLAX_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING




__A			:					List[Any]						=			auto_class_update(
    FlaxAutoModelForTokenClassification, head_doc='token classification'
)





class 			_SCREAMING_SNAKE_CASE (   _BaseAutoModelClass		):







   '''simple docstring'''




   lowerCamelCase__				=      FLAX_MODEL_FOR_MULTIPLE_CHOICE_MAPPING




__A			:					Any						=			auto_class_update(FlaxAutoModelForMultipleChoice, head_doc='multiple choice')





class 			_SCREAMING_SNAKE_CASE (   _BaseAutoModelClass		):







   '''simple docstring'''




   lowerCamelCase__				=      FLAX_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING




__A			:					Union[str, Any]						=			auto_class_update(
    FlaxAutoModelForNextSentencePrediction, head_doc='next sentence prediction'
)





class 			_SCREAMING_SNAKE_CASE (   _BaseAutoModelClass		):







   '''simple docstring'''




   lowerCamelCase__				=      FLAX_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING




__A			:					Optional[Any]						=			auto_class_update(
    FlaxAutoModelForImageClassification, head_doc='image classification'
)





class 			_SCREAMING_SNAKE_CASE (   _BaseAutoModelClass		):







   '''simple docstring'''




   lowerCamelCase__				=      FLAX_MODEL_FOR_VISION_2_SEQ_MAPPING




__A			:					int						=			auto_class_update(FlaxAutoModelForVisionaSeq, head_doc='vision-to-text modeling')





class 			_SCREAMING_SNAKE_CASE (   _BaseAutoModelClass		):







   '''simple docstring'''




   lowerCamelCase__				=      FLAX_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING




__A			:					Optional[int]						=			auto_class_update(
    FlaxAutoModelForSpeechSeqaSeq, head_doc='sequence-to-sequence speech-to-text modeling'
)