



import inspect
import unittest

from transformers import SwinaSRConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import is_torch_available, is_vision_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 SwinaSRForImageSuperResolution, SwinaSRModel
		from transformers.models.swinasr.modeling_swinasr import SWIN2SR_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
		from PIL import Image

		from transformers import SwinaSRImageProcessor



class 	__lowerCAmelCase       :




	def __init__(  self		,			__UpperCAmelCase		,			__UpperCAmelCase=13		,			__UpperCAmelCase=32		,			__UpperCAmelCase=1		,			__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=False		,			__UpperCAmelCase=2		,			):



				'''simple docstring'''
				__lowerCamelCase  							=      parent
				__lowerCamelCase  							=      batch_size
				__lowerCamelCase  							=      image_size
				__lowerCamelCase  							=      patch_size
				__lowerCamelCase  							=      num_channels
				__lowerCamelCase  							=      embed_dim
				__lowerCamelCase  							=      depths
				__lowerCamelCase  							=      num_heads
				__lowerCamelCase  							=      window_size
				__lowerCamelCase  							=      mlp_ratio
				__lowerCamelCase  							=      qkv_bias
				__lowerCamelCase  							=      hidden_dropout_prob
				__lowerCamelCase  							=      attention_probs_dropout_prob
				__lowerCamelCase  							=      drop_path_rate
				__lowerCamelCase  							=      hidden_act
				__lowerCamelCase  							=      use_absolute_embeddings
				__lowerCamelCase  							=      patch_norm
				__lowerCamelCase  							=      layer_norm_eps
				__lowerCamelCase  							=      initializer_range
				__lowerCamelCase  							=      is_training
				__lowerCamelCase  							=      scope
				__lowerCamelCase  							=      use_labels
				__lowerCamelCase  							=      upscale

				# here we set some attributes to make tests pass
				__lowerCamelCase  							=      len(__UpperCAmelCase			)
				__lowerCamelCase  							=      embed_dim
				__lowerCamelCase  							=      (image_size // patch_size) ** 2




	def     lowerCamelCase (  self			):



				'''simple docstring'''
				__lowerCamelCase  							=      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]			)

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

				__lowerCamelCase  							=      self.get_config()

				return config, pixel_values, labels




	def     lowerCamelCase (  self			):



				'''simple docstring'''
				return SwinaSRConfig(
				    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		,			upscale=self.upscale		,			)




	def     lowerCamelCase (  self		,			__UpperCAmelCase		,			__UpperCAmelCase		,			__UpperCAmelCase			):



				'''simple docstring'''
				__lowerCamelCase  							=      SwinaSRModel(config=__UpperCAmelCase			)
				model.to(__UpperCAmelCase			)
				model.eval()
				__lowerCamelCase  							=      model(__UpperCAmelCase			)

				self.parent.assertEqual(
				    result.last_hidden_state.shape		,			(self.batch_size, self.embed_dim, self.image_size, self.image_size)			)




	def     lowerCamelCase (  self		,			__UpperCAmelCase		,			__UpperCAmelCase		,			__UpperCAmelCase			):



				'''simple docstring'''
				__lowerCamelCase  							=      SwinaSRForImageSuperResolution(__UpperCAmelCase			)
				model.to(__UpperCAmelCase			)
				model.eval()
				__lowerCamelCase  							=      model(__UpperCAmelCase			)

				__lowerCamelCase  							=      self.image_size * self.upscale
				self.parent.assertEqual(
				    result.reconstruction.shape		,			(self.batch_size, self.num_channels, expected_image_size, expected_image_size)			)




	def     lowerCamelCase (  self			):



				'''simple docstring'''
				__lowerCamelCase  							=      self.prepare_config_and_inputs()
				__lowerCamelCase							,__lowerCamelCase							,__lowerCamelCase  							=      config_and_inputs
				__lowerCamelCase  							=      {'''pixel_values''': pixel_values}
				return config, inputs_dict



@require_torch
class 	__lowerCAmelCase       (		lowerCAmelCase__					,		lowerCAmelCase__					,		unittest.TestCase				):
	lowerCAmelCase__       =					(SwinaSRModel, SwinaSRForImageSuperResolution) if is_torch_available() else ()
	lowerCAmelCase__       =					{"""feature-extraction""": SwinaSRModel} if is_torch_available() else {}

	lowerCAmelCase__       =					False
	lowerCAmelCase__       =					False
	lowerCAmelCase__       =					False
	lowerCAmelCase__       =					False
	lowerCAmelCase__       =					False




	def     lowerCamelCase (  self			):



				'''simple docstring'''
				__lowerCamelCase  							=      SwinaSRModelTester(self			)
				__lowerCamelCase  							=      ConfigTester(self		,			config_class=__UpperCAmelCase		,			embed_dim=37			)




	def     lowerCamelCase (  self			):



				'''simple docstring'''
				self.config_tester.create_and_test_config_to_json_string()
				self.config_tester.create_and_test_config_to_json_file()
				self.config_tester.create_and_test_config_from_and_save_pretrained()
				self.config_tester.create_and_test_config_with_num_labels()
				self.config_tester.check_config_can_be_init_without_params()
				self.config_tester.check_config_arguments_init()




	def     lowerCamelCase (  self			):



				'''simple docstring'''
				__lowerCamelCase  							=      self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_model(*__UpperCAmelCase			)




	def     lowerCamelCase (  self			):



				'''simple docstring'''
				__lowerCamelCase  							=      self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_image_super_resolution(*__UpperCAmelCase			)




	@unittest.skip(reason='''Got `CUDA error: misaligned address` with PyTorch 2.0.0.'''			)
	def     lowerCamelCase (  self			):



				'''simple docstring'''
				pass




	@unittest.skip(reason='''Swin2SR does not use inputs_embeds'''			)
	def     lowerCamelCase (  self			):



				'''simple docstring'''
				pass




	@unittest.skip(reason='''Swin2SR does not support training yet'''			)
	def     lowerCamelCase (  self			):



				'''simple docstring'''
				pass




	@unittest.skip(reason='''Swin2SR does not support training yet'''			)
	def     lowerCamelCase (  self			):



				'''simple docstring'''
				pass




	def     lowerCamelCase (  self			):



				'''simple docstring'''
				__lowerCamelCase							,__lowerCamelCase  							=      self.model_tester.prepare_config_and_inputs_for_common()

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




	def     lowerCamelCase (  self			):



				'''simple docstring'''
				__lowerCamelCase							,__lowerCamelCase  							=      self.model_tester.prepare_config_and_inputs_for_common()

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

							__lowerCamelCase  							=      ['''pixel_values''']
							self.assertListEqual(arg_names[:1]		,			__UpperCAmelCase			)




	@slow
	def     lowerCamelCase (  self			):



				'''simple docstring'''
				for model_name in SWIN2SR_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
							__lowerCamelCase  							=      SwinaSRModel.from_pretrained(__UpperCAmelCase			)
							self.assertIsNotNone(__UpperCAmelCase			)




	def     lowerCamelCase (  self			):



				'''simple docstring'''
				__lowerCamelCase							,__lowerCamelCase  							=      self.model_tester.prepare_config_and_inputs_for_common()

				__lowerCamelCase  							=      _config_zero_init(__UpperCAmelCase			)
				for model_class in self.all_model_classes:
							__lowerCamelCase  							=      model_class(config=__UpperCAmelCase			)
							for name, param in model.named_parameters():
										if "logit_scale" in name:
													continue
										if 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"""		,			)




	def     lowerCamelCase (  self			):



				'''simple docstring'''
				__lowerCamelCase							,__lowerCamelCase  							=      self.model_tester.prepare_config_and_inputs_for_common()
				__lowerCamelCase  							=      True

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

							# check that output_attentions also work using config
							del inputs_dict["output_attentions"]
							__lowerCamelCase  							=      True
							__lowerCamelCase  							=      config.window_size**2
							__lowerCamelCase  							=      model_class(__UpperCAmelCase			)
							model.to(__UpperCAmelCase			)
							model.eval()
							with torch.no_grad():
										__lowerCamelCase  							=      model(**self._prepare_for_class(__UpperCAmelCase		,			__UpperCAmelCase			)			)
							__lowerCamelCase  							=      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]		,			)
							__lowerCamelCase  							=      len(__UpperCAmelCase			)

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

							self.assertEqual(out_len + 1		,			len(__UpperCAmelCase			)			)

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



@require_vision
@require_torch
@slow
class 	__lowerCAmelCase       (		unittest.TestCase				):




	def     lowerCamelCase (  self			):



				'''simple docstring'''
				__lowerCamelCase  							=      SwinaSRImageProcessor()
				__lowerCamelCase  							=      SwinaSRForImageSuperResolution.from_pretrained('''caidas/swin2SR-classical-sr-x2-64'''			).to(__UpperCAmelCase			)

				__lowerCamelCase  							=      Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''			)
				__lowerCamelCase  							=      processor(images=__UpperCAmelCase		,			return_tensors='''pt'''			).to(__UpperCAmelCase			)

				# forward pass
				with torch.no_grad():
							__lowerCamelCase  							=      model(**__UpperCAmelCase			)

				# verify the logits
				__lowerCamelCase  							=      torch.Size([1, 3, 976, 1296]			)
				self.assertEqual(outputs.reconstruction.shape		,			__UpperCAmelCase			)
				__lowerCamelCase  							=      torch.tensor(
				    [[0.5_458, 0.5_546, 0.5_638], [0.5_526, 0.5_565, 0.5_651], [0.5_396, 0.5_426, 0.5_621]]			).to(__UpperCAmelCase			)
				self.assertTrue(torch.allclose(outputs.reconstruction[0, 0, :3, :3]		,			__UpperCAmelCase		,			atol=1E-4			)			)











from typing import TYPE_CHECKING

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


a_								=   {
    """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_								=   [
      """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_								=   [
      """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_								=   [
      """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_								=   _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)






