
"""simple docstring"""






import inspect
import unittest

from transformers import SegformerConfig, is_torch_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device

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


if is_torch_available():
 import torch

 from transformers import (
     MODEL_MAPPING,
     SegformerForImageClassification,
     SegformerForSemanticSegmentation,
     SegformerModel,
 )
 from transformers.models.segformer.modeling_segformer import SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
 from PIL import Image

 from transformers import SegformerImageProcessor





class 				a__					(						A__       ):



     def  lowerCamelCase_						(							self :List[Any]   ):







      '''simple docstring'''



      UpperCamelCase_     :					List[str]   	=self.config_class(**self.inputs_dict   )
      self.parent.assertTrue(hasattr(_lowerCamelCase      ,  'hidden_sizes'   )   )
      self.parent.assertTrue(hasattr(_lowerCamelCase      ,  'num_attention_heads'   )   )
      self.parent.assertTrue(hasattr(_lowerCamelCase      ,  'num_encoder_blocks'   )   )





class 				a__					:



     def __init__(							self :Optional[int]      ,  _lowerCamelCase :List[Any]      ,  _lowerCamelCase :Optional[int]=13      ,  _lowerCamelCase :List[str]=64      ,  _lowerCamelCase :int=3      ,  _lowerCamelCase :int=4      ,  _lowerCamelCase :Tuple=[2, 2, 2, 2]      ,  _lowerCamelCase :Optional[Any]=[8, 4, 2, 1]      ,  _lowerCamelCase :Union[str, Any]=[16, 32, 64, 128]      ,  _lowerCamelCase :Dict=[1, 4, 8, 16]      ,  _lowerCamelCase :Optional[Any]=[1, 2, 4, 8]      ,  _lowerCamelCase :Tuple=True      ,  _lowerCamelCase :Any=True      ,  _lowerCamelCase :Union[str, Any]="gelu"      ,  _lowerCamelCase :Optional[Any]=0.1      ,  _lowerCamelCase :List[str]=0.1      ,  _lowerCamelCase :Dict=0.02      ,  _lowerCamelCase :int=3      ,  _lowerCamelCase :Optional[Any]=None      ,  ):







      '''simple docstring'''



      UpperCamelCase_     :					int   	=parent
      UpperCamelCase_     :					int   	=batch_size
      UpperCamelCase_     :					int   	=image_size
      UpperCamelCase_     :					Optional[int]   	=num_channels
      UpperCamelCase_     :					Optional[int]   	=num_encoder_blocks
      UpperCamelCase_     :					Optional[int]   	=sr_ratios
      UpperCamelCase_     :					str   	=depths
      UpperCamelCase_     :					Tuple   	=hidden_sizes
      UpperCamelCase_     :					List[Any]   	=downsampling_rates
      UpperCamelCase_     :					Optional[int]   	=num_attention_heads
      UpperCamelCase_     :					str   	=is_training
      UpperCamelCase_     :					str   	=use_labels
      UpperCamelCase_     :					int   	=hidden_act
      UpperCamelCase_     :					str   	=hidden_dropout_prob
      UpperCamelCase_     :					Optional[int]   	=attention_probs_dropout_prob
      UpperCamelCase_     :					List[Any]   	=initializer_range
      UpperCamelCase_     :					Tuple   	=num_labels
      UpperCamelCase_     :					List[Any]   	=scope



     def  lowerCamelCase_						(							self :Optional[Any]   ):







      '''simple docstring'''



      UpperCamelCase_     :					List[Any]   	=floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

      UpperCamelCase_     :					List[str]   	=None
      if self.use_labels:
       UpperCamelCase_     :					Tuple   	=ids_tensor([self.batch_size, self.image_size, self.image_size]      ,  self.num_labels   )

      UpperCamelCase_     :					str   	=self.get_config()
      return config, pixel_values, labels



     def  lowerCamelCase_						(							self :List[Any]   ):







      '''simple docstring'''



      return SegformerConfig(
          image_size=self.image_size      ,  num_channels=self.num_channels      ,  num_encoder_blocks=self.num_encoder_blocks      ,  depths=self.depths      ,  hidden_sizes=self.hidden_sizes      ,  num_attention_heads=self.num_attention_heads      ,  hidden_act=self.hidden_act      ,  hidden_dropout_prob=self.hidden_dropout_prob      ,  attention_probs_dropout_prob=self.attention_probs_dropout_prob      ,  initializer_range=self.initializer_range      ,  )



     def  lowerCamelCase_						(							self :int      ,  _lowerCamelCase :Dict      ,  _lowerCamelCase :str      ,  _lowerCamelCase :Union[str, Any]   ):







      '''simple docstring'''



      UpperCamelCase_     :					Any   	=SegformerModel(config=_lowerCamelCase   )
      model.to(_lowerCamelCase   )
      model.eval()
      UpperCamelCase_     :					List[Any]   	=model(_lowerCamelCase   )
      UpperCamelCase_     :					List[Any]   	=self.image_size // (self.downsampling_rates[-1] * 2)
      self.parent.assertEqual(
          result.last_hidden_state.shape      ,  (self.batch_size, self.hidden_sizes[-1], expected_height, expected_width)   )



     def  lowerCamelCase_						(							self :List[str]      ,  _lowerCamelCase :int      ,  _lowerCamelCase :Union[str, Any]      ,  _lowerCamelCase :List[str]   ):







      '''simple docstring'''



      UpperCamelCase_     :					Any   	=self.num_labels
      UpperCamelCase_     :					int   	=SegformerForSemanticSegmentation(_lowerCamelCase   )
      model.to(_lowerCamelCase   )
      model.eval()
      UpperCamelCase_     :					str   	=model(_lowerCamelCase   )
      self.parent.assertEqual(
          result.logits.shape      ,  (self.batch_size, self.num_labels, self.image_size // 4, self.image_size // 4)   )
      UpperCamelCase_     :					Optional[Any]   	=model(_lowerCamelCase      ,  labels=_lowerCamelCase   )
      self.parent.assertEqual(
          result.logits.shape      ,  (self.batch_size, self.num_labels, self.image_size // 4, self.image_size // 4)   )
      self.parent.assertGreater(result.loss      ,  0.0   )



     def  lowerCamelCase_						(							self :Tuple      ,  _lowerCamelCase :Optional[Any]      ,  _lowerCamelCase :Optional[int]      ,  _lowerCamelCase :List[Any]   ):







      '''simple docstring'''



      UpperCamelCase_     :					Tuple   	=1
      UpperCamelCase_     :					Dict   	=SegformerForSemanticSegmentation(config=_lowerCamelCase   )
      model.to(_lowerCamelCase   )
      model.eval()
      UpperCamelCase_     :					str   	=torch.randint(0      ,  1      ,  (self.batch_size, self.image_size, self.image_size)   ).to(_lowerCamelCase   )
      UpperCamelCase_     :					str   	=model(_lowerCamelCase      ,  labels=_lowerCamelCase   )
      self.parent.assertGreater(result.loss      ,  0.0   )




     def  lowerCamelCase_						(							self :List[str]   ):







      '''simple docstring'''



      UpperCamelCase_     :					Union[str, Any]   	=self.prepare_config_and_inputs()
      UpperCamelCase_	,     UpperCamelCase_	,     UpperCamelCase_     :					Optional[int]   	=config_and_inputs
      UpperCamelCase_     :					Optional[int]   	={'pixel_values': pixel_values}
      return config, inputs_dict





@require_torch
class 				a__					(						A__   ,							A__   ,							unittest.TestCase       ):
     UpperCAmelCase__         =      (
         (
             SegformerModel,
             SegformerForSemanticSegmentation,
             SegformerForImageClassification,
         )
         if is_torch_available()
         else ()
     )
     UpperCAmelCase__         =      (
         {
             '''feature-extraction''': SegformerModel,
             '''image-classification''': SegformerForImageClassification,
             '''image-segmentation''': SegformerForSemanticSegmentation,
         }
         if is_torch_available()
         else {}
     )

     UpperCAmelCase__         =      True
     UpperCAmelCase__         =      False
     UpperCAmelCase__         =      False
     UpperCAmelCase__         =      False



     def  lowerCamelCase_						(							self :List[Any]   ):







      '''simple docstring'''



      UpperCamelCase_     :					Dict   	=SegformerModelTester(self   )
      UpperCamelCase_     :					str   	=SegformerConfigTester(self      ,  config_class=_lowerCamelCase   )



     def  lowerCamelCase_						(							self :int   ):







      '''simple docstring'''



      self.config_tester.run_common_tests()



     def  lowerCamelCase_						(							self :int   ):







      '''simple docstring'''



      UpperCamelCase_     :					int   	=self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*_lowerCamelCase   )



     def  lowerCamelCase_						(							self :Optional[Any]   ):







      '''simple docstring'''



      UpperCamelCase_     :					str   	=self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_binary_image_segmentation(*_lowerCamelCase   )



     def  lowerCamelCase_						(							self :Dict   ):







      '''simple docstring'''



      UpperCamelCase_     :					Optional[int]   	=self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_segmentation(*_lowerCamelCase   )



     @unittest.skip('SegFormer does not use inputs_embeds'   )
     def  lowerCamelCase_						(							self :Optional[int]   ):







      '''simple docstring'''



      pass



     @unittest.skip('SegFormer does not have get_input_embeddings method and get_output_embeddings methods'   )
     def  lowerCamelCase_						(							self :Union[str, Any]   ):







      '''simple docstring'''



      pass



     def  lowerCamelCase_						(							self :Any   ):







      '''simple docstring'''



      UpperCamelCase_	,     UpperCamelCase_     :					Tuple   	=self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
       UpperCamelCase_     :					Any   	=model_class(_lowerCamelCase   )
       UpperCamelCase_     :					Union[str, Any]   	=inspect.signature(model.forward   )
       # signature.parameters is an OrderedDict => so arg_names order is deterministic
       UpperCamelCase_     :					Any   	=[*signature.parameters.keys()]

       UpperCamelCase_     :					Optional[int]   	=['pixel_values']
       self.assertListEqual(arg_names[:1]      ,  _lowerCamelCase   )



     def  lowerCamelCase_						(							self :int   ):







      '''simple docstring'''



      UpperCamelCase_	,     UpperCamelCase_     :					Optional[Any]   	=self.model_tester.prepare_config_and_inputs_for_common()
      UpperCamelCase_     :					Tuple   	=True

      for model_class in self.all_model_classes:
       UpperCamelCase_     :					int   	=True
       UpperCamelCase_     :					Union[str, Any]   	=False
       UpperCamelCase_     :					Tuple   	=True
       UpperCamelCase_     :					str   	=model_class(_lowerCamelCase   )
       model.to(_lowerCamelCase   )
       model.eval()
       with torch.no_grad():
        UpperCamelCase_     :					List[str]   	=model(**self._prepare_for_class(_lowerCamelCase      ,  _lowerCamelCase   )   )
       UpperCamelCase_     :					Optional[Any]   	=outputs.attentions

       UpperCamelCase_     :					Dict   	=sum(self.model_tester.depths   )
       self.assertEqual(len(_lowerCamelCase   )      ,  _lowerCamelCase   )

       # check that output_attentions also work using config
       del inputs_dict["output_attentions"]
       UpperCamelCase_     :					str   	=True
       UpperCamelCase_     :					Tuple   	=model_class(_lowerCamelCase   )
       model.to(_lowerCamelCase   )
       model.eval()
       with torch.no_grad():
        UpperCamelCase_     :					List[Any]   	=model(**self._prepare_for_class(_lowerCamelCase      ,  _lowerCamelCase   )   )
       UpperCamelCase_     :					Tuple   	=outputs.attentions

       self.assertEqual(len(_lowerCamelCase   )      ,  _lowerCamelCase   )

       # verify the first attentions (first block, first layer)
       UpperCamelCase_     :					int   	=(self.model_tester.image_size // 4) ** 2
       UpperCamelCase_     :					str   	=(self.model_tester.image_size // (4 * self.model_tester.sr_ratios[0])) ** 2
       self.assertListEqual(
           list(attentions[0].shape[-3:]   )      ,  [self.model_tester.num_attention_heads[0], expected_seq_len, expected_reduced_seq_len]      ,  )

       # verify the last attentions (last block, last layer)
       UpperCamelCase_     :					Optional[Any]   	=(self.model_tester.image_size // 32) ** 2
       UpperCamelCase_     :					Any   	=(self.model_tester.image_size // (32 * self.model_tester.sr_ratios[-1])) ** 2
       self.assertListEqual(
           list(attentions[-1].shape[-3:]   )      ,  [self.model_tester.num_attention_heads[-1], expected_seq_len, expected_reduced_seq_len]      ,  )
       UpperCamelCase_     :					str   	=len(_lowerCamelCase   )

       # Check attention is always last and order is fine
       UpperCamelCase_     :					str   	=True
       UpperCamelCase_     :					List[str]   	=True
       UpperCamelCase_     :					int   	=model_class(_lowerCamelCase   )
       model.to(_lowerCamelCase   )
       model.eval()
       with torch.no_grad():
        UpperCamelCase_     :					str   	=model(**self._prepare_for_class(_lowerCamelCase      ,  _lowerCamelCase   )   )

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

       UpperCamelCase_     :					Optional[Any]   	=outputs.attentions

       self.assertEqual(len(_lowerCamelCase   )      ,  _lowerCamelCase   )
       # verify the first attentions (first block, first layer)
       UpperCamelCase_     :					List[Any]   	=(self.model_tester.image_size // 4) ** 2
       UpperCamelCase_     :					Dict   	=(self.model_tester.image_size // (4 * self.model_tester.sr_ratios[0])) ** 2
       self.assertListEqual(
           list(self_attentions[0].shape[-3:]   )      ,  [self.model_tester.num_attention_heads[0], expected_seq_len, expected_reduced_seq_len]      ,  )



     def  lowerCamelCase_						(							self :Union[str, Any]   ):







      '''simple docstring'''



      def check_hidden_states_output(_lowerCamelCase :Optional[Any]      ,  _lowerCamelCase :List[Any]      ,  _lowerCamelCase :List[str]   ):
       UpperCamelCase_     :					Dict   	=model_class(_lowerCamelCase   )
       model.to(_lowerCamelCase   )
       model.eval()

       with torch.no_grad():
        UpperCamelCase_     :					List[str]   	=model(**self._prepare_for_class(_lowerCamelCase      ,  _lowerCamelCase   )   )

       UpperCamelCase_     :					Optional[int]   	=outputs.hidden_states

       UpperCamelCase_     :					List[Any]   	=self.model_tester.num_encoder_blocks
       self.assertEqual(len(_lowerCamelCase   )      ,  _lowerCamelCase   )

       # verify the first hidden states (first block)
       self.assertListEqual(
           list(hidden_states[0].shape[-3:]   )      ,  [
               self.model_tester.hidden_sizes[0],
               self.model_tester.image_size // 4,
               self.model_tester.image_size // 4,
           ]      ,  )

      UpperCamelCase_	,     UpperCamelCase_     :					str   	=self.model_tester.prepare_config_and_inputs_for_common()

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

       # check that output_hidden_states also work using config
       del inputs_dict["output_hidden_states"]
       UpperCamelCase_     :					Union[str, Any]   	=True

       check_hidden_states_output(_lowerCamelCase      ,  _lowerCamelCase      ,  _lowerCamelCase   )



     def  lowerCamelCase_						(							self :List[Any]   ):







      '''simple docstring'''



      if not self.model_tester.is_training:
       return

      UpperCamelCase_	,     UpperCamelCase_     :					str   	=self.model_tester.prepare_config_and_inputs_for_common()
      UpperCamelCase_     :					str   	=True

      for model_class in self.all_model_classes:
       if model_class in get_values(_lowerCamelCase   ):
        continue

       UpperCamelCase_     :					Union[str, Any]   	=model_class(_lowerCamelCase   )
       model.to(_lowerCamelCase   )
       model.train()
       UpperCamelCase_     :					Tuple   	=self._prepare_for_class(_lowerCamelCase      ,  _lowerCamelCase      ,  return_labels=_lowerCamelCase   )
       UpperCamelCase_     :					str   	=model(**_lowerCamelCase   ).loss
       loss.backward()



     @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'   )
     def  lowerCamelCase_						(							self :List[Any]   ):







      '''simple docstring'''



      pass




     @slow
     def  lowerCamelCase_						(							self :Tuple   ):







      '''simple docstring'''



      for model_name in SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       UpperCamelCase_     :					List[Any]   	=SegformerModel.from_pretrained(_lowerCamelCase   )
       self.assertIsNotNone(_lowerCamelCase   )




def       A_  (				):
 UpperCamelCase_     :					Tuple   	=Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'	)
 return image





@require_torch
class 				a__					(						unittest.TestCase       ):



     @slow
     def  lowerCamelCase_						(							self :int   ):







      '''simple docstring'''



      UpperCamelCase_     :					Tuple   	=SegformerImageProcessor(
          image_scale=(512, 512)      ,  keep_ratio=_lowerCamelCase      ,  align=_lowerCamelCase      ,  do_random_crop=_lowerCamelCase   )
      UpperCamelCase_     :					Dict   	=SegformerForSemanticSegmentation.from_pretrained('nvidia/segformer-b0-finetuned-ade-512-512'   ).to(
          _lowerCamelCase   )

      UpperCamelCase_     :					Dict   	=prepare_img()
      UpperCamelCase_     :					str   	=image_processor(images=_lowerCamelCase      ,  return_tensors='pt'   )
      UpperCamelCase_     :					int   	=encoded_inputs.pixel_values.to(_lowerCamelCase   )

      with torch.no_grad():
       UpperCamelCase_     :					Dict   	=model(_lowerCamelCase   )

      UpperCamelCase_     :					Union[str, Any]   	=torch.Size((1, model.config.num_labels, 128, 128)   )
      self.assertEqual(outputs.logits.shape      ,  _lowerCamelCase   )

      UpperCamelCase_     :					List[str]   	=torch.tensor(
          [
              [[-4.6310, -5.5232, -6.2356], [-5.1921, -6.1444, -6.5996], [-5.4424, -6.2790, -6.7574]],
              [[-12.1391, -13.3122, -13.9554], [-12.8732, -13.9352, -14.3563], [-12.9438, -13.8226, -14.2513]],
              [[-12.5134, -13.4686, -14.4915], [-12.8669, -14.4343, -14.7758], [-13.2523, -14.5819, -15.0694]],
          ]   ).to(_lowerCamelCase   )
      self.assertTrue(torch.allclose(outputs.logits[0, :3, :3, :3]      ,  _lowerCamelCase      ,  atol=1E-4   )   )



     @slow
     def  lowerCamelCase_						(							self :str   ):







      '''simple docstring'''



      UpperCamelCase_     :					int   	=SegformerImageProcessor(
          image_scale=(512, 512)      ,  keep_ratio=_lowerCamelCase      ,  align=_lowerCamelCase      ,  do_random_crop=_lowerCamelCase   )
      UpperCamelCase_     :					Any   	=SegformerForSemanticSegmentation.from_pretrained(
          'nvidia/segformer-b1-finetuned-cityscapes-1024-1024'   ).to(_lowerCamelCase   )

      UpperCamelCase_     :					Any   	=prepare_img()
      UpperCamelCase_     :					Tuple   	=image_processor(images=_lowerCamelCase      ,  return_tensors='pt'   )
      UpperCamelCase_     :					Any   	=encoded_inputs.pixel_values.to(_lowerCamelCase   )

      with torch.no_grad():
       UpperCamelCase_     :					Any   	=model(_lowerCamelCase   )

      UpperCamelCase_     :					Optional[int]   	=torch.Size((1, model.config.num_labels, 128, 128)   )
      self.assertEqual(outputs.logits.shape      ,  _lowerCamelCase   )

      UpperCamelCase_     :					Any   	=torch.tensor(
          [
              [[-13.5748, -13.9111, -12.6500], [-14.3500, -15.3683, -14.2328], [-14.7532, -16.0424, -15.6087]],
              [[-17.1651, -15.8725, -12.9653], [-17.2580, -17.3718, -14.8223], [-16.6058, -16.8783, -16.7452]],
              [[-3.6456, -3.0209, -1.4203], [-3.0797, -3.1959, -2.0000], [-1.8757, -1.9217, -1.6997]],
          ]   ).to(_lowerCamelCase   )
      self.assertTrue(torch.allclose(outputs.logits[0, :3, :3, :3]      ,  _lowerCamelCase      ,  atol=1E-1   )   )




     @slow
     def  lowerCamelCase_						(							self :List[str]   ):







      '''simple docstring'''



      UpperCamelCase_     :					int   	=SegformerImageProcessor(
          image_scale=(512, 512)      ,  keep_ratio=_lowerCamelCase      ,  align=_lowerCamelCase      ,  do_random_crop=_lowerCamelCase   )
      UpperCamelCase_     :					int   	=SegformerForSemanticSegmentation.from_pretrained('nvidia/segformer-b0-finetuned-ade-512-512'   ).to(
          _lowerCamelCase   )

      UpperCamelCase_     :					Any   	=prepare_img()
      UpperCamelCase_     :					int   	=image_processor(images=_lowerCamelCase      ,  return_tensors='pt'   )
      UpperCamelCase_     :					List[Any]   	=encoded_inputs.pixel_values.to(_lowerCamelCase   )

      with torch.no_grad():
       UpperCamelCase_     :					int   	=model(_lowerCamelCase   )

      UpperCamelCase_     :					int   	=outputs.logits.detach().cpu()

      UpperCamelCase_     :					Any   	=image_processor.post_process_semantic_segmentation(outputs=_lowerCamelCase      ,  target_sizes=[(500, 300)]   )
      UpperCamelCase_     :					Any   	=torch.Size((500, 300)   )
      self.assertEqual(segmentation[0].shape      ,  _lowerCamelCase   )

      UpperCamelCase_     :					Optional[Any]   	=image_processor.post_process_semantic_segmentation(outputs=_lowerCamelCase   )
      UpperCamelCase_     :					Any   	=torch.Size((128, 128)   )
      self.assertEqual(segmentation[0].shape      ,  _lowerCamelCase   )


"""simple docstring"""






from typing import TYPE_CHECKING

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


__SCREAMING_SNAKE_CASE							=     {
    'configuration_mega': ['MEGA_PRETRAINED_CONFIG_ARCHIVE_MAP', 'MegaConfig', 'MegaOnnxConfig'],
}

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __SCREAMING_SNAKE_CASE							=     [
     'MEGA_PRETRAINED_MODEL_ARCHIVE_LIST',
     'MegaForCausalLM',
     'MegaForMaskedLM',
     'MegaForMultipleChoice',
     'MegaForQuestionAnswering',
     'MegaForSequenceClassification',
     'MegaForTokenClassification',
     'MegaModel',
     'MegaPreTrainedModel',
 ]

if TYPE_CHECKING:
 from .configuration_mega import MEGA_PRETRAINED_CONFIG_ARCHIVE_MAP, MegaConfig, MegaOnnxConfig

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_mega import (
      MEGA_PRETRAINED_MODEL_ARCHIVE_LIST,
      MegaForCausalLM,
      MegaForMaskedLM,
      MegaForMultipleChoice,
      MegaForQuestionAnswering,
      MegaForSequenceClassification,
      MegaForTokenClassification,
      MegaModel,
      MegaPreTrainedModel,
  )

else:
 import sys

 __SCREAMING_SNAKE_CASE							=     _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
