'''simple docstring'''






import collections
import inspect
import unittest

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

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


if is_torch_available():
    import torch
    from torch import nn

    from transformers import (
        FocalNetBackbone,
        FocalNetForImageClassification,
        FocalNetForMaskedImageModeling,
        FocalNetModel,
    )
    from transformers.models.focalnet.modeling_focalnet import FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
    from PIL import Image

    from transformers import AutoImageProcessor




class    a :



  """simple docstring"""







  def __init__(							self   ,    snake_case_   ,    snake_case_=13   ,    snake_case_=32   ,    snake_case_=2   ,    snake_case_=3   ,    snake_case_=16   ,    snake_case_=[32, 64, 128]   ,    snake_case_=[1, 2, 1]   ,    snake_case_=[2, 2, 4]   ,    snake_case_=2   ,    snake_case_=2.0   ,    snake_case_=True   ,    snake_case_=0.0   ,    snake_case_=0.0   ,    snake_case_=0.1   ,    snake_case_="gelu"   ,    snake_case_=False   ,    snake_case_=True   ,    snake_case_=0.0_2   ,    snake_case_=1e-5   ,    snake_case_=True   ,    snake_case_=None   ,    snake_case_=True   ,    snake_case_=10   ,    snake_case_=8   ,    snake_case_=["stage1", "stage2"]   ,    snake_case_=[1, 2]   ,    ):

    '''simple docstring'''







    __UpperCAmelCase:					Optional[int]		= parent
    __UpperCAmelCase:					Optional[int]		= batch_size
    __UpperCAmelCase:					str		= image_size
    __UpperCAmelCase:					Any		= patch_size
    __UpperCAmelCase:					Optional[int]		= num_channels
    __UpperCAmelCase:					str		= embed_dim
    __UpperCAmelCase:					str		= hidden_sizes
    __UpperCAmelCase:					Optional[Any]		= depths
    __UpperCAmelCase:					Tuple		= num_heads
    __UpperCAmelCase:					Optional[int]		= window_size
    __UpperCAmelCase:					Union[str, Any]		= mlp_ratio
    __UpperCAmelCase:					Dict		= qkv_bias
    __UpperCAmelCase:					Dict		= hidden_dropout_prob
    __UpperCAmelCase:					Tuple		= attention_probs_dropout_prob
    __UpperCAmelCase:					Optional[Any]		= drop_path_rate
    __UpperCAmelCase:					str		= hidden_act
    __UpperCAmelCase:					Dict		= use_absolute_embeddings
    __UpperCAmelCase:					Optional[int]		= patch_norm
    __UpperCAmelCase:					List[str]		= layer_norm_eps
    __UpperCAmelCase:					Tuple		= initializer_range
    __UpperCAmelCase:					Optional[Any]		= is_training
    __UpperCAmelCase:					Union[str, Any]		= scope
    __UpperCAmelCase:					Tuple		= use_labels
    __UpperCAmelCase:					Tuple		= type_sequence_label_size
    __UpperCAmelCase:					str		= encoder_stride
    __UpperCAmelCase:					List[str]		= out_features
    __UpperCAmelCase:					Union[str, Any]		= out_indices







  def    lowercase_  (							self					):

    '''simple docstring'''







    __UpperCAmelCase:					Optional[int]		= floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

    __UpperCAmelCase:					Tuple		= None
    if self.use_labels:
      __UpperCAmelCase:					Dict		= ids_tensor([self.batch_size]   ,    self.type_sequence_label_size					)

    __UpperCAmelCase:					Optional[Any]		= self.get_config()

    return config, pixel_values, labels







  def    lowercase_  (							self					):

    '''simple docstring'''







    return FocalNetConfig(
        image_size=self.image_size   ,    patch_size=self.patch_size   ,    num_channels=self.num_channels   ,    embed_dim=self.embed_dim   ,    hidden_sizes=self.hidden_sizes   ,    depths=self.depths   ,    num_heads=self.num_heads   ,    window_size=self.window_size   ,    mlp_ratio=self.mlp_ratio   ,    qkv_bias=self.qkv_bias   ,    hidden_dropout_prob=self.hidden_dropout_prob   ,    attention_probs_dropout_prob=self.attention_probs_dropout_prob   ,    drop_path_rate=self.drop_path_rate   ,    hidden_act=self.hidden_act   ,    use_absolute_embeddings=self.use_absolute_embeddings   ,    path_norm=self.patch_norm   ,    layer_norm_eps=self.layer_norm_eps   ,    initializer_range=self.initializer_range   ,    encoder_stride=self.encoder_stride   ,    out_features=self.out_features   ,    out_indices=self.out_indices   ,    )







  def    lowercase_  (							self   ,    snake_case_   ,    snake_case_   ,    snake_case_					):

    '''simple docstring'''







    __UpperCAmelCase:					Optional[Any]		= FocalNetModel(config=snake_case_					)
    model.to(snake_case_					)
    model.eval()
    __UpperCAmelCase:					List[Any]		= model(snake_case_					)

    __UpperCAmelCase:					str		= ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths					) - 1))
    __UpperCAmelCase:					List[Any]		= int(config.embed_dim * 2 ** (len(config.depths					) - 1)					)

    self.parent.assertEqual(result.last_hidden_state.shape   ,    (self.batch_size, expected_seq_len, expected_dim)					)







  def    lowercase_  (							self   ,    snake_case_   ,    snake_case_   ,    snake_case_					):

    '''simple docstring'''







    __UpperCAmelCase:					Any		= FocalNetBackbone(config=snake_case_					)
    model.to(snake_case_					)
    model.eval()
    __UpperCAmelCase:					Any		= model(snake_case_					)

    # verify feature maps
    self.parent.assertEqual(len(result.feature_maps					)   ,    len(config.out_features					)					)
    self.parent.assertListEqual(list(result.feature_maps[0].shape					)   ,    [self.batch_size, self.image_size, 8, 8]					)

    # verify channels
    self.parent.assertEqual(len(model.channels					)   ,    len(config.out_features					)					)
    self.parent.assertListEqual(model.channels   ,    config.hidden_sizes[:-1]					)

    # verify backbone works with out_features=None
    __UpperCAmelCase:					Dict		= None
    __UpperCAmelCase:					Tuple		= FocalNetBackbone(config=snake_case_					)
    model.to(snake_case_					)
    model.eval()
    __UpperCAmelCase:					Dict		= model(snake_case_					)

    # verify feature maps
    self.parent.assertEqual(len(result.feature_maps					)   ,    1					)
    self.parent.assertListEqual(list(result.feature_maps[0].shape					)   ,    [self.batch_size, self.image_size * 2, 4, 4]					)

    # verify channels
    self.parent.assertEqual(len(model.channels					)   ,    1					)
    self.parent.assertListEqual(model.channels   ,    [config.hidden_sizes[-1]]					)







  def    lowercase_  (							self   ,    snake_case_   ,    snake_case_   ,    snake_case_					):

    '''simple docstring'''







    __UpperCAmelCase:					Dict		= FocalNetForMaskedImageModeling(config=snake_case_					)
    model.to(snake_case_					)
    model.eval()
    __UpperCAmelCase:					List[str]		= model(snake_case_					)
    self.parent.assertEqual(
        result.reconstruction.shape   ,    (self.batch_size, self.num_channels, self.image_size, self.image_size)					)

    # test greyscale images
    __UpperCAmelCase:					Any		= 1
    __UpperCAmelCase:					int		= FocalNetForMaskedImageModeling(snake_case_					)
    model.to(snake_case_					)
    model.eval()

    __UpperCAmelCase:					Optional[Any]		= floats_tensor([self.batch_size, 1, self.image_size, self.image_size]					)
    __UpperCAmelCase:					List[str]		= model(snake_case_					)
    self.parent.assertEqual(result.reconstruction.shape   ,    (self.batch_size, 1, self.image_size, self.image_size)					)







  def    lowercase_  (							self   ,    snake_case_   ,    snake_case_   ,    snake_case_					):

    '''simple docstring'''







    __UpperCAmelCase:					List[Any]		= self.type_sequence_label_size
    __UpperCAmelCase:					int		= FocalNetForImageClassification(snake_case_					)
    model.to(snake_case_					)
    model.eval()
    __UpperCAmelCase:					Optional[int]		= model(snake_case_   ,    labels=snake_case_					)
    self.parent.assertEqual(result.logits.shape   ,    (self.batch_size, self.type_sequence_label_size)					)

    # test greyscale images
    __UpperCAmelCase:					List[str]		= 1
    __UpperCAmelCase:					str		= FocalNetForImageClassification(snake_case_					)
    model.to(snake_case_					)
    model.eval()

    __UpperCAmelCase:					str		= floats_tensor([self.batch_size, 1, self.image_size, self.image_size]					)
    __UpperCAmelCase:					List[str]		= model(snake_case_					)
    self.parent.assertEqual(result.logits.shape   ,    (self.batch_size, self.type_sequence_label_size)					)







  def    lowercase_  (							self					):

    '''simple docstring'''







    __UpperCAmelCase:					str		= self.prepare_config_and_inputs()

    __UpperCAmelCase, __UpperCAmelCase, __UpperCAmelCase:					Tuple		= config_and_inputs
    __UpperCAmelCase:					Any		= {"""pixel_values""": pixel_values}
    return config, inputs_dict




@require_torch
class    a (       __lowerCAmelCase						,  __lowerCAmelCase						,  unittest.TestCase				):



  """simple docstring"""
  __lowerCAmelCase				      =					(
      (
          FocalNetModel,
          FocalNetForImageClassification,
          FocalNetForMaskedImageModeling,
          FocalNetBackbone,
      )
      if is_torch_available()
      else ()
  )
  __lowerCAmelCase				      =					(
      {"""feature-extraction""": FocalNetModel, """image-classification""": FocalNetForImageClassification}
      if is_torch_available()
      else {}
  )
  __lowerCAmelCase				      =					False

  __lowerCAmelCase				      =					False
  __lowerCAmelCase				      =					False
  __lowerCAmelCase				      =					False
  __lowerCAmelCase				      =					False







  def    lowercase_  (							self					):

    '''simple docstring'''







    __UpperCAmelCase:					int		= FocalNetModelTester(self					)
    __UpperCAmelCase:					Dict		= ConfigTester(self   ,    config_class=snake_case_   ,    embed_dim=37   ,    has_text_modality=snake_case_					)







  def    lowercase_  (							self					):

    '''simple docstring'''







    self.create_and_test_config_common_properties()
    self.config_tester.create_and_test_config_to_json_string()
    self.config_tester.create_and_test_config_to_json_file()
    self.config_tester.create_and_test_config_from_and_save_pretrained()
    self.config_tester.create_and_test_config_with_num_labels()
    self.config_tester.check_config_can_be_init_without_params()
    self.config_tester.check_config_arguments_init()







  def    lowercase_  (							self					):

    '''simple docstring'''







    return







  def    lowercase_  (							self					):

    '''simple docstring'''







    __UpperCAmelCase:					str		= self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_model(*snake_case_					)







  def    lowercase_  (							self					):

    '''simple docstring'''







    __UpperCAmelCase:					int		= self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_backbone(*snake_case_					)







  def    lowercase_  (							self					):

    '''simple docstring'''







    __UpperCAmelCase:					Optional[Any]		= self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_masked_image_modeling(*snake_case_					)







  def    lowercase_  (							self					):

    '''simple docstring'''







    __UpperCAmelCase:					Union[str, Any]		= self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_image_classification(*snake_case_					)







  @unittest.skip(reason="""FocalNet does not use inputs_embeds"""					)
  def    lowercase_  (							self					):

    '''simple docstring'''







    pass







  @unittest.skip(reason="""FocalNet does not use feedforward chunking"""					)
  def    lowercase_  (							self					):

    '''simple docstring'''







    pass







  def    lowercase_  (							self					):

    '''simple docstring'''







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

    for model_class in self.all_model_classes[:-1]:
      __UpperCAmelCase:					List[str]		= model_class(snake_case_					)
      self.assertIsInstance(model.get_input_embeddings()   ,    (nn.Module)					)
      __UpperCAmelCase:					Union[str, Any]		= model.get_output_embeddings()
      self.assertTrue(x is None or isinstance(snake_case_   ,    nn.Linear					)					)







  def    lowercase_  (							self					):

    '''simple docstring'''







    __UpperCAmelCase, __UpperCAmelCase:					List[str]		= self.model_tester.prepare_config_and_inputs_for_common()

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

      __UpperCAmelCase:					Union[str, Any]		= ["""pixel_values"""]
      self.assertListEqual(arg_names[:1]   ,    snake_case_					)







  def    lowercase_  (							self   ,    snake_case_   ,    snake_case_   ,    snake_case_   ,    snake_case_					):

    '''simple docstring'''







    __UpperCAmelCase:					Any		= model_class(snake_case_					)
    model.to(snake_case_					)
    model.eval()

    with torch.no_grad():
      __UpperCAmelCase:					Dict		= model(**self._prepare_for_class(snake_case_   ,    snake_case_					)					)

    __UpperCAmelCase:					List[Any]		= outputs.hidden_states

    __UpperCAmelCase:					Optional[Any]		= getattr(
        self.model_tester   ,    """expected_num_hidden_layers"""   ,    len(self.model_tester.depths					) + 1					)
    self.assertEqual(len(snake_case_					)   ,    snake_case_					)

    # FocalNet has a different seq_length
    __UpperCAmelCase:					Dict		= (
        config.patch_size
        if isinstance(config.patch_size   ,    collections.abc.Iterable					)
        else (config.patch_size, config.patch_size)
    )

    __UpperCAmelCase:					Optional[int]		= (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

    self.assertListEqual(
        list(hidden_states[0].shape[-2:]					)   ,    [num_patches, self.model_tester.embed_dim]   ,    )

    __UpperCAmelCase:					int		= outputs.reshaped_hidden_states
    self.assertEqual(len(snake_case_					)   ,    snake_case_					)

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







  def    lowercase_  (							self					):

    '''simple docstring'''







    __UpperCAmelCase, __UpperCAmelCase:					List[Any]		= self.model_tester.prepare_config_and_inputs_for_common()

    __UpperCAmelCase:					List[str]		= (
        self.model_tester.image_size
        if isinstance(self.model_tester.image_size   ,    collections.abc.Iterable					)
        else (self.model_tester.image_size, self.model_tester.image_size)
    )

    for model_class in self.all_model_classes[:-1]:
      __UpperCAmelCase:					List[str]		= True
      self.check_hidden_states_output(snake_case_   ,    snake_case_   ,    snake_case_   ,    snake_case_					)

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

      self.check_hidden_states_output(snake_case_   ,    snake_case_   ,    snake_case_   ,    snake_case_					)







  def    lowercase_  (							self					):

    '''simple docstring'''







    __UpperCAmelCase, __UpperCAmelCase:					List[Any]		= self.model_tester.prepare_config_and_inputs_for_common()
    __UpperCAmelCase:					Optional[int]		= 3

    __UpperCAmelCase:					List[Any]		= (
        self.model_tester.image_size
        if isinstance(self.model_tester.image_size   ,    collections.abc.Iterable					)
        else (self.model_tester.image_size, self.model_tester.image_size)
    )
    __UpperCAmelCase:					str		= (
        config.patch_size
        if isinstance(config.patch_size   ,    collections.abc.Iterable					)
        else (config.patch_size, config.patch_size)
    )

    __UpperCAmelCase:					str		= image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
    __UpperCAmelCase:					Tuple		= image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

    for model_class in self.all_model_classes[:-1]:
      __UpperCAmelCase:					Union[str, Any]		= True
      self.check_hidden_states_output(snake_case_   ,    snake_case_   ,    snake_case_   ,    (padded_height, padded_width)					)

      # check that output_hidden_states also work using config
      del inputs_dict["output_hidden_states"]
      __UpperCAmelCase:					Optional[Any]		= True
      self.check_hidden_states_output(snake_case_   ,    snake_case_   ,    snake_case_   ,    (padded_height, padded_width)					)







  @slow
  def    lowercase_  (							self					):

    '''simple docstring'''







    for model_name in FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
      __UpperCAmelCase:					List[Any]		= FocalNetModel.from_pretrained(snake_case_					)
      self.assertIsNotNone(snake_case_					)







  def    lowercase_  (							self					):

    '''simple docstring'''







    __UpperCAmelCase, __UpperCAmelCase:					List[str]		= self.model_tester.prepare_config_and_inputs_for_common()

    __UpperCAmelCase:					int		= _config_zero_init(snake_case_					)
    for model_class in self.all_model_classes:
      __UpperCAmelCase:					Tuple		= model_class(config=snake_case_					)
      for name, param in model.named_parameters():
        if "embeddings" not in name and param.requires_grad:
          self.assertIn(
              ((param.data.mean() * 1e9).round() / 1e9).item()   ,    [0.0, 1.0]   ,    msg=F'''Parameter {name} of model {model_class} seems not properly initialized'''   ,    )




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



  """simple docstring"""







  @cached_property
  def    lowercase_  (							self					):

    '''simple docstring'''







    return AutoImageProcessor.from_pretrained("""microsoft/focalnet-tiny"""					) if is_vision_available() else None







  @slow
  def    lowercase_  (							self					):

    '''simple docstring'''







    __UpperCAmelCase:					Union[str, Any]		= FocalNetForImageClassification.from_pretrained("""microsoft/focalnet-tiny"""					).to(snake_case_					)
    __UpperCAmelCase:					str		= self.default_image_processor

    __UpperCAmelCase:					Union[str, Any]		= Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""					)
    __UpperCAmelCase:					Union[str, Any]		= image_processor(images=snake_case_   ,    return_tensors="""pt"""					).to(snake_case_					)

    # forward pass
    with torch.no_grad():
      __UpperCAmelCase:					Union[str, Any]		= model(**snake_case_					)

    # verify the logits
    __UpperCAmelCase:					Optional[int]		= torch.Size((1, 1000)					)
    self.assertEqual(outputs.logits.shape   ,    snake_case_					)
    __UpperCAmelCase:					List[str]		= torch.tensor([0.2_1_6_6, -0.4_3_6_8, 0.2_1_9_1]					).to(snake_case_					)
    self.assertTrue(torch.allclose(outputs.logits[0, :3]   ,    snake_case_   ,    atol=1e-4					)					)
    self.assertTrue(outputs.logits.argmax(dim=-1					).item()   ,    281					)




@require_torch
class    a (       __lowerCAmelCase						,  unittest.TestCase				):



  """simple docstring"""
  __lowerCAmelCase				      =					(FocalNetBackbone,) if is_torch_available() else ()
  __lowerCAmelCase				      =					FocalNetConfig

  __lowerCAmelCase				      =					False







  def    lowercase_  (							self					):

    '''simple docstring'''







    __UpperCAmelCase:					List[str]		= FocalNetModelTester(self					)
'''simple docstring'''






from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


SCREAMING_SNAKE_CASE_	   =			{
    'configuration_rembert': ['REMBERT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'RemBertConfig', 'RemBertOnnxConfig']
}

try:
    if not is_sentencepiece_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    SCREAMING_SNAKE_CASE_	   =			['RemBertTokenizer']

try:
    if not is_tokenizers_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    SCREAMING_SNAKE_CASE_	   =			['RemBertTokenizerFast']

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    SCREAMING_SNAKE_CASE_	   =			[
        'REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
        'RemBertForCausalLM',
        'RemBertForMaskedLM',
        'RemBertForMultipleChoice',
        'RemBertForQuestionAnswering',
        'RemBertForSequenceClassification',
        'RemBertForTokenClassification',
        'RemBertLayer',
        'RemBertModel',
        'RemBertPreTrainedModel',
        'load_tf_weights_in_rembert',
    ]


try:
    if not is_tf_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    SCREAMING_SNAKE_CASE_	   =			[
        'TF_REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
        'TFRemBertForCausalLM',
        'TFRemBertForMaskedLM',
        'TFRemBertForMultipleChoice',
        'TFRemBertForQuestionAnswering',
        'TFRemBertForSequenceClassification',
        'TFRemBertForTokenClassification',
        'TFRemBertLayer',
        'TFRemBertModel',
        'TFRemBertPreTrainedModel',
    ]


if TYPE_CHECKING:
    from .configuration_rembert import REMBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, RemBertConfig, RemBertOnnxConfig

    try:
        if not is_sentencepiece_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .tokenization_rembert import RemBertTokenizer

    try:
        if not is_tokenizers_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .tokenization_rembert_fast import RemBertTokenizerFast

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_rembert import (
            REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
            RemBertForCausalLM,
            RemBertForMaskedLM,
            RemBertForMultipleChoice,
            RemBertForQuestionAnswering,
            RemBertForSequenceClassification,
            RemBertForTokenClassification,
            RemBertLayer,
            RemBertModel,
            RemBertPreTrainedModel,
            load_tf_weights_in_rembert,
        )

    try:
        if not is_tf_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_tf_rembert import (
            TF_REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
            TFRemBertForCausalLM,
            TFRemBertForMaskedLM,
            TFRemBertForMultipleChoice,
            TFRemBertForQuestionAnswering,
            TFRemBertForSequenceClassification,
            TFRemBertForTokenClassification,
            TFRemBertLayer,
            TFRemBertModel,
            TFRemBertPreTrainedModel,
        )


else:
    import sys

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