import inspect
import tempfile
import unittest

from huggingface_hub import hf_hub_download

from transformers import is_torch_available
from transformers.testing_utils import is_flaky, 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


a_    					=       1E-4

if is_torch_available():
   import torch

   from transformers import AutoformerConfig, AutoformerForPrediction, AutoformerModel
   from transformers.models.autoformer.modeling_autoformer import AutoformerDecoder, AutoformerEncoder





@require_torch
class 		_lowercase						:

 def __init__( self	:							List[Any]   ,      snake_case	:							List[Any]   ,      snake_case	:							int=1_6   ,      snake_case	:							List[Any]=1_3   ,      snake_case	:							Union[str, Any]=7   ,      snake_case	:							List[Any]=1_4   ,      snake_case	:							List[str]=1_0   ,      snake_case	:							Dict=1_9   ,      snake_case	:							Tuple=5   ,      snake_case	:							Union[str, Any]=4   ,      snake_case	:							Dict=True   ,      snake_case	:							List[Any]=1_6   ,      snake_case	:							List[Any]=2   ,      snake_case	:							Dict=4   ,      snake_case	:							str=4   ,      snake_case	:							Union[str, Any]="gelu"   ,      snake_case	:							Union[str, Any]=0.1   ,      snake_case	:							Tuple=0.1   ,      snake_case	:							List[Any]=[1, 2, 3, 4, 5]   ,      snake_case	:							Optional[Any]=2_5   ,      snake_case	:							List[Any]=5   ,      )   ->						Optional[Any]:

  """simple docstring"""





  UpperCamelCase_					:						str =					d_model
  UpperCamelCase_					:						List[Any] =					parent
  UpperCamelCase_					:						List[str] =					batch_size
  UpperCamelCase_					:						Optional[int] =					prediction_length
  UpperCamelCase_					:						str =					context_length
  UpperCamelCase_					:						str =					cardinality
  UpperCamelCase_					:						Dict =					num_time_features
  UpperCamelCase_					:						Union[str, Any] =					lags_sequence
  UpperCamelCase_					:						int =					embedding_dimension
  UpperCamelCase_					:						int =					is_training
  UpperCamelCase_					:						Optional[Any] =					hidden_size
  UpperCamelCase_					:						Dict =					num_hidden_layers
  UpperCamelCase_					:						Optional[Any] =					num_attention_heads
  UpperCamelCase_					:						Any =					intermediate_size
  UpperCamelCase_					:						Dict =					hidden_act
  UpperCamelCase_					:						Optional[Any] =					hidden_dropout_prob
  UpperCamelCase_					:						int =					attention_probs_dropout_prob

  UpperCamelCase_					:						Optional[Any] =					context_length
  UpperCamelCase_					:						Tuple =					prediction_length + label_length
  UpperCamelCase_					:						Any =					label_length

  UpperCamelCase_					:						Tuple =					moving_average
  UpperCamelCase_					:						Optional[int] =					autocorrelation_factor

 def 						SCREAMING_SNAKE_CASE__   ( self	:							Optional[int]			)   ->						Any:

  """simple docstring"""





  return AutoformerConfig(
      d_model=self.d_model   ,      encoder_layers=self.num_hidden_layers   ,      decoder_layers=self.num_hidden_layers   ,      encoder_attention_heads=self.num_attention_heads   ,      decoder_attention_heads=self.num_attention_heads   ,      encoder_ffn_dim=self.intermediate_size   ,      decoder_ffn_dim=self.intermediate_size   ,      dropout=self.hidden_dropout_prob   ,      attention_dropout=self.attention_probs_dropout_prob   ,      prediction_length=self.prediction_length   ,      context_length=self.context_length   ,      label_length=self.label_length   ,      lags_sequence=self.lags_sequence   ,      num_time_features=self.num_time_features   ,      num_static_categorical_features=1   ,      cardinality=[self.cardinality]   ,      embedding_dimension=[self.embedding_dimension]   ,      moving_average=self.moving_average   ,      )

 def 						SCREAMING_SNAKE_CASE__   ( self	:							Dict   ,      snake_case	:							Dict			)   ->						Tuple:

  """simple docstring"""





  UpperCamelCase_					:						Union[str, Any] =					config.context_length + max(config.lags_sequence			)

  UpperCamelCase_					:						Union[str, Any] =					ids_tensor([self.batch_size, 1]   ,      config.cardinality[0]			)
  UpperCamelCase_					:						List[str] =					floats_tensor([self.batch_size, _past_length, config.num_time_features]			)
  UpperCamelCase_					:						List[str] =					floats_tensor([self.batch_size, _past_length]			)
  UpperCamelCase_					:						List[str] =					floats_tensor([self.batch_size, _past_length]			) > 0.5

  # decoder inputs
  UpperCamelCase_					:						List[str] =					floats_tensor([self.batch_size, config.prediction_length, config.num_time_features]			)
  UpperCamelCase_					:						Tuple =					floats_tensor([self.batch_size, config.prediction_length]			)

  UpperCamelCase_					:						int =					{
      'past_values': past_values,
      'static_categorical_features': static_categorical_features,
      'past_time_features': past_time_features,
      'past_observed_mask': past_observed_mask,
      'future_time_features': future_time_features,
      'future_values': future_values,
  }
  return inputs_dict

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

  """simple docstring"""





  UpperCamelCase_					:						List[str] =					self.get_config()
  UpperCamelCase_					:						Dict =					self.prepare_autoformer_inputs_dict(snake_case			)
  return config, inputs_dict

 def 						SCREAMING_SNAKE_CASE__   ( self	:							Any			)   ->						Optional[int]:

  """simple docstring"""





  UpperCamelCase_, UpperCamelCase_					:						Tuple =					self.prepare_config_and_inputs()
  return config, inputs_dict


 def 						SCREAMING_SNAKE_CASE__   ( self	:							int   ,      snake_case	:							Union[str, Any]   ,      snake_case	:							Optional[Any]			)   ->						List[str]:

  """simple docstring"""





  UpperCamelCase_					:						str =					AutoformerModel(config=snake_case			).to(snake_case			).eval()
  UpperCamelCase_					:						Tuple =					model(**snake_case			)

  UpperCamelCase_					:						Tuple =					outputs.encoder_last_hidden_state
  UpperCamelCase_					:						int =					outputs.last_hidden_state

  with tempfile.TemporaryDirectory() as tmpdirname:
   UpperCamelCase_					:						Optional[Any] =					model.get_encoder()
   encoder.save_pretrained(snake_case			)
   UpperCamelCase_					:						int =					AutoformerEncoder.from_pretrained(snake_case			).to(snake_case			)

  UpperCamelCase_, UpperCamelCase_, UpperCamelCase_, UpperCamelCase_, UpperCamelCase_					:						Dict =					model.create_network_inputs(**snake_case			)
  UpperCamelCase_, UpperCamelCase_					:						Union[str, Any] =					model.decomposition_layer(transformer_inputs[:, : config.context_length, ...]			)

  UpperCamelCase_					:						Any =					torch.cat(
      (transformer_inputs[:, : config.context_length, ...], feature[:, : config.context_length, ...])   ,      dim=-1   ,      )
  UpperCamelCase_					:						Union[str, Any] =					encoder(inputs_embeds=snake_case			)[0]
  self.parent.assertTrue((encoder_last_hidden_state_a - encoder_last_hidden_state).abs().max().item() < 1e-3			)

  UpperCamelCase_					:						str =					(
      torch.mean(transformer_inputs[:, : config.context_length, ...]   ,      dim=1			)
      .unsqueeze(1			)
      .repeat(1   ,      config.prediction_length   ,      1			)
  )
  UpperCamelCase_					:						Union[str, Any] =					torch.zeros(
      [transformer_inputs.shape[0], config.prediction_length, transformer_inputs.shape[2]]   ,      device=enc_input.device   ,      )

  UpperCamelCase_					:						str =					torch.cat(
      (
          torch.cat((seasonal_input[:, -config.label_length :, ...], zeros)   ,      dim=1			),
          feature[:, config.context_length - config.label_length :, ...],
      )   ,      dim=-1   ,      )
  UpperCamelCase_					:						Any =					torch.cat(
      (
          torch.cat((trend_input[:, -config.label_length :, ...], mean)   ,      dim=1			),
          feature[:, config.context_length - config.label_length :, ...],
      )   ,      dim=-1   ,      )

  with tempfile.TemporaryDirectory() as tmpdirname:
   UpperCamelCase_					:						str =					model.get_decoder()
   decoder.save_pretrained(snake_case			)
   UpperCamelCase_					:						List[Any] =					AutoformerDecoder.from_pretrained(snake_case			).to(snake_case			)

  UpperCamelCase_					:						Dict =					decoder(
      trend=snake_case   ,      inputs_embeds=snake_case   ,      encoder_hidden_states=snake_case   ,      )[0]

  self.parent.assertTrue((last_hidden_state_a - last_hidden_state).abs().max().item() < 1e-3			)





@require_torch
class 		_lowercase						(					snake_case_						,      snake_case_						,      unittest.TestCase       ):
 lowercase				     =   (AutoformerModel, AutoformerForPrediction) if is_torch_available() else ()
 lowercase				     =   (AutoformerForPrediction,) if is_torch_available() else ()
 lowercase				     =   {'feature-extraction': AutoformerModel} if is_torch_available() else {}
 lowercase				     =   False
 lowercase				     =   False
 lowercase				     =   False
 lowercase				     =   False
 lowercase				     =   False
 lowercase				     =   False

 def 						SCREAMING_SNAKE_CASE__   ( self	:							Optional[Any]			)   ->						str:

  """simple docstring"""





  UpperCamelCase_					:						Tuple =					AutoformerModelTester(self			)
  UpperCamelCase_					:						Any =					ConfigTester(self   ,      config_class=snake_case   ,      has_text_modality=snake_case			)

 def 						SCREAMING_SNAKE_CASE__   ( self	:							List[str]			)   ->						Tuple:

  """simple docstring"""





  self.config_tester.run_common_tests()

 def 						SCREAMING_SNAKE_CASE__   ( self	:							Tuple			)   ->						List[Any]:

  """simple docstring"""





  UpperCamelCase_, UpperCamelCase_					:						Optional[int] =					self.model_tester.prepare_config_and_inputs()
  for model_class in self.all_model_classes:
   UpperCamelCase_					:						Dict =					model_class(snake_case			)

   with tempfile.TemporaryDirectory() as tmpdirname:
    model.save_pretrained(snake_case			)
    UpperCamelCase_, UpperCamelCase_					:						Union[str, Any] =					model_class.from_pretrained(snake_case   ,      output_loading_info=snake_case			)
   self.assertEqual(info['missing_keys']   ,      []			)

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

  """simple docstring"""





  UpperCamelCase_					:						List[Any] =					self.model_tester.prepare_config_and_inputs_for_common()
  self.model_tester.check_encoder_decoder_model_standalone(*snake_case			)

 @unittest.skip(reason='Model has no tokens embeddings'			)
 def 						SCREAMING_SNAKE_CASE__   ( self	:							Optional[Any]			)   ->						str:

  """simple docstring"""





  pass

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

  """simple docstring"""





  UpperCamelCase_					:						str =					inspect.signature(getattr(snake_case   ,      'forward'			)			)
  # The main input is the name of the argument after `self`
  UpperCamelCase_					:						int =					list(model_signature.parameters.keys()			)[1]
  self.assertEqual(AutoformerModel.main_input_name   ,      snake_case			)

 def 						SCREAMING_SNAKE_CASE__   ( self	:							Dict			)   ->						int:

  """simple docstring"""





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

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

   UpperCamelCase_					:						Any =					[
       'past_values',
       'past_time_features',
       'past_observed_mask',
       'static_categorical_features',
       'static_real_features',
       'future_values',
       'future_time_features',
   ]

   if model.__class__.__name__ in ["AutoformerForPrediction"]:
    expected_arg_names.append('future_observed_mask'			)

   expected_arg_names.extend(
       [
           'decoder_attention_mask',
           'head_mask',
           'decoder_head_mask',
           'cross_attn_head_mask',
           'encoder_outputs',
           'past_key_values',
           'output_hidden_states',
           'output_attentions',
           'use_cache',
           'return_dict',
       ]			)

   self.assertListEqual(arg_names[: len(snake_case			)]   ,      snake_case			)

 def 						SCREAMING_SNAKE_CASE__   ( self	:							Optional[int]			)   ->						List[str]:

  """simple docstring"""





  UpperCamelCase_, UpperCamelCase_					:						Optional[int] =					self.model_tester.prepare_config_and_inputs_for_common()
  UpperCamelCase_					:						str =					True

  UpperCamelCase_					:						Dict =					getattr(self.model_tester   ,      'seq_length'   ,      snake_case			)
  UpperCamelCase_					:						Optional[Any] =					getattr(self.model_tester   ,      'decoder_seq_length'   ,      snake_case			)
  UpperCamelCase_					:						Optional[int] =					getattr(self.model_tester   ,      'encoder_seq_length'   ,      snake_case			)
  UpperCamelCase_					:						Optional[Any] =					getattr(self.model_tester   ,      'd_model'   ,      snake_case			)
  UpperCamelCase_					:						Optional[int] =					getattr(self.model_tester   ,      'num_attention_heads'   ,      snake_case			)
  UpperCamelCase_					:						int =					d_model // num_attention_heads

  for model_class in self.all_model_classes:
   UpperCamelCase_					:						int =					True
   UpperCamelCase_					:						List[Any] =					False
   UpperCamelCase_					:						int =					True
   UpperCamelCase_					:						Any =					model_class(snake_case			)
   model.to(snake_case			)
   model.eval()
   with torch.no_grad():
    UpperCamelCase_					:						Optional[int] =					model(**self._prepare_for_class(snake_case   ,      snake_case			)			)
   UpperCamelCase_					:						str =					outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
   self.assertEqual(len(snake_case			)   ,      self.model_tester.num_hidden_layers			)

   # check that output_attentions also work using config
   del inputs_dict["output_attentions"]
   UpperCamelCase_					:						Union[str, Any] =					True
   UpperCamelCase_					:						int =					model_class(snake_case			)
   model.to(snake_case			)
   model.eval()
   with torch.no_grad():
    UpperCamelCase_					:						Optional[Any] =					model(**self._prepare_for_class(snake_case   ,      snake_case			)			)
   UpperCamelCase_					:						str =					outputs.encoder_attentions
   self.assertEqual(len(snake_case			)   ,      self.model_tester.num_hidden_layers			)

   self.assertListEqual(
       list(attentions[0].shape[-3:]			)   ,      [self.model_tester.num_attention_heads, encoder_seq_length, dim]   ,      )
   UpperCamelCase_					:						Optional[int] =					len(snake_case			)

   UpperCamelCase_					:						str =					7

   if "last_hidden_state" in outputs:
    correct_outlen += 1

   if "trend" in outputs:
    correct_outlen += 1

   if "past_key_values" in outputs:
    correct_outlen += 1  # past_key_values have been returned

   if "loss" in outputs:
    correct_outlen += 1

   if "params" in outputs:
    correct_outlen += 1

   self.assertEqual(snake_case   ,      snake_case			)

   # decoder attentions
   UpperCamelCase_					:						Dict =					outputs.decoder_attentions
   self.assertIsInstance(snake_case   ,      (list, tuple)			)
   self.assertEqual(len(snake_case			)   ,      self.model_tester.num_hidden_layers			)
   self.assertListEqual(
       list(decoder_attentions[0].shape[-3:]			)   ,      [self.model_tester.num_attention_heads, decoder_seq_length, dim]   ,      )

   # cross attentions
   UpperCamelCase_					:						Tuple =					outputs.cross_attentions
   self.assertIsInstance(snake_case   ,      (list, tuple)			)
   self.assertEqual(len(snake_case			)   ,      self.model_tester.num_hidden_layers			)
   self.assertListEqual(
       list(cross_attentions[0].shape[-3:]			)   ,      [self.model_tester.num_attention_heads, decoder_seq_length, dim]   ,      )

  # Check attention is always last and order is fine
  UpperCamelCase_					:						Tuple =					True
  UpperCamelCase_					:						int =					True
  UpperCamelCase_					:						Dict =					model_class(snake_case			)
  model.to(snake_case			)
  model.eval()
  with torch.no_grad():
   UpperCamelCase_					:						Any =					model(**self._prepare_for_class(snake_case   ,      snake_case			)			)

  self.assertEqual(out_len + 2   ,      len(snake_case			)			)

  UpperCamelCase_					:						str =					outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions

  self.assertEqual(len(snake_case			)   ,      self.model_tester.num_hidden_layers			)
  self.assertListEqual(
      list(self_attentions[0].shape[-3:]			)   ,      [self.model_tester.num_attention_heads, encoder_seq_length, dim]   ,      )


 @is_flaky()
 def 						SCREAMING_SNAKE_CASE__   ( self	:							Optional[Any]			)   ->						List[Any]:

  """simple docstring"""





  super().test_retain_grad_hidden_states_attentions()





def    __lowercase     (						lowerCamelCase					:     int="train-batch.pt"	):
 UpperCamelCase_					:						str =					hf_hub_download(repo_id='hf-internal-testing/tourism-monthly-batch'  ,  filename=lowerCamelCase  ,  repo_type='dataset'	)
 UpperCamelCase_					:						Tuple =					torch.load(lowerCamelCase  ,  map_location=lowerCamelCase	)
 return batch






@require_torch
@slow
class 		_lowercase						(					unittest.TestCase       ):

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

  """simple docstring"""





  UpperCamelCase_					:						Optional[Any] =					AutoformerModel.from_pretrained('huggingface/autoformer-tourism-monthly'			).to(snake_case			)
  UpperCamelCase_					:						List[str] =					prepare_batch()

  with torch.no_grad():
   UpperCamelCase_					:						int =					model(
       past_values=batch['past_values']   ,      past_time_features=batch['past_time_features']   ,      past_observed_mask=batch['past_observed_mask']   ,      static_categorical_features=batch['static_categorical_features']   ,      future_values=batch['future_values']   ,      future_time_features=batch['future_time_features']   ,      )[0]

  UpperCamelCase_					:						Optional[Any] =					torch.Size(
      (6_4, model.config.prediction_length + model.config.label_length, model.config.feature_size)			)
  self.assertEqual(output.shape   ,      snake_case			)

  UpperCamelCase_					:						List[str] =					torch.tensor(
      [[0.3593, -1.3398, 0.6330], [0.2279, 1.5396, -0.1792], [0.0450, 1.3225, -0.2335]]   ,      device=snake_case			)
  self.assertTrue(torch.allclose(output[0, :3, :3]   ,      snake_case   ,      atol=snake_case			)			)

 def 						SCREAMING_SNAKE_CASE__   ( self	:							int			)   ->						Optional[Any]:

  """simple docstring"""





  UpperCamelCase_					:						List[Any] =					AutoformerForPrediction.from_pretrained('huggingface/autoformer-tourism-monthly'			).to(snake_case			)
  UpperCamelCase_					:						Optional[int] =					prepare_batch('val-batch.pt'			)
  with torch.no_grad():
   UpperCamelCase_					:						str =					model(
       past_values=batch['past_values']   ,      past_time_features=batch['past_time_features']   ,      past_observed_mask=batch['past_observed_mask']   ,      static_categorical_features=batch['static_categorical_features']   ,      ).encoder_last_hidden_state
  UpperCamelCase_					:						Union[str, Any] =					torch.Size((6_4, model.config.context_length, model.config.d_model)			)
  self.assertEqual(output.shape   ,      snake_case			)

  UpperCamelCase_					:						Dict =					torch.tensor(
      [[-0.0734, -0.9036, 0.8358], [4.7186, 2.4113, 1.9581], [1.7953, 2.3558, 1.2970]]   ,      device=snake_case			)
  self.assertTrue(torch.allclose(output[0, :3, :3]   ,      snake_case   ,      atol=snake_case			)			)


 def 						SCREAMING_SNAKE_CASE__   ( self	:							Optional[int]			)   ->						Union[str, Any]:

  """simple docstring"""





  UpperCamelCase_					:						str =					AutoformerForPrediction.from_pretrained('huggingface/autoformer-tourism-monthly'			).to(snake_case			)
  UpperCamelCase_					:						Any =					prepare_batch('val-batch.pt'			)
  with torch.no_grad():
   UpperCamelCase_					:						List[str] =					model.generate(
       static_categorical_features=batch['static_categorical_features']   ,      past_time_features=batch['past_time_features']   ,      past_values=batch['past_values']   ,      future_time_features=batch['future_time_features']   ,      past_observed_mask=batch['past_observed_mask']   ,      )
  UpperCamelCase_					:						str =					torch.Size((6_4, model.config.num_parallel_samples, model.config.prediction_length)			)
  self.assertEqual(outputs.sequences.shape   ,      snake_case			)

  UpperCamelCase_					:						List[Any] =					torch.tensor([3130.6763, 4056.5293, 7053.0786]   ,      device=snake_case			)
  UpperCamelCase_					:						Optional[int] =					outputs.sequences.mean(dim=1			)
  self.assertTrue(torch.allclose(mean_prediction[0, -3:]   ,      snake_case   ,      rtol=1e-1			)			)




from typing import TYPE_CHECKING

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


a_    					=       {
    'configuration_efficientformer': [
        'EFFICIENTFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'EfficientFormerConfig',
    ]
}

try:
   if not is_vision_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   a_    					=       ['EfficientFormerImageProcessor']

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   a_    					=       [
       'EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST',
       'EfficientFormerForImageClassification',
       'EfficientFormerForImageClassificationWithTeacher',
       'EfficientFormerModel',
       'EfficientFormerPreTrainedModel',
   ]

try:
   if not is_tf_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   a_    					=       [
       'TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST',
       'TFEfficientFormerForImageClassification',
       'TFEfficientFormerForImageClassificationWithTeacher',
       'TFEfficientFormerModel',
       'TFEfficientFormerPreTrainedModel',
   ]

if TYPE_CHECKING:
   from .configuration_efficientformer import EFFICIENTFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, EfficientFormerConfig

   try:
      if not is_vision_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .image_processing_efficientformer import EfficientFormerImageProcessor

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_efficientformer import (
          EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
          EfficientFormerForImageClassification,
          EfficientFormerForImageClassificationWithTeacher,
          EfficientFormerModel,
          EfficientFormerPreTrainedModel,
      )
   try:
      if not is_tf_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_tf_efficientformer import (
          TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
          TFEfficientFormerForImageClassification,
          TFEfficientFormerForImageClassificationWithTeacher,
          TFEfficientFormerModel,
          TFEfficientFormerPreTrainedModel,
      )

else:
   import sys

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



