




'''simple docstring'''
import collections
import inspect
import unittest

from transformers import SwinConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_backbone_common import BackboneTesterMixin
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 SwinBackbone, SwinForImageClassification, SwinForMaskedImageModeling, SwinModel
  from transformers.models.swin.modeling_swin import SWIN_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
  from PIL import Image

  from transformers import AutoImageProcessor






class 	SCREAMING_SNAKE_CASE:

       def __init__(   self ,		lowerCamelCase__ ,		lowerCamelCase__=13 ,		lowerCamelCase__=32 ,		lowerCamelCase__=2 ,		lowerCamelCase__=3 ,		lowerCamelCase__=16 ,		lowerCamelCase__=[1, 2, 1] ,		lowerCamelCase__=[2, 2, 4] ,		lowerCamelCase__=2 ,		lowerCamelCase__=2.0 ,		lowerCamelCase__=True ,		lowerCamelCase__=0.0 ,		lowerCamelCase__=0.0 ,		lowerCamelCase__=0.1 ,		lowerCamelCase__="gelu" ,		lowerCamelCase__=False ,		lowerCamelCase__=True ,		lowerCamelCase__=0.02 ,		lowerCamelCase__=1E-5 ,		lowerCamelCase__=True ,		lowerCamelCase__=None ,		lowerCamelCase__=True ,		lowerCamelCase__=10 ,		lowerCamelCase__=8 ,		lowerCamelCase__=["stage1", "stage2"] ,		lowerCamelCase__=[1, 2] ,		)   -> Dict:

           """simple docstring"""



           __lowercase          =						parent
           __lowercase          =						batch_size
           __lowercase          =						image_size
           __lowercase          =						patch_size
           __lowercase          =						num_channels
           __lowercase          =						embed_dim
           __lowercase          =						depths
           __lowercase          =						num_heads
           __lowercase          =						window_size
           __lowercase          =						mlp_ratio
           __lowercase          =						qkv_bias
           __lowercase          =						hidden_dropout_prob
           __lowercase          =						attention_probs_dropout_prob
           __lowercase          =						drop_path_rate
           __lowercase          =						hidden_act
           __lowercase          =						use_absolute_embeddings
           __lowercase          =						patch_norm
           __lowercase          =						layer_norm_eps
           __lowercase          =						initializer_range
           __lowercase          =						is_training
           __lowercase          =						scope
           __lowercase          =						use_labels
           __lowercase          =						type_sequence_label_size
           __lowercase          =						encoder_stride
           __lowercase          =						out_features
           __lowercase          =						out_indices

       def    snake_case__      (   self					)   -> Optional[int]:

           """simple docstring"""



           __lowercase          =						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

           __lowercase          =						None
           if self.use_labels:
               __lowercase          =						ids_tensor([self.batch_size] ,		self.type_sequence_label_size					)

           __lowercase          =						self.get_config()

           return config, pixel_values, labels

       def    snake_case__      (   self					)   -> Tuple:

           """simple docstring"""



           return SwinConfig(
               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 ,		out_features=self.out_features ,		out_indices=self.out_indices ,		)

       def    snake_case__      (   self ,		lowerCamelCase__ ,		lowerCamelCase__ ,		lowerCamelCase__					)   -> int:

           """simple docstring"""



           __lowercase          =						SwinModel(config=lowerCamelCase__					)
           model.to(lowerCamelCase__					)
           model.eval()
           __lowercase          =						model(lowerCamelCase__					)

           __lowercase          =						((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths					) - 1))
           __lowercase          =						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    snake_case__      (   self ,		lowerCamelCase__ ,		lowerCamelCase__ ,		lowerCamelCase__					)   -> Union[str, Any]:

           """simple docstring"""



           __lowercase          =						SwinBackbone(config=lowerCamelCase__					)
           model.to(lowerCamelCase__					)
           model.eval()
           __lowercase          =						model(lowerCamelCase__					)

           # verify hidden states
           self.parent.assertEqual(len(result.feature_maps					) ,		len(config.out_features					)					)
           self.parent.assertListEqual(list(result.feature_maps[0].shape					) ,		[self.batch_size, model.channels[0], 16, 16]					)

           # verify channels
           self.parent.assertEqual(len(model.channels					) ,		len(config.out_features					)					)

           # verify backbone works with out_features=None
           __lowercase          =						None
           __lowercase          =						SwinBackbone(config=lowerCamelCase__					)
           model.to(lowerCamelCase__					)
           model.eval()
           __lowercase          =						model(lowerCamelCase__					)

           # verify feature maps
           self.parent.assertEqual(len(result.feature_maps					) ,		1					)
           self.parent.assertListEqual(list(result.feature_maps[0].shape					) ,		[self.batch_size, model.channels[-1], 4, 4]					)

           # verify channels
           self.parent.assertEqual(len(model.channels					) ,		1					)

       def    snake_case__      (   self ,		lowerCamelCase__ ,		lowerCamelCase__ ,		lowerCamelCase__					)   -> Optional[Any]:

           """simple docstring"""



           __lowercase          =						SwinForMaskedImageModeling(config=lowerCamelCase__					)
           model.to(lowerCamelCase__					)
           model.eval()
           __lowercase          =						model(lowerCamelCase__					)
           self.parent.assertEqual(
               result.logits.shape ,		(self.batch_size, self.num_channels, self.image_size, self.image_size)					)

           # test greyscale images
           __lowercase          =						1
           __lowercase          =						SwinForMaskedImageModeling(lowerCamelCase__					)
           model.to(lowerCamelCase__					)
           model.eval()

           __lowercase          =						floats_tensor([self.batch_size, 1, self.image_size, self.image_size]					)
           __lowercase          =						model(lowerCamelCase__					)
           self.parent.assertEqual(result.logits.shape ,		(self.batch_size, 1, self.image_size, self.image_size)					)

       def    snake_case__      (   self ,		lowerCamelCase__ ,		lowerCamelCase__ ,		lowerCamelCase__					)   -> Optional[int]:

           """simple docstring"""



           __lowercase          =						self.type_sequence_label_size
           __lowercase          =						SwinForImageClassification(lowerCamelCase__					)
           model.to(lowerCamelCase__					)
           model.eval()
           __lowercase          =						model(lowerCamelCase__ ,		labels=lowerCamelCase__					)
           self.parent.assertEqual(result.logits.shape ,		(self.batch_size, self.type_sequence_label_size)					)

           # test greyscale images
           __lowercase          =						1
           __lowercase          =						SwinForImageClassification(lowerCamelCase__					)
           model.to(lowerCamelCase__					)
           model.eval()

           __lowercase          =						floats_tensor([self.batch_size, 1, self.image_size, self.image_size]					)
           __lowercase          =						model(lowerCamelCase__					)
           self.parent.assertEqual(result.logits.shape ,		(self.batch_size, self.type_sequence_label_size)					)




       def    snake_case__      (   self					)   -> int:

           """simple docstring"""



           __lowercase          =						self.prepare_config_and_inputs()
           (
               (
               __lowercase
           )    ,(
               __lowercase
           )    ,(
               __lowercase
           )    ,
           )          =						config_and_inputs
           __lowercase          =						{"""pixel_values""": pixel_values}
           return config, inputs_dict






@require_torch
class 	SCREAMING_SNAKE_CASE(    __A       ,				__A       ,				unittest.TestCase					):
       snake_case_			:					Any   = (
           (
               SwinModel,
               SwinBackbone,
               SwinForImageClassification,
               SwinForMaskedImageModeling,
           )
           if is_torch_available()
           else ()
       )
       snake_case_			:					Any   = (
           {"""feature-extraction""": SwinModel, """image-classification""": SwinForImageClassification}
           if is_torch_available()
           else {}
       )
       snake_case_			:					Optional[Any]   = True

       snake_case_			:					Tuple   = False
       snake_case_			:					Optional[Any]   = False
       snake_case_			:					List[Any]   = False

       def    snake_case__      (   self					)   -> int:

           """simple docstring"""



           __lowercase          =						SwinModelTester(self					)
           __lowercase          =						ConfigTester(self ,		config_class=lowerCamelCase__ ,		embed_dim=37					)

       def    snake_case__      (   self					)   -> List[str]:

           """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    snake_case__      (   self					)   -> Tuple:

           """simple docstring"""



           return

       def    snake_case__      (   self					)   -> List[Any]:

           """simple docstring"""



           __lowercase          =						self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*lowerCamelCase__					)

       @unittest.skip(reason="""Got `CUDA error: misaligned address` with PyTorch 2.0.0."""					)
       def    snake_case__      (   self					)   -> Dict:

           """simple docstring"""



           pass

       def    snake_case__      (   self					)   -> Tuple:

           """simple docstring"""



           super().test_training_gradient_checkpointing()

       def    snake_case__      (   self					)   -> Optional[Any]:

           """simple docstring"""



           __lowercase          =						self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_backbone(*lowerCamelCase__					)

       def    snake_case__      (   self					)   -> List[Any]:

           """simple docstring"""



           __lowercase          =						self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_masked_image_modeling(*lowerCamelCase__					)

       def    snake_case__      (   self					)   -> List[Any]:

           """simple docstring"""



           __lowercase          =						self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_image_classification(*lowerCamelCase__					)

       @unittest.skip(reason="""Swin does not use inputs_embeds"""					)
       def    snake_case__      (   self					)   -> str:

           """simple docstring"""



           pass

       @unittest.skip(reason="""Swin Transformer does not use feedforward chunking"""					)
       def    snake_case__      (   self					)   -> Optional[Any]:

           """simple docstring"""



           pass

       def    snake_case__      (   self					)   -> str:

           """simple docstring"""



           __lowercase    ,__lowercase          =						self.model_tester.prepare_config_and_inputs_for_common()

           for model_class in self.all_model_classes:
               __lowercase          =						model_class(lowerCamelCase__					)
               self.assertIsInstance(model.get_input_embeddings() ,		(nn.Module)					)
               __lowercase          =						model.get_output_embeddings()
               self.assertTrue(x is None or isinstance(lowerCamelCase__ ,		nn.Linear					)					)

       def    snake_case__      (   self					)   -> int:

           """simple docstring"""



           __lowercase    ,__lowercase          =						self.model_tester.prepare_config_and_inputs_for_common()

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

               __lowercase          =						["""pixel_values"""]
               self.assertListEqual(arg_names[:1] ,		lowerCamelCase__					)

       def    snake_case__      (   self					)   -> Optional[int]:

           """simple docstring"""



           __lowercase    ,__lowercase          =						self.model_tester.prepare_config_and_inputs_for_common()
           __lowercase          =						True

           for model_class in self.all_model_classes:
               __lowercase          =						True
               __lowercase          =						False
               __lowercase          =						True
               __lowercase          =						model_class(lowerCamelCase__					)
               model.to(lowerCamelCase__					)
               model.eval()
               with torch.no_grad():
                   __lowercase          =						model(**self._prepare_for_class(lowerCamelCase__ ,		lowerCamelCase__					)					)
               __lowercase          =						outputs.attentions
               __lowercase          =						len(self.model_tester.depths					)
               self.assertEqual(len(lowerCamelCase__					) ,		lowerCamelCase__					)

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

               self.assertListEqual(
                   list(attentions[0].shape[-3:]					) ,		[self.model_tester.num_heads[0], window_size_squared, window_size_squared] ,		)
               __lowercase          =						len(lowerCamelCase__					)

               # Check attention is always last and order is fine
               __lowercase          =						True
               __lowercase          =						True
               __lowercase          =						model_class(lowerCamelCase__					)
               model.to(lowerCamelCase__					)
               model.eval()
               with torch.no_grad():
                   __lowercase          =						model(**self._prepare_for_class(lowerCamelCase__ ,		lowerCamelCase__					)					)

               # also another +1 for reshaped_hidden_states
               __lowercase          =						1 if model_class.__name__ == """SwinBackbone""" else 2
               self.assertEqual(out_len + added_hidden_states ,		len(lowerCamelCase__					)					)

               __lowercase          =						outputs.attentions

               self.assertEqual(len(lowerCamelCase__					) ,		lowerCamelCase__					)

               self.assertListEqual(
                   list(self_attentions[0].shape[-3:]					) ,		[self.model_tester.num_heads[0], window_size_squared, window_size_squared] ,		)

       def    snake_case__      (   self ,		lowerCamelCase__ ,		lowerCamelCase__ ,		lowerCamelCase__ ,		lowerCamelCase__					)   -> Any:

           """simple docstring"""



           __lowercase          =						model_class(lowerCamelCase__					)
           model.to(lowerCamelCase__					)
           model.eval()

           with torch.no_grad():
               __lowercase          =						model(**self._prepare_for_class(lowerCamelCase__ ,		lowerCamelCase__					)					)

           __lowercase          =						outputs.hidden_states

           __lowercase          =						getattr(
               self.model_tester ,		"""expected_num_hidden_layers""" ,		len(self.model_tester.depths					) + 1					)
           self.assertEqual(len(lowerCamelCase__					) ,		lowerCamelCase__					)

           # Swin has a different seq_length
           __lowercase          =						(
               config.patch_size
               if isinstance(config.patch_size ,		collections.abc.Iterable					)
               else (config.patch_size, config.patch_size)
           )

           __lowercase          =						(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] ,		)

           if not model_class.__name__ == "SwinBackbone":
               __lowercase          =						outputs.reshaped_hidden_states
               self.assertEqual(len(lowerCamelCase__					) ,		lowerCamelCase__					)

               __lowercase    ,__lowercase    ,__lowercase    ,__lowercase          =						reshaped_hidden_states[0].shape
               __lowercase          =						(
                   reshaped_hidden_states[0].view(lowerCamelCase__ ,		lowerCamelCase__ ,		height * width					).permute(0 ,		2 ,		1					)
               )
               self.assertListEqual(
                   list(reshaped_hidden_states.shape[-2:]					) ,		[num_patches, self.model_tester.embed_dim] ,		)

       def    snake_case__      (   self					)   -> List[Any]:

           """simple docstring"""



           __lowercase    ,__lowercase          =						self.model_tester.prepare_config_and_inputs_for_common()

           __lowercase          =						(
               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:
               __lowercase          =						True
               self.check_hidden_states_output(lowerCamelCase__ ,		lowerCamelCase__ ,		lowerCamelCase__ ,		lowerCamelCase__					)

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

               self.check_hidden_states_output(lowerCamelCase__ ,		lowerCamelCase__ ,		lowerCamelCase__ ,		lowerCamelCase__					)

       def    snake_case__      (   self					)   -> Optional[Any]:

           """simple docstring"""



           __lowercase    ,__lowercase          =						self.model_tester.prepare_config_and_inputs_for_common()
           __lowercase          =						3

           __lowercase          =						(
               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)
           )
           __lowercase          =						(
               config.patch_size
               if isinstance(config.patch_size ,		collections.abc.Iterable					)
               else (config.patch_size, config.patch_size)
           )

           __lowercase          =						image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
           __lowercase          =						image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

           for model_class in self.all_model_classes:
               __lowercase          =						True
               self.check_hidden_states_output(lowerCamelCase__ ,		lowerCamelCase__ ,		lowerCamelCase__ ,		(padded_height, padded_width)					)

               # check that output_hidden_states also work using config
               del inputs_dict["output_hidden_states"]
               __lowercase          =						True
               self.check_hidden_states_output(lowerCamelCase__ ,		lowerCamelCase__ ,		lowerCamelCase__ ,		(padded_height, padded_width)					)

       @slow
       def    snake_case__      (   self					)   -> Any:

           """simple docstring"""



           for model_name in SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               __lowercase          =						SwinModel.from_pretrained(lowerCamelCase__					)
               self.assertIsNotNone(lowerCamelCase__					)




       def    snake_case__      (   self					)   -> Dict:

           """simple docstring"""



           __lowercase    ,__lowercase          =						self.model_tester.prepare_config_and_inputs_for_common()

           __lowercase          =						_config_zero_init(lowerCamelCase__					)
           for model_class in self.all_model_classes:
               __lowercase          =						model_class(config=lowerCamelCase__					)
               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' ,		)






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

       @cached_property
       def    snake_case__      (   self					)   -> str:

           """simple docstring"""



           return (
               AutoImageProcessor.from_pretrained("""microsoft/swin-tiny-patch4-window7-224"""					)
               if is_vision_available()
               else None
           )




       @slow
       def    snake_case__      (   self					)   -> Optional[int]:

           """simple docstring"""



           __lowercase          =						SwinForImageClassification.from_pretrained("""microsoft/swin-tiny-patch4-window7-224"""					).to(lowerCamelCase__					)
           __lowercase          =						self.default_image_processor

           __lowercase          =						Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""					)
           __lowercase          =						image_processor(images=lowerCamelCase__ ,		return_tensors="""pt"""					).to(lowerCamelCase__					)

           # forward pass
           with torch.no_grad():
               __lowercase          =						model(**lowerCamelCase__					)

           # verify the logits
           __lowercase          =						torch.Size((1, 1000)					)
           self.assertEqual(outputs.logits.shape ,		lowerCamelCase__					)
           __lowercase          =						torch.tensor([-0.09_48, -0.64_54, -0.09_21]					).to(lowerCamelCase__					)
           self.assertTrue(torch.allclose(outputs.logits[0, :3] ,		lowerCamelCase__ ,		atol=1E-4					)					)






@require_torch
class 	SCREAMING_SNAKE_CASE(    unittest.TestCase       ,				__A					):
       snake_case_			:					Tuple   = (SwinBackbone,) if is_torch_available() else ()
       snake_case_			:					Dict   = SwinConfig

       def    snake_case__      (   self					)   -> Optional[Any]:

           """simple docstring"""



           __lowercase          =						SwinModelTester(self					)










'''simple docstring'''
from typing import TYPE_CHECKING

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


A							:				List[str]			     =	{
    """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:
  A							:				Optional[Any]			     =	[
      """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:
  A							:				Dict			     =	[
      """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:
  A							:				Tuple			     =	[
      """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

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




