


'''simple docstring'''
import argparse

import gdown
import numpy as np
import torch
from huggingface_hub import hf_hub_download

from transformers import (
    CLIPTokenizer,
    CLIPTokenizerFast,
    VideoMAEImageProcessor,
    XCLIPConfig,
    XCLIPModel,
    XCLIPProcessor,
    XCLIPTextConfig,
    XCLIPVisionConfig,
)





def 					a__       (					lowerCAmelCase__  ,					lowerCAmelCase__						)    ->	Optional[Any]:
    UpperCAmelCase__			:		Dict													=				XCLIPTextConfig()

    # derive patch size from model name
    UpperCAmelCase__			:		Any													=				model_name.find('''patch'''						)
    UpperCAmelCase__			:		str													=				int(model_name[start_idx + len('''patch'''						) : start_idx + len('''patch'''						) + 2]						)
    UpperCAmelCase__			:		str													=				XCLIPVisionConfig(patch_size=lowerCAmelCase__  ,					num_frames=lowerCAmelCase__						)

    if "large" in model_name:
        UpperCAmelCase__			:		Optional[Any]													=				7_68
        UpperCAmelCase__			:		Any													=				30_72
        UpperCAmelCase__			:		str													=				12

        UpperCAmelCase__			:		List[str]													=				10_24
        UpperCAmelCase__			:		Union[str, Any]													=				40_96
        UpperCAmelCase__			:		str													=				16
        UpperCAmelCase__			:		str													=				24
        UpperCAmelCase__			:		List[str]													=				7_68
        UpperCAmelCase__			:		Optional[Any]													=				30_72

    if model_name == "xclip-large-patch14-16-frames":
        UpperCAmelCase__			:		Tuple													=				3_36

    UpperCAmelCase__			:		Tuple													=				XCLIPConfig.from_text_vision_configs(lowerCAmelCase__  ,					lowerCAmelCase__						)

    if "large" in model_name:
        UpperCAmelCase__			:		Tuple													=				7_68

    return config





def 					a__       (					lowerCAmelCase__						)    ->	Any:
    # text encoder
    if name == "token_embedding.weight":
        UpperCAmelCase__			:		str													=				name.replace('''token_embedding.weight'''  ,					'''text_model.embeddings.token_embedding.weight'''						)
    if name == "positional_embedding":
        UpperCAmelCase__			:		Optional[Any]													=				name.replace('''positional_embedding'''  ,					'''text_model.embeddings.position_embedding.weight'''						)
    if "ln_1" in name:
        UpperCAmelCase__			:		Any													=				name.replace('''ln_1'''  ,					'''layer_norm1'''						)
    if "ln_2" in name:
        UpperCAmelCase__			:		Tuple													=				name.replace('''ln_2'''  ,					'''layer_norm2'''						)
    if "c_fc" in name:
        UpperCAmelCase__			:		Tuple													=				name.replace('''c_fc'''  ,					'''fc1'''						)
    if "c_proj" in name:
        UpperCAmelCase__			:		int													=				name.replace('''c_proj'''  ,					'''fc2'''						)
    if name.startswith('''transformer.resblocks'''						):
        UpperCAmelCase__			:		List[Any]													=				name.replace('''transformer.resblocks'''  ,					'''text_model.encoder.layers'''						)
    if "attn.out_proj" in name and "message" not in name:
        UpperCAmelCase__			:		Optional[int]													=				name.replace('''attn.out_proj'''  ,					'''self_attn.out_proj'''						)
    if "ln_final" in name:
        UpperCAmelCase__			:		List[str]													=				name.replace('''ln_final'''  ,					'''text_model.final_layer_norm'''						)
    # visual encoder
    if name == "visual.class_embedding":
        UpperCAmelCase__			:		List[str]													=				name.replace('''visual.class_embedding'''  ,					'''vision_model.embeddings.class_embedding'''						)
    if name == "visual.positional_embedding":
        UpperCAmelCase__			:		Any													=				name.replace('''visual.positional_embedding'''  ,					'''vision_model.embeddings.position_embedding.weight'''						)
    if name.startswith('''visual.transformer.resblocks'''						):
        UpperCAmelCase__			:		int													=				name.replace('''visual.transformer.resblocks'''  ,					'''vision_model.encoder.layers'''						)
    if "visual.conv1" in name:
        UpperCAmelCase__			:		List[Any]													=				name.replace('''visual.conv1'''  ,					'''vision_model.embeddings.patch_embedding'''						)
    if "visual.ln_pre" in name:
        UpperCAmelCase__			:		str													=				name.replace('''visual.ln_pre'''  ,					'''vision_model.pre_layernorm'''						)
    if "visual.ln_post" in name:
        UpperCAmelCase__			:		List[Any]													=				name.replace('''visual.ln_post'''  ,					'''vision_model.post_layernorm'''						)
    if "visual.proj" in name:
        UpperCAmelCase__			:		List[Any]													=				name.replace('''visual.proj'''  ,					'''visual_projection.weight'''						)
    if "text_projection" in name:
        UpperCAmelCase__			:		List[Any]													=				name.replace('''text_projection'''  ,					'''text_projection.weight'''						)
    # things on top
    if "prompts_visual_proj" in name:
        UpperCAmelCase__			:		List[Any]													=				name.replace('''prompts_visual_proj'''  ,					'''prompts_visual_projection'''						)
    if "prompts_visual_ln" in name:
        UpperCAmelCase__			:		Optional[int]													=				name.replace('''prompts_visual_ln'''  ,					'''prompts_visual_layernorm'''						)
    # mit
    if name == "mit.positional_embedding":
        UpperCAmelCase__			:		str													=				name.replace('''positional'''  ,					'''position'''						)
    if name.startswith('''mit.resblocks'''						):
        UpperCAmelCase__			:		List[str]													=				name.replace('''mit.resblocks'''  ,					'''mit.encoder.layers'''						)
    # prompts generator
    if name.startswith('''prompts_generator.norm'''						):
        UpperCAmelCase__			:		str													=				name.replace('''prompts_generator.norm'''  ,					'''prompts_generator.layernorm'''						)

    return name





def 					a__       (					lowerCAmelCase__  ,					lowerCAmelCase__						)    ->	List[str]:
    for key in orig_state_dict.copy().keys():
        UpperCAmelCase__			:		List[str]													=				orig_state_dict.pop(lowerCAmelCase__						)

        if "attn.in_proj" in key:
            UpperCAmelCase__			:		Optional[Any]													=				key.split('''.'''						)
            if key.startswith('''visual'''						):
                UpperCAmelCase__			:		int													=				key_split[3]
                UpperCAmelCase__			:		List[Any]													=				config.vision_config.hidden_size
                if "message_attn" in key:
                    if "weight" in key:
                        UpperCAmelCase__			:		List[Any]													=				val[
                            :dim, :
                        ]
                        UpperCAmelCase__			:		Optional[int]													=				val[
                            dim : dim * 2, :
                        ]
                        UpperCAmelCase__			:		Optional[int]													=				val[
                            -dim:, :
                        ]
                    else:
                        UpperCAmelCase__			:		List[Any]													=				val[
                            :dim
                        ]
                        UpperCAmelCase__			:		Union[str, Any]													=				val[
                            dim : dim * 2
                        ]
                        UpperCAmelCase__			:		Optional[Any]													=				val[
                            -dim:
                        ]
                else:
                    if "weight" in key:
                        UpperCAmelCase__			:		Tuple													=				val[
                            :dim, :
                        ]
                        UpperCAmelCase__			:		Union[str, Any]													=				val[
                            dim : dim * 2, :
                        ]
                        UpperCAmelCase__			:		Any													=				val[
                            -dim:, :
                        ]
                    else:
                        UpperCAmelCase__			:		Any													=				val[:dim]
                        UpperCAmelCase__			:		List[str]													=				val[
                            dim : dim * 2
                        ]
                        UpperCAmelCase__			:		Optional[int]													=				val[-dim:]
            elif key.startswith('''mit'''						):
                UpperCAmelCase__			:		Any													=				key_split[2]
                UpperCAmelCase__			:		List[Any]													=				config.vision_config.mit_hidden_size
                if "weight" in key:
                    UpperCAmelCase__			:		Dict													=				val[:dim, :]
                    UpperCAmelCase__			:		List[Any]													=				val[dim : dim * 2, :]
                    UpperCAmelCase__			:		Dict													=				val[-dim:, :]
                else:
                    UpperCAmelCase__			:		List[Any]													=				val[:dim]
                    UpperCAmelCase__			:		Any													=				val[dim : dim * 2]
                    UpperCAmelCase__			:		Any													=				val[-dim:]
            else:
                UpperCAmelCase__			:		List[str]													=				key_split[2]
                UpperCAmelCase__			:		int													=				config.text_config.hidden_size
                if "weight" in key:
                    UpperCAmelCase__			:		str													=				val[:dim, :]
                    UpperCAmelCase__			:		str													=				val[
                        dim : dim * 2, :
                    ]
                    UpperCAmelCase__			:		Any													=				val[-dim:, :]
                else:
                    UpperCAmelCase__			:		int													=				val[:dim]
                    UpperCAmelCase__			:		List[str]													=				val[
                        dim : dim * 2
                    ]
                    UpperCAmelCase__			:		Tuple													=				val[-dim:]
        else:
            UpperCAmelCase__			:		Any													=				rename_key(lowerCAmelCase__						)
            if new_key_name in ["visual_projection.weight", "text_projection.weight"]:
                UpperCAmelCase__			:		Optional[int]													=				val.T
            UpperCAmelCase__			:		List[Any]													=				val

    return orig_state_dict





def 					a__       (					lowerCAmelCase__						)    ->	Tuple:
    if num_frames == 8:
        UpperCAmelCase__			:		Dict													=				'''eating_spaghetti_8_frames.npy'''
    elif num_frames == 16:
        UpperCAmelCase__			:		Optional[int]													=				'''eating_spaghetti.npy'''
    elif num_frames == 32:
        UpperCAmelCase__			:		List[Any]													=				'''eating_spaghetti_32_frames.npy'''
    UpperCAmelCase__			:		List[str]													=				hf_hub_download(
        repo_id='''hf-internal-testing/spaghetti-video'''  ,					filename=lowerCAmelCase__  ,					repo_type='''dataset'''  ,					)
    UpperCAmelCase__			:		Optional[Any]													=				np.load(lowerCAmelCase__						)
    return list(lowerCAmelCase__						)





def 					a__       (					lowerCAmelCase__  ,					lowerCAmelCase__=None  ,					lowerCAmelCase__=False						)    ->	Tuple:
    UpperCAmelCase__			:		Optional[int]													=				{
        # fully supervised kinetics-400 checkpoints
        '''xclip-base-patch32''': '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k400_32_8.pth''',
        '''xclip-base-patch32-16-frames''': (
            '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k400_32_16.pth'''
        ),
        '''xclip-base-patch16''': '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k400_16_8.pth''',
        '''xclip-base-patch16-16-frames''': (
            '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k400_16_16.pth'''
        ),
        '''xclip-large-patch14''': '''https://drive.google.com/u/0/uc?id=1NUOImq0o5DlQTST17iIP3vG7DgmHQuCx&amp;export=download&amp;confirm=t&amp;uuid=b26caedc-88e2-473e-830a-9d158b653cdb''',
        '''xclip-large-patch14-16-frames''': '''https://drive.google.com/u/0/uc?id=1FOYgnJc097OJ4lGwtRCCydQyVPJEOH7d&amp;export=download&amp;confirm=t&amp;uuid=538fa810-e671-4050-b385-9a623f89804f''',
        # fully supervised kinetics-600 checkpoints
        '''xclip-base-patch16-kinetics-600''': (
            '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k600_16_8.pth'''
        ),
        '''xclip-base-patch16-kinetics-600-16-frames''': (
            '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k600_16_16.pth'''
        ),
        '''xclip-large-patch14-kinetics-600''': '''https://drive.google.com/u/0/uc?id=1FV8C1INuM91sLAN4ImjzePLIlpMSihwV&amp;export=download&amp;confirm=t&amp;uuid=141d4977-4a65-44ae-864f-4b0c19f838be''',
        # few shot
        '''xclip-base-patch16-hmdb-2-shot''': (
            '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_hmdb_2.pth'''
        ),
        '''xclip-base-patch16-hmdb-4-shot''': (
            '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_hmdb_4.pth'''
        ),
        '''xclip-base-patch16-hmdb-8-shot''': (
            '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_hmdb_8.pth'''
        ),
        '''xclip-base-patch16-hmdb-16-shot''': (
            '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_hmdb_16.pth'''
        ),
        '''xclip-base-patch16-ucf-2-shot''': (
            '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_ucf_2.pth'''
        ),
        '''xclip-base-patch16-ucf-4-shot''': (
            '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_ucf_4.pth'''
        ),
        '''xclip-base-patch16-ucf-8-shot''': (
            '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_ucf_8.pth'''
        ),
        '''xclip-base-patch16-ucf-16-shot''': (
            '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_ucf_16.pth'''
        ),
        # zero shot
        '''xclip-base-patch16-zero-shot''': '''https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/zero.pth''',
    }

    UpperCAmelCase__			:		Optional[int]													=				model_to_url[model_name]
    UpperCAmelCase__			:		Dict													=				8
    if "16-frames" in model_name:
        UpperCAmelCase__			:		Tuple													=				16
    elif "shot" in model_name:
        UpperCAmelCase__			:		Optional[int]													=				32

    UpperCAmelCase__			:		Tuple													=				get_xclip_config(lowerCAmelCase__  ,					lowerCAmelCase__						)
    UpperCAmelCase__			:		List[str]													=				XCLIPModel(lowerCAmelCase__						)
    model.eval()

    if "drive" in checkpoint_url:
        UpperCAmelCase__			:		Union[str, Any]													=				'''pytorch_model.bin'''
        gdown.cached_download(lowerCAmelCase__  ,					lowerCAmelCase__  ,					quiet=lowerCAmelCase__						)
        UpperCAmelCase__			:		List[str]													=				torch.load(lowerCAmelCase__  ,					map_location='''cpu'''						)['''model''']
    else:
        UpperCAmelCase__			:		Union[str, Any]													=				torch.hub.load_state_dict_from_url(lowerCAmelCase__						)['''model''']

    UpperCAmelCase__			:		Dict													=				convert_state_dict(lowerCAmelCase__  ,					lowerCAmelCase__						)

    UpperCAmelCase__			:		str													=				XCLIPModel(lowerCAmelCase__						)
    UpperCAmelCase__						,						UpperCAmelCase__			:		Dict													=				model.load_state_dict(lowerCAmelCase__  ,					strict=lowerCAmelCase__						)
    assert missing_keys == ["text_model.embeddings.position_ids", "vision_model.embeddings.position_ids"]
    model.eval()

    UpperCAmelCase__			:		Dict													=				3_36 if model_name == '''xclip-large-patch14-16-frames''' else 2_24
    UpperCAmelCase__			:		Any													=				VideoMAEImageProcessor(size=lowerCAmelCase__						)
    UpperCAmelCase__			:		Any													=				CLIPTokenizer.from_pretrained('''openai/clip-vit-base-patch32'''						)
    UpperCAmelCase__			:		str													=				CLIPTokenizerFast.from_pretrained('''openai/clip-vit-base-patch32'''						)
    UpperCAmelCase__			:		Union[str, Any]													=				XCLIPProcessor(image_processor=lowerCAmelCase__  ,					tokenizer=lowerCAmelCase__						)

    UpperCAmelCase__			:		Dict													=				prepare_video(lowerCAmelCase__						)
    UpperCAmelCase__			:		int													=				processor(
        text=['''playing sports''', '''eating spaghetti''', '''go shopping''']  ,					videos=lowerCAmelCase__  ,					return_tensors='''pt'''  ,					padding=lowerCAmelCase__						)

    print('''Shape of pixel values:'''  ,					inputs.pixel_values.shape						)

    with torch.no_grad():
        UpperCAmelCase__			:		Optional[Any]													=				model(**lowerCAmelCase__						)

    # Verify outputs
    UpperCAmelCase__			:		List[str]													=				outputs.logits_per_video
    UpperCAmelCase__			:		int													=				logits_per_video.softmax(dim=1						)
    print('''Probs:'''  ,					lowerCAmelCase__						)
    # kinetics-400
    if model_name == "xclip-base-patch32":
        UpperCAmelCase__			:		List[Any]													=				torch.tensor([[0.0_0_1_9, 0.9_9_5_1, 0.0_0_3_0]]						)
    elif model_name == "xclip-base-patch32-16-frames":
        UpperCAmelCase__			:		str													=				torch.tensor([[7.0999E-04, 9.9883E-01, 4.5580E-04]]						)
    elif model_name == "xclip-base-patch16":
        UpperCAmelCase__			:		List[str]													=				torch.tensor([[0.0_0_8_3, 0.9_6_8_1, 0.0_2_3_6]]						)
    elif model_name == "xclip-base-patch16-16-frames":
        UpperCAmelCase__			:		Union[str, Any]													=				torch.tensor([[7.6937E-04, 9.9728E-01, 1.9473E-03]]						)
    elif model_name == "xclip-large-patch14":
        UpperCAmelCase__			:		List[Any]													=				torch.tensor([[0.0_0_6_2, 0.9_8_6_4, 0.0_0_7_5]]						)
    elif model_name == "xclip-large-patch14-16-frames":
        UpperCAmelCase__			:		Dict													=				torch.tensor([[3.3877E-04, 9.9937E-01, 2.8888E-04]]						)
    # kinetics-600
    elif model_name == "xclip-base-patch16-kinetics-600":
        UpperCAmelCase__			:		List[str]													=				torch.tensor([[0.0_5_5_5, 0.8_9_1_4, 0.0_5_3_1]]						)
    elif model_name == "xclip-base-patch16-kinetics-600-16-frames":
        UpperCAmelCase__			:		Union[str, Any]													=				torch.tensor([[3.8554E-04, 9.9929E-01, 3.2754E-04]]						)
    elif model_name == "xclip-large-patch14-kinetics-600":
        UpperCAmelCase__			:		Any													=				torch.tensor([[0.0_0_3_6, 0.9_9_2_0, 0.0_0_4_5]]						)
    # few shot
    elif model_name == "xclip-base-patch16-hmdb-2-shot":
        UpperCAmelCase__			:		Union[str, Any]													=				torch.tensor([[7.1890E-06, 9.9994E-01, 5.6559E-05]]						)
    elif model_name == "xclip-base-patch16-hmdb-4-shot":
        UpperCAmelCase__			:		List[Any]													=				torch.tensor([[1.0320E-05, 9.9993E-01, 6.2435E-05]]						)
    elif model_name == "xclip-base-patch16-hmdb-8-shot":
        UpperCAmelCase__			:		Optional[int]													=				torch.tensor([[4.1377E-06, 9.9990E-01, 9.8386E-05]]						)
    elif model_name == "xclip-base-patch16-hmdb-16-shot":
        UpperCAmelCase__			:		List[Any]													=				torch.tensor([[4.1347E-05, 9.9962E-01, 3.3411E-04]]						)
    elif model_name == "xclip-base-patch16-ucf-2-shot":
        UpperCAmelCase__			:		List[Any]													=				torch.tensor([[8.5857E-05, 9.9928E-01, 6.3291E-04]]						)
    elif model_name == "xclip-base-patch16-ucf-4-shot":
        UpperCAmelCase__			:		str													=				torch.tensor([[8.5857E-05, 9.9928E-01, 6.3291E-04]]						)
    elif model_name == "xclip-base-patch16-ucf-8-shot":
        UpperCAmelCase__			:		List[str]													=				torch.tensor([[0.0_0_2_7, 0.9_9_0_4, 0.0_0_7_0]]						)
    elif model_name == "xclip-base-patch16-ucf-16-shot":
        UpperCAmelCase__			:		str													=				torch.tensor([[9.8219E-04, 9.9593E-01, 3.0863E-03]]						)
    # zero shot
    elif model_name == "xclip-base-patch16-zero-shot":
        UpperCAmelCase__			:		int													=				torch.tensor([[3.5082E-04, 9.9785E-01, 1.7966E-03]]						)
    else:
        raise ValueError(F"""Model name {model_name} not supported"""						)
    assert torch.allclose(lowerCAmelCase__  ,					lowerCAmelCase__  ,					atol=1E-3						)
    print('''Looks ok!'''						)

    if pytorch_dump_folder_path is not None:
        print(F"""Saving model {model_name} to {pytorch_dump_folder_path}"""						)
        model.save_pretrained(lowerCAmelCase__						)

    if push_to_hub:
        print('''Pushing model, processor and slow tokenizer files to the hub...'''						)
        model.push_to_hub(lowerCAmelCase__  ,					organization='''nielsr'''						)
        processor.push_to_hub(lowerCAmelCase__  ,					organization='''nielsr'''						)
        slow_tokenizer.push_to_hub(lowerCAmelCase__  ,					organization='''nielsr'''						)


if __name__ == "__main__":
  UpperCamelCase__    					=      argparse.ArgumentParser()
  # Required parameters
  parser.add_argument(
      '''--model_name''',
      default='''xclip-base-patch32''',
      type=str,
      help='''Name of the model.''',
  )
  parser.add_argument(
      '''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to the output PyTorch model directory.'''
  )
  parser.add_argument(
      '''--push_to_hub''', action='''store_true''', help='''Whether or not to push the converted model to the 🤗 hub.'''
  )

  UpperCamelCase__    					=      parser.parse_args()
  convert_xclip_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)




'''simple docstring'''
from typing import TYPE_CHECKING

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


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

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

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

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  UpperCamelCase__    					=      [
      '''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:
  UpperCamelCase__    					=      [
      '''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

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