


"""simple docstring"""






import collections
import inspect
import unittest

from transformers import DonutSwinConfig
from transformers.testing_utils import require_torch, slow, torch_device
from transformers.utils import is_torch_available

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


if is_torch_available():
 import torch
 from torch import nn

 from transformers import DonutSwinModel
 from transformers.models.donut.modeling_donut_swin import DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST


class 	A_       :





  """simple docstring"""

  def __init__(						self  ,					__UpperCAmelCase  ,					__UpperCAmelCase=13  ,					__UpperCAmelCase=32  ,					__UpperCAmelCase=2  ,					__UpperCAmelCase=3  ,					__UpperCAmelCase=16  ,					__UpperCAmelCase=[1, 2, 1]  ,					__UpperCAmelCase=[2, 2, 4]  ,					__UpperCAmelCase=2  ,					__UpperCAmelCase=2.0  ,					__UpperCAmelCase=True  ,					__UpperCAmelCase=0.0  ,					__UpperCAmelCase=0.0  ,					__UpperCAmelCase=0.1  ,					__UpperCAmelCase="gelu"  ,					__UpperCAmelCase=False  ,					__UpperCAmelCase=True  ,					__UpperCAmelCase=0.02  ,					__UpperCAmelCase=1E-5  ,					__UpperCAmelCase=True  ,					__UpperCAmelCase=None  ,					__UpperCAmelCase=True  ,					__UpperCAmelCase=10  ,					__UpperCAmelCase=8  ,					)				->					List[str]:
     a   :	List[Any]						=    parent
     a   :	List[Any]						=    batch_size
     a   :	List[Any]						=    image_size
     a   :	List[str]						=    patch_size
     a   :	Dict						=    num_channels
     a   :	int						=    embed_dim
     a   :	Optional[Any]						=    depths
     a   :	Optional[int]						=    num_heads
     a   :	int						=    window_size
     a   :	Optional[int]						=    mlp_ratio
     a   :	Union[str, Any]						=    qkv_bias
     a   :	str						=    hidden_dropout_prob
     a   :	Union[str, Any]						=    attention_probs_dropout_prob
     a   :	Union[str, Any]						=    drop_path_rate
     a   :	Optional[int]						=    hidden_act
     a   :	Optional[int]						=    use_absolute_embeddings
     a   :	Optional[Any]						=    patch_norm
     a   :	str						=    layer_norm_eps
     a   :	Union[str, Any]						=    initializer_range
     a   :	Any						=    is_training
     a   :	Dict						=    scope
     a   :	Optional[int]						=    use_labels
     a   :	Dict						=    type_sequence_label_size
     a   :	Optional[int]						=    encoder_stride
  def 							lowercase_     (						self						)				->					Optional[Any]:
     a   :	Tuple						=    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

     a   :	Union[str, Any]						=    None
     if self.use_labels:
        a   :	int						=    ids_tensor([self.batch_size]  ,					self.type_sequence_label_size						)

     a   :	str						=    self.get_config()

     return config, pixel_values, labels
  def 							lowercase_     (						self						)				->					Optional[int]:
     return DonutSwinConfig(
         image_size=self.image_size  ,					patch_size=self.patch_size  ,					num_channels=self.num_channels  ,					embed_dim=self.embed_dim  ,					depths=self.depths  ,					num_heads=self.num_heads  ,					window_size=self.window_size  ,					mlp_ratio=self.mlp_ratio  ,					qkv_bias=self.qkv_bias  ,					hidden_dropout_prob=self.hidden_dropout_prob  ,					attention_probs_dropout_prob=self.attention_probs_dropout_prob  ,					drop_path_rate=self.drop_path_rate  ,					hidden_act=self.hidden_act  ,					use_absolute_embeddings=self.use_absolute_embeddings  ,					path_norm=self.patch_norm  ,					layer_norm_eps=self.layer_norm_eps  ,					initializer_range=self.initializer_range  ,					encoder_stride=self.encoder_stride  ,					)
  def 							lowercase_     (						self  ,					__UpperCAmelCase  ,					__UpperCAmelCase  ,					__UpperCAmelCase						)				->					int:
     a   :	Optional[int]						=    DonutSwinModel(config=__UpperCAmelCase						)
     model.to(__UpperCAmelCase						)
     model.eval()
     a   :	str						=    model(__UpperCAmelCase						)

     a   :	Dict						=    ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths						) - 1))
     a   :	List[Any]						=    int(config.embed_dim * 2 ** (len(config.depths						) - 1)						)

     self.parent.assertEqual(result.last_hidden_state.shape  ,					(self.batch_size, expected_seq_len, expected_dim)						)






  def 							lowercase_     (						self						)				->					Tuple:
     a   :	List[str]						=    self.prepare_config_and_inputs()
     (
         (
         a
     )	, (
         a
     )	, (
         a
     )	, 
     )   :	int						=    config_and_inputs
     a   :	List[str]						=    {'pixel_values': pixel_values}
     return config, inputs_dict



@require_torch
class 	A_       (     _UpperCAmelCase      ,  _UpperCAmelCase      ,  unittest.TestCase   ):





  """simple docstring"""

  lowercase		:	Optional[Any]   =						(DonutSwinModel,) if is_torch_available() else ()
  lowercase		:	Optional[int]   =						{"feature-extraction": DonutSwinModel} if is_torch_available() else {}
  lowercase		:	int   =						True

  lowercase		:	Dict   =						False
  lowercase		:	List[str]   =						False
  lowercase		:	List[str]   =						False
  def 							lowercase_     (						self						)				->					List[str]:
     a   :	Optional[int]						=    DonutSwinModelTester(self						)
     a   :	Optional[int]						=    ConfigTester(self  ,					config_class=__UpperCAmelCase  ,					embed_dim=37						)
  def 							lowercase_     (						self						)				->					Tuple:
     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 							lowercase_     (						self						)				->					Tuple:
     return
  def 							lowercase_     (						self						)				->					str:
     a   :	Dict						=    self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*__UpperCAmelCase						)
  def 							lowercase_     (						self						)				->					List[Any]:
     # DonutSwin does not use inputs_embeds
     pass
  def 							lowercase_     (						self						)				->					str:
     a	, a   :	Any						=    self.model_tester.prepare_config_and_inputs_for_common()

     for model_class in self.all_model_classes:
        a   :	int						=    model_class(__UpperCAmelCase						)
        self.assertIsInstance(model.get_input_embeddings()  ,					(nn.Module)						)
        a   :	Tuple						=    model.get_output_embeddings()
        self.assertTrue(x is None or isinstance(__UpperCAmelCase  ,					nn.Linear						)						)
  def 							lowercase_     (						self						)				->					Optional[Any]:
     a	, a   :	List[Any]						=    self.model_tester.prepare_config_and_inputs_for_common()

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

        a   :	Dict						=    ['pixel_values']
        self.assertListEqual(arg_names[:1]  ,					__UpperCAmelCase						)
  def 							lowercase_     (						self						)				->					str:
     a	, a   :	Optional[int]						=    self.model_tester.prepare_config_and_inputs_for_common()
     a   :	List[str]						=    True

     for model_class in self.all_model_classes:
        a   :	Optional[Any]						=    True
        a   :	List[str]						=    False
        a   :	Optional[Any]						=    True
        a   :	List[str]						=    model_class(__UpperCAmelCase						)
        model.to(__UpperCAmelCase						)
        model.eval()
        with torch.no_grad():
           a   :	Union[str, Any]						=    model(**self._prepare_for_class(__UpperCAmelCase  ,					__UpperCAmelCase						)						)
        a   :	int						=    outputs.attentions
        a   :	Optional[Any]						=    len(self.model_tester.depths						)
        self.assertEqual(len(__UpperCAmelCase						)  ,					__UpperCAmelCase						)

        # check that output_attentions also work using config
        del inputs_dict["output_attentions"]
        a   :	Optional[int]						=    True
        a   :	List[str]						=    config.window_size**2
        a   :	Optional[Any]						=    model_class(__UpperCAmelCase						)
        model.to(__UpperCAmelCase						)
        model.eval()
        with torch.no_grad():
           a   :	Any						=    model(**self._prepare_for_class(__UpperCAmelCase  ,					__UpperCAmelCase						)						)
        a   :	Optional[Any]						=    outputs.attentions
        self.assertEqual(len(__UpperCAmelCase						)  ,					__UpperCAmelCase						)

        self.assertListEqual(
            list(attentions[0].shape[-3:]						)  ,					[self.model_tester.num_heads[0], window_size_squared, window_size_squared]  ,					)
        a   :	List[str]						=    len(__UpperCAmelCase						)

        # Check attention is always last and order is fine
        a   :	Union[str, Any]						=    True
        a   :	Union[str, Any]						=    True
        a   :	Optional[Any]						=    model_class(__UpperCAmelCase						)
        model.to(__UpperCAmelCase						)
        model.eval()
        with torch.no_grad():
           a   :	Any						=    model(**self._prepare_for_class(__UpperCAmelCase  ,					__UpperCAmelCase						)						)

        if hasattr(self.model_tester  ,					'num_hidden_states_types'						):
           a   :	Tuple						=    self.model_tester.num_hidden_states_types
        else:
           # also another +1 for reshaped_hidden_states
           a   :	List[str]						=    2
        self.assertEqual(out_len + added_hidden_states  ,					len(__UpperCAmelCase						)						)

        a   :	List[Any]						=    outputs.attentions

        self.assertEqual(len(__UpperCAmelCase						)  ,					__UpperCAmelCase						)

        self.assertListEqual(
            list(self_attentions[0].shape[-3:]						)  ,					[self.model_tester.num_heads[0], window_size_squared, window_size_squared]  ,					)
  def 							lowercase_     (						self  ,					__UpperCAmelCase  ,					__UpperCAmelCase  ,					__UpperCAmelCase  ,					__UpperCAmelCase						)				->					Dict:
     a   :	List[Any]						=    model_class(__UpperCAmelCase						)
     model.to(__UpperCAmelCase						)
     model.eval()

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

     a   :	Optional[int]						=    outputs.hidden_states

     a   :	Tuple						=    getattr(
         self.model_tester  ,					'expected_num_hidden_layers'  ,					len(self.model_tester.depths						) + 1						)
     self.assertEqual(len(__UpperCAmelCase						)  ,					__UpperCAmelCase						)

     # DonutSwin has a different seq_length
     a   :	Optional[int]						=    (
         config.patch_size
         if isinstance(config.patch_size  ,					collections.abc.Iterable						)
         else (config.patch_size, config.patch_size)
     )

     a   :	Any						=    (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

     self.assertListEqual(
         list(hidden_states[0].shape[-2:]						)  ,					[num_patches, self.model_tester.embed_dim]  ,					)

     a   :	List[Any]						=    outputs.reshaped_hidden_states
     self.assertEqual(len(__UpperCAmelCase						)  ,					__UpperCAmelCase						)

     a	, a	, a	, a   :	Any						=    reshaped_hidden_states[0].shape
     a   :	Union[str, Any]						=    (
         reshaped_hidden_states[0].view(__UpperCAmelCase  ,					__UpperCAmelCase  ,					height * width						).permute(0  ,					2  ,					1						)
     )
     self.assertListEqual(
         list(reshaped_hidden_states.shape[-2:]						)  ,					[num_patches, self.model_tester.embed_dim]  ,					)
  def 							lowercase_     (						self						)				->					Optional[int]:
     a	, a   :	Tuple						=    self.model_tester.prepare_config_and_inputs_for_common()

     a   :	Dict						=    (
         self.model_tester.image_size
         if isinstance(self.model_tester.image_size  ,					collections.abc.Iterable						)
         else (self.model_tester.image_size, self.model_tester.image_size)
     )

     for model_class in self.all_model_classes:
        a   :	Union[str, Any]						=    True
        self.check_hidden_states_output(__UpperCAmelCase  ,					__UpperCAmelCase  ,					__UpperCAmelCase  ,					__UpperCAmelCase						)

        # check that output_hidden_states also work using config
        del inputs_dict["output_hidden_states"]
        a   :	Optional[Any]						=    True

        self.check_hidden_states_output(__UpperCAmelCase  ,					__UpperCAmelCase  ,					__UpperCAmelCase  ,					__UpperCAmelCase						)
  def 							lowercase_     (						self						)				->					int:
     a	, a   :	int						=    self.model_tester.prepare_config_and_inputs_for_common()
     a   :	Union[str, Any]						=    3

     a   :	Optional[Any]						=    (
         self.model_tester.image_size
         if isinstance(self.model_tester.image_size  ,					collections.abc.Iterable						)
         else (self.model_tester.image_size, self.model_tester.image_size)
     )
     a   :	List[str]						=    (
         config.patch_size
         if isinstance(config.patch_size  ,					collections.abc.Iterable						)
         else (config.patch_size, config.patch_size)
     )

     a   :	Optional[Any]						=    image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
     a   :	List[str]						=    image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

     for model_class in self.all_model_classes:
        a   :	Optional[int]						=    True
        self.check_hidden_states_output(__UpperCAmelCase  ,					__UpperCAmelCase  ,					__UpperCAmelCase  ,					(padded_height, padded_width)						)

        # check that output_hidden_states also work using config
        del inputs_dict["output_hidden_states"]
        a   :	int						=    True
        self.check_hidden_states_output(__UpperCAmelCase  ,					__UpperCAmelCase  ,					__UpperCAmelCase  ,					(padded_height, padded_width)						)
  @slow
  def 							lowercase_     (						self						)				->					List[str]:
     for model_name in DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        a   :	Any						=    DonutSwinModel.from_pretrained(__UpperCAmelCase						)
        self.assertIsNotNone(__UpperCAmelCase						)






  def 							lowercase_     (						self						)				->					Tuple:
     a	, a   :	List[str]						=    self.model_tester.prepare_config_and_inputs_for_common()

     a   :	Optional[Any]						=    _config_zero_init(__UpperCAmelCase						)
     for model_class in self.all_model_classes:
        a   :	int						=    model_class(config=__UpperCAmelCase						)
        for name, param in model.named_parameters():
           if "embeddings" not in name and param.requires_grad:
              self.assertIn(
                  ((param.data.mean() * 1E9).round() / 1E9).item()  ,					[0.0, 1.0]  ,					msg=f'Parameter {name} of model {model_class} seems not properly initialized'  ,					)









"""simple docstring"""






from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_torch_available,
)


SCREAMING_SNAKE_CASE__				:  int						= {
    "auto_factory": ["get_values"],
    "configuration_auto": ["ALL_PRETRAINED_CONFIG_ARCHIVE_MAP", "CONFIG_MAPPING", "MODEL_NAMES_MAPPING", "AutoConfig"],
    "feature_extraction_auto": ["FEATURE_EXTRACTOR_MAPPING", "AutoFeatureExtractor"],
    "image_processing_auto": ["IMAGE_PROCESSOR_MAPPING", "AutoImageProcessor"],
    "processing_auto": ["PROCESSOR_MAPPING", "AutoProcessor"],
    "tokenization_auto": ["TOKENIZER_MAPPING", "AutoTokenizer"],
}

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 SCREAMING_SNAKE_CASE__				:  Optional[int]						= [
     "MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING",
     "MODEL_FOR_AUDIO_FRAME_CLASSIFICATION_MAPPING",
     "MODEL_FOR_AUDIO_XVECTOR_MAPPING",
     "MODEL_FOR_BACKBONE_MAPPING",
     "MODEL_FOR_CAUSAL_IMAGE_MODELING_MAPPING",
     "MODEL_FOR_CAUSAL_LM_MAPPING",
     "MODEL_FOR_CTC_MAPPING",
     "MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING",
     "MODEL_FOR_DEPTH_ESTIMATION_MAPPING",
     "MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING",
     "MODEL_FOR_IMAGE_SEGMENTATION_MAPPING",
     "MODEL_FOR_INSTANCE_SEGMENTATION_MAPPING",
     "MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING",
     "MODEL_FOR_MASKED_LM_MAPPING",
     "MODEL_FOR_MASK_GENERATION_MAPPING",
     "MODEL_FOR_MULTIPLE_CHOICE_MAPPING",
     "MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING",
     "MODEL_FOR_OBJECT_DETECTION_MAPPING",
     "MODEL_FOR_PRETRAINING_MAPPING",
     "MODEL_FOR_QUESTION_ANSWERING_MAPPING",
     "MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING",
     "MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING",
     "MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING",
     "MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING",
     "MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING",
     "MODEL_FOR_TEXT_ENCODING_MAPPING",
     "MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING",
     "MODEL_FOR_UNIVERSAL_SEGMENTATION_MAPPING",
     "MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING",
     "MODEL_FOR_VISION_2_SEQ_MAPPING",
     "MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING",
     "MODEL_MAPPING",
     "MODEL_WITH_LM_HEAD_MAPPING",
     "MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING",
     "MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING",
     "AutoModel",
     "AutoBackbone",
     "AutoModelForAudioClassification",
     "AutoModelForAudioFrameClassification",
     "AutoModelForAudioXVector",
     "AutoModelForCausalLM",
     "AutoModelForCTC",
     "AutoModelForDepthEstimation",
     "AutoModelForImageClassification",
     "AutoModelForImageSegmentation",
     "AutoModelForInstanceSegmentation",
     "AutoModelForMaskGeneration",
     "AutoModelForTextEncoding",
     "AutoModelForMaskedImageModeling",
     "AutoModelForMaskedLM",
     "AutoModelForMultipleChoice",
     "AutoModelForNextSentencePrediction",
     "AutoModelForObjectDetection",
     "AutoModelForPreTraining",
     "AutoModelForQuestionAnswering",
     "AutoModelForSemanticSegmentation",
     "AutoModelForSeq2SeqLM",
     "AutoModelForSequenceClassification",
     "AutoModelForSpeechSeq2Seq",
     "AutoModelForTableQuestionAnswering",
     "AutoModelForTokenClassification",
     "AutoModelForUniversalSegmentation",
     "AutoModelForVideoClassification",
     "AutoModelForVision2Seq",
     "AutoModelForVisualQuestionAnswering",
     "AutoModelForDocumentQuestionAnswering",
     "AutoModelWithLMHead",
     "AutoModelForZeroShotImageClassification",
     "AutoModelForZeroShotObjectDetection",
 ]

try:
 if not is_tf_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 SCREAMING_SNAKE_CASE__				:  int						= [
     "TF_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING",
     "TF_MODEL_FOR_CAUSAL_LM_MAPPING",
     "TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING",
     "TF_MODEL_FOR_MASK_GENERATION_MAPPING",
     "TF_MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING",
     "TF_MODEL_FOR_MASKED_LM_MAPPING",
     "TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING",
     "TF_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING",
     "TF_MODEL_FOR_PRETRAINING_MAPPING",
     "TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING",
     "TF_MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING",
     "TF_MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING",
     "TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING",
     "TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING",
     "TF_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING",
     "TF_MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING",
     "TF_MODEL_FOR_TEXT_ENCODING_MAPPING",
     "TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING",
     "TF_MODEL_FOR_VISION_2_SEQ_MAPPING",
     "TF_MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING",
     "TF_MODEL_MAPPING",
     "TF_MODEL_WITH_LM_HEAD_MAPPING",
     "TFAutoModel",
     "TFAutoModelForAudioClassification",
     "TFAutoModelForCausalLM",
     "TFAutoModelForImageClassification",
     "TFAutoModelForMaskedImageModeling",
     "TFAutoModelForMaskedLM",
     "TFAutoModelForMaskGeneration",
     "TFAutoModelForMultipleChoice",
     "TFAutoModelForNextSentencePrediction",
     "TFAutoModelForPreTraining",
     "TFAutoModelForDocumentQuestionAnswering",
     "TFAutoModelForQuestionAnswering",
     "TFAutoModelForSemanticSegmentation",
     "TFAutoModelForSeq2SeqLM",
     "TFAutoModelForSequenceClassification",
     "TFAutoModelForSpeechSeq2Seq",
     "TFAutoModelForTableQuestionAnswering",
     "TFAutoModelForTextEncoding",
     "TFAutoModelForTokenClassification",
     "TFAutoModelForVision2Seq",
     "TFAutoModelForZeroShotImageClassification",
     "TFAutoModelWithLMHead",
 ]

try:
 if not is_flax_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 SCREAMING_SNAKE_CASE__				:  Optional[int]						= [
     "FLAX_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING",
     "FLAX_MODEL_FOR_CAUSAL_LM_MAPPING",
     "FLAX_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING",
     "FLAX_MODEL_FOR_MASKED_LM_MAPPING",
     "FLAX_MODEL_FOR_MULTIPLE_CHOICE_MAPPING",
     "FLAX_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING",
     "FLAX_MODEL_FOR_PRETRAINING_MAPPING",
     "FLAX_MODEL_FOR_QUESTION_ANSWERING_MAPPING",
     "FLAX_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING",
     "FLAX_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING",
     "FLAX_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING",
     "FLAX_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING",
     "FLAX_MODEL_FOR_VISION_2_SEQ_MAPPING",
     "FLAX_MODEL_MAPPING",
     "FlaxAutoModel",
     "FlaxAutoModelForCausalLM",
     "FlaxAutoModelForImageClassification",
     "FlaxAutoModelForMaskedLM",
     "FlaxAutoModelForMultipleChoice",
     "FlaxAutoModelForNextSentencePrediction",
     "FlaxAutoModelForPreTraining",
     "FlaxAutoModelForQuestionAnswering",
     "FlaxAutoModelForSeq2SeqLM",
     "FlaxAutoModelForSequenceClassification",
     "FlaxAutoModelForSpeechSeq2Seq",
     "FlaxAutoModelForTokenClassification",
     "FlaxAutoModelForVision2Seq",
 ]


if TYPE_CHECKING:
 from .auto_factory import get_values
 from .configuration_auto import ALL_PRETRAINED_CONFIG_ARCHIVE_MAP, CONFIG_MAPPING, MODEL_NAMES_MAPPING, AutoConfig
 from .feature_extraction_auto import FEATURE_EXTRACTOR_MAPPING, AutoFeatureExtractor
 from .image_processing_auto import IMAGE_PROCESSOR_MAPPING, AutoImageProcessor
 from .processing_auto import PROCESSOR_MAPPING, AutoProcessor
 from .tokenization_auto import TOKENIZER_MAPPING, AutoTokenizer

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_auto import (
      MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING,
      MODEL_FOR_AUDIO_FRAME_CLASSIFICATION_MAPPING,
      MODEL_FOR_AUDIO_XVECTOR_MAPPING,
      MODEL_FOR_BACKBONE_MAPPING,
      MODEL_FOR_CAUSAL_IMAGE_MODELING_MAPPING,
      MODEL_FOR_CAUSAL_LM_MAPPING,
      MODEL_FOR_CTC_MAPPING,
      MODEL_FOR_DEPTH_ESTIMATION_MAPPING,
      MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING,
      MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
      MODEL_FOR_IMAGE_SEGMENTATION_MAPPING,
      MODEL_FOR_INSTANCE_SEGMENTATION_MAPPING,
      MODEL_FOR_MASK_GENERATION_MAPPING,
      MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING,
      MODEL_FOR_MASKED_LM_MAPPING,
      MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
      MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
      MODEL_FOR_OBJECT_DETECTION_MAPPING,
      MODEL_FOR_PRETRAINING_MAPPING,
      MODEL_FOR_QUESTION_ANSWERING_MAPPING,
      MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING,
      MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
      MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
      MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING,
      MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING,
      MODEL_FOR_TEXT_ENCODING_MAPPING,
      MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
      MODEL_FOR_UNIVERSAL_SEGMENTATION_MAPPING,
      MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING,
      MODEL_FOR_VISION_2_SEQ_MAPPING,
      MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING,
      MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING,
      MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING,
      MODEL_MAPPING,
      MODEL_WITH_LM_HEAD_MAPPING,
      AutoBackbone,
      AutoModel,
      AutoModelForAudioClassification,
      AutoModelForAudioFrameClassification,
      AutoModelForAudioXVector,
      AutoModelForCausalLM,
      AutoModelForCTC,
      AutoModelForDepthEstimation,
      AutoModelForDocumentQuestionAnswering,
      AutoModelForImageClassification,
      AutoModelForImageSegmentation,
      AutoModelForInstanceSegmentation,
      AutoModelForMaskedImageModeling,
      AutoModelForMaskedLM,
      AutoModelForMaskGeneration,
      AutoModelForMultipleChoice,
      AutoModelForNextSentencePrediction,
      AutoModelForObjectDetection,
      AutoModelForPreTraining,
      AutoModelForQuestionAnswering,
      AutoModelForSemanticSegmentation,
      AutoModelForSeqaSeqLM,
      AutoModelForSequenceClassification,
      AutoModelForSpeechSeqaSeq,
      AutoModelForTableQuestionAnswering,
      AutoModelForTextEncoding,
      AutoModelForTokenClassification,
      AutoModelForUniversalSegmentation,
      AutoModelForVideoClassification,
      AutoModelForVisionaSeq,
      AutoModelForVisualQuestionAnswering,
      AutoModelForZeroShotImageClassification,
      AutoModelForZeroShotObjectDetection,
      AutoModelWithLMHead,
  )

 try:
  if not is_tf_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_tf_auto import (
      TF_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING,
      TF_MODEL_FOR_CAUSAL_LM_MAPPING,
      TF_MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING,
      TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
      TF_MODEL_FOR_MASK_GENERATION_MAPPING,
      TF_MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING,
      TF_MODEL_FOR_MASKED_LM_MAPPING,
      TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
      TF_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
      TF_MODEL_FOR_PRETRAINING_MAPPING,
      TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
      TF_MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING,
      TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
      TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
      TF_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING,
      TF_MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING,
      TF_MODEL_FOR_TEXT_ENCODING_MAPPING,
      TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
      TF_MODEL_FOR_VISION_2_SEQ_MAPPING,
      TF_MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING,
      TF_MODEL_MAPPING,
      TF_MODEL_WITH_LM_HEAD_MAPPING,
      TFAutoModel,
      TFAutoModelForAudioClassification,
      TFAutoModelForCausalLM,
      TFAutoModelForDocumentQuestionAnswering,
      TFAutoModelForImageClassification,
      TFAutoModelForMaskedImageModeling,
      TFAutoModelForMaskedLM,
      TFAutoModelForMaskGeneration,
      TFAutoModelForMultipleChoice,
      TFAutoModelForNextSentencePrediction,
      TFAutoModelForPreTraining,
      TFAutoModelForQuestionAnswering,
      TFAutoModelForSemanticSegmentation,
      TFAutoModelForSeqaSeqLM,
      TFAutoModelForSequenceClassification,
      TFAutoModelForSpeechSeqaSeq,
      TFAutoModelForTableQuestionAnswering,
      TFAutoModelForTextEncoding,
      TFAutoModelForTokenClassification,
      TFAutoModelForVisionaSeq,
      TFAutoModelForZeroShotImageClassification,
      TFAutoModelWithLMHead,
  )

 try:
  if not is_flax_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_flax_auto import (
      FLAX_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING,
      FLAX_MODEL_FOR_CAUSAL_LM_MAPPING,
      FLAX_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
      FLAX_MODEL_FOR_MASKED_LM_MAPPING,
      FLAX_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
      FLAX_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
      FLAX_MODEL_FOR_PRETRAINING_MAPPING,
      FLAX_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
      FLAX_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
      FLAX_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
      FLAX_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING,
      FLAX_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
      FLAX_MODEL_FOR_VISION_2_SEQ_MAPPING,
      FLAX_MODEL_MAPPING,
      FlaxAutoModel,
      FlaxAutoModelForCausalLM,
      FlaxAutoModelForImageClassification,
      FlaxAutoModelForMaskedLM,
      FlaxAutoModelForMultipleChoice,
      FlaxAutoModelForNextSentencePrediction,
      FlaxAutoModelForPreTraining,
      FlaxAutoModelForQuestionAnswering,
      FlaxAutoModelForSeqaSeqLM,
      FlaxAutoModelForSequenceClassification,
      FlaxAutoModelForSpeechSeqaSeq,
      FlaxAutoModelForTokenClassification,
      FlaxAutoModelForVisionaSeq,
  )

else:
 import sys

 SCREAMING_SNAKE_CASE__				:  Optional[int]						= _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)





