
'''simple docstring'''





import os
import tempfile
import unittest

import numpy as np
import torch

from diffusers.models import ModelMixin, UNetaDConditionModel
from diffusers.models.attention_processor import AttnProcessor, LoRAAttnProcessor
from diffusers.utils import (
    floats_tensor,
    logging,
    skip_mps,
    torch_device,
)
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import enable_full_determinism

from .test_modeling_common import ModelTesterMixin, UNetTesterMixin


enable_full_determinism()

a__		: int  							=							logging.get_logger(__name__)





def 							snake_case				(		UpperCAmelCase   ,	UpperCAmelCase = True						)->      Optional[Any]:







      """simple docstring"""
      __A													=      {}
      for name in model.attn_processors.keys():
            __A													=      name.endswith('attn2.processor'						) and not (
                name.startswith('transformer_in'						) or 'temp_attentions' in name.split('.'						)
            )
            __A													=      model.config.cross_attention_dim if has_cross_attention else None
            if name.startswith('mid_block'						):
                  __A													=      model.config.block_out_channels[-1]
            elif name.startswith('up_blocks'						):
                  __A													=      int(name[len('up_blocks.'						)]						)
                  __A													=      list(reversed(model.config.block_out_channels						)						)[block_id]
            elif name.startswith('down_blocks'						):
                  __A													=      int(name[len('down_blocks.'						)]						)
                  __A													=      model.config.block_out_channels[block_id]
            elif name.startswith('transformer_in'						):
                  # Note that the `8 * ...` comes from: https://github.com/huggingface/diffusers/blob/7139f0e874f10b2463caa8cbd585762a309d12d6/src/diffusers/models/unet_3d_condition.py#L148
                  __A													=      8 * model.config.attention_head_dim

            __A													=      LoRAAttnProcessor(hidden_size=UpperCAmelCase   ,	cross_attention_dim=UpperCAmelCase						)
            __A													=      lora_attn_procs[name].to(model.device						)

            if mock_weights:
                  # add 1 to weights to mock trained weights
                  with torch.no_grad():
                        lora_attn_procs[name].to_q_lora.up.weight += 1
                        lora_attn_procs[name].to_k_lora.up.weight += 1
                        lora_attn_procs[name].to_v_lora.up.weight += 1
                        lora_attn_procs[name].to_out_lora.up.weight += 1

      return lora_attn_procs


@skip_mps
class 			UpperCamelCase__	(     SCREAMING_SNAKE_CASE   ,  SCREAMING_SNAKE_CASE   ,  unittest.TestCase):
 UpperCAmelCase__     :     List[str]    					=       UNetaDConditionModel
 UpperCAmelCase__     :     Dict    					=       'sample'






 @property
 def 						lowercase_    (      self	:List[Any]      )					->      List[Any]:







       '''simple docstring'''



       __A													=      4
       __A													=      4
       __A													=      4
       __A													=      (32, 32)

       __A													=      floats_tensor((batch_size, num_channels, num_frames) + sizes      ).to(_A      )
       __A													=      torch.tensor([10]      ).to(_A      )
       __A													=      floats_tensor((batch_size, 4, 32)      ).to(_A      )

       return {"sample": noise, "timestep": time_step, "encoder_hidden_states": encoder_hidden_states}






 @property
 def 						lowercase_    (      self	:int      )					->      List[Any]:







       '''simple docstring'''



       return (4, 4, 32, 32)






 @property
 def 						lowercase_    (      self	:List[str]      )					->      Any:







       '''simple docstring'''



       return (4, 4, 32, 32)






 def 						lowercase_    (      self	:Tuple      )					->      Any:







       '''simple docstring'''



       __A													=      {
           'block_out_channels': (32, 64),
           'down_block_types': (
               'CrossAttnDownBlock3D',
               'DownBlock3D',
           ),
           'up_block_types': ('UpBlock3D', 'CrossAttnUpBlock3D'),
           'cross_attention_dim': 32,
           'attention_head_dim': 8,
           'out_channels': 4,
           'in_channels': 4,
           'layers_per_block': 1,
           'sample_size': 32,
       }
       __A													=      self.dummy_input
       return init_dict, inputs_dict






 @unittest.skipIf(
     torch_device != 'cuda' or not is_xformers_available()						,					reason='XFormers attention is only available with CUDA and `xformers` installed'						,					)
 def 						lowercase_    (      self	:Tuple      )					->      str:







       '''simple docstring'''



       __A						,   __A													=      self.prepare_init_args_and_inputs_for_common()
       __A													=      self.model_class(**_A      )

       model.enable_xformers_memory_efficient_attention()

       assert (
           model.mid_block.attentions[0].transformer_blocks[0].attna.processor.__class__.__name__
           == "XFormersAttnProcessor"
       ), "xformers is not enabled"






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







       '''simple docstring'''



       __A						,   __A													=      self.prepare_init_args_and_inputs_for_common()

       __A													=      32

       __A													=      self.model_class(**_A      )
       model.to(_A      )
       model.eval()

       with torch.no_grad():
             __A													=      model(**_A      )

             if isinstance(_A						,					_A      ):
                   __A													=      output.sample

       self.assertIsNotNone(_A      )
       __A													=      inputs_dict['sample'].shape
       self.assertEqual(output.shape						,					_A						,					'Input and output shapes do not match'      )






 def 						lowercase_    (      self	:Optional[int]      )					->      Dict:







       '''simple docstring'''



       __A						,   __A													=      self.prepare_init_args_and_inputs_for_common()
       __A													=      self.model_class(**_A      )
       model.to(_A      )
       model.eval()

       with torch.no_grad():
             # Warmup pass when using mps (see #372)
             if torch_device == "mps" and isinstance(_A						,					_A      ):
                   model(**self.dummy_input      )

             __A													=      model(**_A      )
             if isinstance(_A						,					_A      ):
                   __A													=      first.sample

             __A													=      model(**_A      )
             if isinstance(_A						,					_A      ):
                   __A													=      second.sample

       __A													=      first.cpu().numpy()
       __A													=      second.cpu().numpy()
       __A													=      out_a[~np.isnan(_A      )]
       __A													=      out_a[~np.isnan(_A      )]
       __A													=      np.amax(np.abs(out_a - out_a      )      )
       self.assertLessEqual(_A						,					1E-5      )






 def 						lowercase_    (      self	:Optional[Any]      )					->      Dict:







       '''simple docstring'''



       __A						,   __A													=      self.prepare_init_args_and_inputs_for_common()

       __A													=      8

       __A													=      self.model_class(**_A      )
       model.to(_A      )
       model.eval()

       model.set_attention_slice('auto'      )
       with torch.no_grad():
             __A													=      model(**_A      )
       assert output is not None

       model.set_attention_slice('max'      )
       with torch.no_grad():
             __A													=      model(**_A      )
       assert output is not None

       model.set_attention_slice(2      )
       with torch.no_grad():
             __A													=      model(**_A      )
       assert output is not None






 def 						lowercase_    (      self	:Dict      )					->      Optional[Any]:







       '''simple docstring'''



       __A						,   __A													=      self.prepare_init_args_and_inputs_for_common()

       __A													=      8

       __A													=      self.model_class(**_A      )
       model.to(_A      )

       with torch.no_grad():
             __A													=      model(**_A      ).sample

       __A													=      create_lora_layers(_A      )

       # make sure we can set a list of attention processors
       model.set_attn_processor(_A      )
       model.to(_A      )

       # test that attn processors can be set to itself
       model.set_attn_processor(model.attn_processors      )

       with torch.no_grad():
             __A													=      model(**_A						,					cross_attention_kwargs={'scale': 0.0}      ).sample
             __A													=      model(**_A						,					cross_attention_kwargs={'scale': 0.5}      ).sample
             __A													=      model(**_A						,					cross_attention_kwargs={'scale': 0.5}      ).sample

       assert (samplea - samplea).abs().max() < 3E-3
       assert (samplea - samplea).abs().max() < 3E-3

       # sample 2 and sample 3 should be different
       assert (samplea - samplea).abs().max() > 3E-3






 def 						lowercase_    (      self	:List[str]      )					->      Any:







       '''simple docstring'''



       __A						,   __A													=      self.prepare_init_args_and_inputs_for_common()

       __A													=      8

       torch.manual_seed(0      )
       __A													=      self.model_class(**_A      )
       model.to(_A      )

       with torch.no_grad():
             __A													=      model(**_A      ).sample

       __A													=      create_lora_layers(_A      )
       model.set_attn_processor(_A      )

       with torch.no_grad():
             __A													=      model(**_A						,					cross_attention_kwargs={'scale': 0.5}      ).sample

       with tempfile.TemporaryDirectory() as tmpdirname:
             model.save_attn_procs(_A      )
             self.assertTrue(os.path.isfile(os.path.join(_A						,					'pytorch_lora_weights.bin'      )      )      )
             torch.manual_seed(0      )
             __A													=      self.model_class(**_A      )
             new_model.to(_A      )
             new_model.load_attn_procs(_A      )

       with torch.no_grad():
             __A													=      new_model(**_A						,					cross_attention_kwargs={'scale': 0.5}      ).sample

       assert (sample - new_sample).abs().max() < 1E-3

       # LoRA and no LoRA should NOT be the same
       assert (sample - old_sample).abs().max() > 1E-4






 def 						lowercase_    (      self	:Tuple      )					->      str:







       '''simple docstring'''



       __A						,   __A													=      self.prepare_init_args_and_inputs_for_common()

       __A													=      8

       torch.manual_seed(0      )
       __A													=      self.model_class(**_A      )
       model.to(_A      )

       with torch.no_grad():
             __A													=      model(**_A      ).sample

       __A													=      create_lora_layers(_A      )
       model.set_attn_processor(_A      )

       with torch.no_grad():
             __A													=      model(**_A						,					cross_attention_kwargs={'scale': 0.5}      ).sample

       with tempfile.TemporaryDirectory() as tmpdirname:
             model.save_attn_procs(_A						,					safe_serialization=_A      )
             self.assertTrue(os.path.isfile(os.path.join(_A						,					'pytorch_lora_weights.safetensors'      )      )      )
             torch.manual_seed(0      )
             __A													=      self.model_class(**_A      )
             new_model.to(_A      )
             new_model.load_attn_procs(_A      )

       with torch.no_grad():
             __A													=      new_model(**_A						,					cross_attention_kwargs={'scale': 0.5}      ).sample

       assert (sample - new_sample).abs().max() < 3E-3

       # LoRA and no LoRA should NOT be the same
       assert (sample - old_sample).abs().max() > 1E-4






 def 						lowercase_    (      self	:Any      )					->      Tuple:







       '''simple docstring'''



       __A						,   __A													=      self.prepare_init_args_and_inputs_for_common()

       __A													=      8

       torch.manual_seed(0      )
       __A													=      self.model_class(**_A      )
       model.to(_A      )

       __A													=      create_lora_layers(_A						,					mock_weights=_A      )
       model.set_attn_processor(_A      )
       # Saving as torch, properly reloads with directly filename
       with tempfile.TemporaryDirectory() as tmpdirname:
             model.save_attn_procs(_A      )
             self.assertTrue(os.path.isfile(os.path.join(_A						,					'pytorch_lora_weights.bin'      )      )      )
             torch.manual_seed(0      )
             __A													=      self.model_class(**_A      )
             new_model.to(_A      )
             new_model.load_attn_procs(_A						,					weight_name='pytorch_lora_weights.bin'      )






 def 						lowercase_    (      self	:Any      )					->      Union[str, Any]:







       '''simple docstring'''



       __A						,   __A													=      self.prepare_init_args_and_inputs_for_common()

       __A													=      8

       torch.manual_seed(0      )
       __A													=      self.model_class(**_A      )
       model.to(_A      )

       __A													=      create_lora_layers(_A						,					mock_weights=_A      )
       model.set_attn_processor(_A      )
       # Saving as torch, properly reloads with directly filename
       with tempfile.TemporaryDirectory() as tmpdirname:
             model.save_attn_procs(_A      )
             self.assertTrue(os.path.isfile(os.path.join(_A						,					'pytorch_lora_weights.bin'      )      )      )
             torch.manual_seed(0      )
             __A													=      self.model_class(**_A      )
             new_model.to(_A      )
             with self.assertRaises(_A      ) as e:
                   new_model.load_attn_procs(_A						,					use_safetensors=_A      )
             self.assertIn('Error no file named pytorch_lora_weights.safetensors'						,					str(e.exception      )      )






 def 						lowercase_    (      self	:List[Any]      )					->      str:







       '''simple docstring'''



       __A						,   __A													=      self.prepare_init_args_and_inputs_for_common()

       __A													=      8

       torch.manual_seed(0      )
       __A													=      self.model_class(**_A      )
       model.to(_A      )

       with torch.no_grad():
             __A													=      model(**_A      ).sample

       __A													=      create_lora_layers(_A      )
       model.set_attn_processor(_A      )

       with torch.no_grad():
             __A													=      model(**_A						,					cross_attention_kwargs={'scale': 0.0}      ).sample

       model.set_attn_processor(AttnProcessor()      )

       with torch.no_grad():
             __A													=      model(**_A      ).sample

       assert (sample - new_sample).abs().max() < 1E-4
       assert (sample - old_sample).abs().max() < 3E-3






 @unittest.skipIf(
     torch_device != 'cuda' or not is_xformers_available()						,					reason='XFormers attention is only available with CUDA and `xformers` installed'						,					)
 def 						lowercase_    (      self	:Tuple      )					->      Dict:







       '''simple docstring'''



       __A						,   __A													=      self.prepare_init_args_and_inputs_for_common()

       __A													=      4

       torch.manual_seed(0      )
       __A													=      self.model_class(**_A      )
       model.to(_A      )
       __A													=      create_lora_layers(_A      )
       model.set_attn_processor(_A      )

       # default
       with torch.no_grad():
             __A													=      model(**_A      ).sample

             model.enable_xformers_memory_efficient_attention()
             __A													=      model(**_A      ).sample

             model.disable_xformers_memory_efficient_attention()
             __A													=      model(**_A      ).sample

       assert (sample - on_sample).abs().max() < 1E-4
       assert (sample - off_sample).abs().max() < 1E-4






 def 						lowercase_    (      self	:str      )					->      Union[str, Any]:







       '''simple docstring'''



       __A						,   __A													=      self.prepare_init_args_and_inputs_for_common()
       __A													=      32

       __A													=      self.model_class(**_A      )
       model.to(_A      )
       model.eval()

       with torch.no_grad():
             __A													=      model(**_A      )[0]

       model.enable_forward_chunking()
       with torch.no_grad():
             __A													=      model(**_A      )[0]

       self.assertEqual(output.shape						,					output_a.shape						,					'Shape doesn\'t match'      )
       assert np.abs(output.cpu() - output_a.cpu()      ).max() < 1E-2


# (todo: sayakpaul) implement SLOW tests.










"""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__)





