



'''simple docstring'''





import argparse
import json
from pathlib import Path

import requests
import torch
from huggingface_hub import cached_download, hf_hub_download, hf_hub_url
from PIL import Image

from transformers import DetaConfig, DetaForObjectDetection, DetaImageProcessor, SwinConfig
from transformers.utils import logging


logging.set_verbosity_info()
_lowerCAmelCase      						=	logging.get_logger(__name__)
def    _SCREAMING_SNAKE_CASE  (       UpperCamelCase			):



    """simple docstring"""





    lowerCAmelCase__ :  Union[str, Any]							      =					SwinConfig(
        embed_dim=192							,    depths=(2, 2, 18, 2)							,    num_heads=(6, 12, 24, 48)							,    window_size=12							,    out_features=["""stage2""", """stage3""", """stage4"""]							,    )

    lowerCAmelCase__ :  Union[str, Any]							      =					DetaConfig(
        backbone_config=UpperCamelCase							,    num_queries=900							,    encoder_ffn_dim=2048							,    decoder_ffn_dim=2048							,    num_feature_levels=5							,    assign_first_stage=UpperCamelCase							,    with_box_refine=UpperCamelCase							,    two_stage=UpperCamelCase							,    )

    # set labels
    lowerCAmelCase__ :  int							      =					"""huggingface/label-files"""
    if "o365" in model_name:
        lowerCAmelCase__ :  Optional[int]							      =					366
        lowerCAmelCase__ :  int							      =					"""object365-id2label.json"""
    else:
        lowerCAmelCase__ :  List[str]							      =					91
        lowerCAmelCase__ :  int							      =					"""coco-detection-id2label.json"""

    lowerCAmelCase__ :  Union[str, Any]							      =					num_labels
    lowerCAmelCase__ :  Tuple							      =					json.load(open(cached_download(hf_hub_url(UpperCamelCase							,    UpperCamelCase							,    repo_type="""dataset"""			)			)							,    """r"""			)			)
    lowerCAmelCase__ :  List[str]							      =					{int(UpperCamelCase			): v for k, v in idalabel.items()}
    lowerCAmelCase__ :  Union[str, Any]							      =					idalabel
    lowerCAmelCase__ :  Optional[Any]							      =					{v: k for k, v in idalabel.items()}

    return config
def    _SCREAMING_SNAKE_CASE  (       UpperCamelCase			):



    """simple docstring"""





    lowerCAmelCase__ :  Any							      =					[]

    # stem
    # fmt: off
    rename_keys.append(("""backbone.0.body.patch_embed.proj.weight""", """model.backbone.model.embeddings.patch_embeddings.projection.weight""")			)
    rename_keys.append(("""backbone.0.body.patch_embed.proj.bias""", """model.backbone.model.embeddings.patch_embeddings.projection.bias""")			)
    rename_keys.append(("""backbone.0.body.patch_embed.norm.weight""", """model.backbone.model.embeddings.norm.weight""")			)
    rename_keys.append(("""backbone.0.body.patch_embed.norm.bias""", """model.backbone.model.embeddings.norm.bias""")			)
    # stages
    for i in range(len(config.backbone_config.depths			)			):
        for j in range(config.backbone_config.depths[i]			):
            rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.norm1.weight""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_before.weight""")			)
            rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.norm1.bias""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_before.bias""")			)
            rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.attn.relative_position_bias_table""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_bias_table""")			)
            rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.attn.relative_position_index""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_index""")			)
            rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.attn.proj.weight""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.weight""")			)
            rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.attn.proj.bias""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.bias""")			)
            rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.norm2.weight""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_after.weight""")			)
            rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.norm2.bias""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_after.bias""")			)
            rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.mlp.fc1.weight""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.weight""")			)
            rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.mlp.fc1.bias""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.bias""")			)
            rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.mlp.fc2.weight""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.output.dense.weight""")			)
            rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.mlp.fc2.bias""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.output.dense.bias""")			)

        if i < 3:
            rename_keys.append((f"""backbone.0.body.layers.{i}.downsample.reduction.weight""", f"""model.backbone.model.encoder.layers.{i}.downsample.reduction.weight""")			)
            rename_keys.append((f"""backbone.0.body.layers.{i}.downsample.norm.weight""", f"""model.backbone.model.encoder.layers.{i}.downsample.norm.weight""")			)
            rename_keys.append((f"""backbone.0.body.layers.{i}.downsample.norm.bias""", f"""model.backbone.model.encoder.layers.{i}.downsample.norm.bias""")			)

    rename_keys.append(("""backbone.0.body.norm1.weight""", """model.backbone.model.hidden_states_norms.stage2.weight""")			)
    rename_keys.append(("""backbone.0.body.norm1.bias""", """model.backbone.model.hidden_states_norms.stage2.bias""")			)
    rename_keys.append(("""backbone.0.body.norm2.weight""", """model.backbone.model.hidden_states_norms.stage3.weight""")			)
    rename_keys.append(("""backbone.0.body.norm2.bias""", """model.backbone.model.hidden_states_norms.stage3.bias""")			)
    rename_keys.append(("""backbone.0.body.norm3.weight""", """model.backbone.model.hidden_states_norms.stage4.weight""")			)
    rename_keys.append(("""backbone.0.body.norm3.bias""", """model.backbone.model.hidden_states_norms.stage4.bias""")			)

    # transformer encoder
    for i in range(config.encoder_layers			):
        rename_keys.append((f"""transformer.encoder.layers.{i}.self_attn.sampling_offsets.weight""", f"""model.encoder.layers.{i}.self_attn.sampling_offsets.weight""")			)
        rename_keys.append((f"""transformer.encoder.layers.{i}.self_attn.sampling_offsets.bias""", f"""model.encoder.layers.{i}.self_attn.sampling_offsets.bias""")			)
        rename_keys.append((f"""transformer.encoder.layers.{i}.self_attn.attention_weights.weight""", f"""model.encoder.layers.{i}.self_attn.attention_weights.weight""")			)
        rename_keys.append((f"""transformer.encoder.layers.{i}.self_attn.attention_weights.bias""", f"""model.encoder.layers.{i}.self_attn.attention_weights.bias""")			)
        rename_keys.append((f"""transformer.encoder.layers.{i}.self_attn.value_proj.weight""", f"""model.encoder.layers.{i}.self_attn.value_proj.weight""")			)
        rename_keys.append((f"""transformer.encoder.layers.{i}.self_attn.value_proj.bias""", f"""model.encoder.layers.{i}.self_attn.value_proj.bias""")			)
        rename_keys.append((f"""transformer.encoder.layers.{i}.self_attn.output_proj.weight""", f"""model.encoder.layers.{i}.self_attn.output_proj.weight""")			)
        rename_keys.append((f"""transformer.encoder.layers.{i}.self_attn.output_proj.bias""", f"""model.encoder.layers.{i}.self_attn.output_proj.bias""")			)
        rename_keys.append((f"""transformer.encoder.layers.{i}.norm1.weight""", f"""model.encoder.layers.{i}.self_attn_layer_norm.weight""")			)
        rename_keys.append((f"""transformer.encoder.layers.{i}.norm1.bias""", f"""model.encoder.layers.{i}.self_attn_layer_norm.bias""")			)
        rename_keys.append((f"""transformer.encoder.layers.{i}.linear1.weight""", f"""model.encoder.layers.{i}.fc1.weight""")			)
        rename_keys.append((f"""transformer.encoder.layers.{i}.linear1.bias""", f"""model.encoder.layers.{i}.fc1.bias""")			)
        rename_keys.append((f"""transformer.encoder.layers.{i}.linear2.weight""", f"""model.encoder.layers.{i}.fc2.weight""")			)
        rename_keys.append((f"""transformer.encoder.layers.{i}.linear2.bias""", f"""model.encoder.layers.{i}.fc2.bias""")			)
        rename_keys.append((f"""transformer.encoder.layers.{i}.norm2.weight""", f"""model.encoder.layers.{i}.final_layer_norm.weight""")			)
        rename_keys.append((f"""transformer.encoder.layers.{i}.norm2.bias""", f"""model.encoder.layers.{i}.final_layer_norm.bias""")			)

    # transformer decoder
    for i in range(config.decoder_layers			):
        rename_keys.append((f"""transformer.decoder.layers.{i}.cross_attn.sampling_offsets.weight""", f"""model.decoder.layers.{i}.encoder_attn.sampling_offsets.weight""")			)
        rename_keys.append((f"""transformer.decoder.layers.{i}.cross_attn.sampling_offsets.bias""", f"""model.decoder.layers.{i}.encoder_attn.sampling_offsets.bias""")			)
        rename_keys.append((f"""transformer.decoder.layers.{i}.cross_attn.attention_weights.weight""", f"""model.decoder.layers.{i}.encoder_attn.attention_weights.weight""")			)
        rename_keys.append((f"""transformer.decoder.layers.{i}.cross_attn.attention_weights.bias""", f"""model.decoder.layers.{i}.encoder_attn.attention_weights.bias""")			)
        rename_keys.append((f"""transformer.decoder.layers.{i}.cross_attn.value_proj.weight""", f"""model.decoder.layers.{i}.encoder_attn.value_proj.weight""")			)
        rename_keys.append((f"""transformer.decoder.layers.{i}.cross_attn.value_proj.bias""", f"""model.decoder.layers.{i}.encoder_attn.value_proj.bias""")			)
        rename_keys.append((f"""transformer.decoder.layers.{i}.cross_attn.output_proj.weight""", f"""model.decoder.layers.{i}.encoder_attn.output_proj.weight""")			)
        rename_keys.append((f"""transformer.decoder.layers.{i}.cross_attn.output_proj.bias""", f"""model.decoder.layers.{i}.encoder_attn.output_proj.bias""")			)
        rename_keys.append((f"""transformer.decoder.layers.{i}.norm1.weight""", f"""model.decoder.layers.{i}.encoder_attn_layer_norm.weight""")			)
        rename_keys.append((f"""transformer.decoder.layers.{i}.norm1.bias""", f"""model.decoder.layers.{i}.encoder_attn_layer_norm.bias""")			)
        rename_keys.append((f"""transformer.decoder.layers.{i}.self_attn.out_proj.weight""", f"""model.decoder.layers.{i}.self_attn.out_proj.weight""")			)
        rename_keys.append((f"""transformer.decoder.layers.{i}.self_attn.out_proj.bias""", f"""model.decoder.layers.{i}.self_attn.out_proj.bias""")			)
        rename_keys.append((f"""transformer.decoder.layers.{i}.norm2.weight""", f"""model.decoder.layers.{i}.self_attn_layer_norm.weight""")			)
        rename_keys.append((f"""transformer.decoder.layers.{i}.norm2.bias""", f"""model.decoder.layers.{i}.self_attn_layer_norm.bias""")			)
        rename_keys.append((f"""transformer.decoder.layers.{i}.linear1.weight""", f"""model.decoder.layers.{i}.fc1.weight""")			)
        rename_keys.append((f"""transformer.decoder.layers.{i}.linear1.bias""", f"""model.decoder.layers.{i}.fc1.bias""")			)
        rename_keys.append((f"""transformer.decoder.layers.{i}.linear2.weight""", f"""model.decoder.layers.{i}.fc2.weight""")			)
        rename_keys.append((f"""transformer.decoder.layers.{i}.linear2.bias""", f"""model.decoder.layers.{i}.fc2.bias""")			)
        rename_keys.append((f"""transformer.decoder.layers.{i}.norm3.weight""", f"""model.decoder.layers.{i}.final_layer_norm.weight""")			)
        rename_keys.append((f"""transformer.decoder.layers.{i}.norm3.bias""", f"""model.decoder.layers.{i}.final_layer_norm.bias""")			)

    # fmt: on

    return rename_keys
def    _SCREAMING_SNAKE_CASE  (       UpperCamelCase							,    UpperCamelCase							,    UpperCamelCase			):



    """simple docstring"""





    lowerCAmelCase__ :  Union[str, Any]							      =					dct.pop(UpperCamelCase			)
    lowerCAmelCase__ :  Dict							      =					val
def    _SCREAMING_SNAKE_CASE  (       UpperCamelCase							,    UpperCamelCase			):



    """simple docstring"""





    lowerCAmelCase__ :  List[Any]							      =					[int(backbone_config.embed_dim * 2**i			) for i in range(len(backbone_config.depths			)			)]
    for i in range(len(backbone_config.depths			)			):
        lowerCAmelCase__ :  Any							      =					num_features[i]
        for j in range(backbone_config.depths[i]			):
            # fmt: off
            # read in weights + bias of input projection layer (in original implementation, this is a single matrix + bias)
            lowerCAmelCase__ :  int							      =					state_dict.pop(f"""backbone.0.body.layers.{i}.blocks.{j}.attn.qkv.weight"""			)
            lowerCAmelCase__ :  Dict							      =					state_dict.pop(f"""backbone.0.body.layers.{i}.blocks.{j}.attn.qkv.bias"""			)
            # next, add query, keys and values (in that order) to the state dict
            lowerCAmelCase__ :  Dict							      =					in_proj_weight[:dim, :]
            lowerCAmelCase__ :  str							      =					in_proj_bias[: dim]
            lowerCAmelCase__ :  int							      =					in_proj_weight[
                dim : dim * 2, :
            ]
            lowerCAmelCase__ :  Union[str, Any]							      =					in_proj_bias[
                dim : dim * 2
            ]
            lowerCAmelCase__ :  Tuple							      =					in_proj_weight[
                -dim :, :
            ]
            lowerCAmelCase__ :  Any							      =					in_proj_bias[-dim :]
            # fmt: on
def    _SCREAMING_SNAKE_CASE  (       UpperCamelCase							,    UpperCamelCase			):



    """simple docstring"""





    lowerCAmelCase__ :  Optional[int]							      =					config.d_model
    for i in range(config.decoder_layers			):
        # read in weights + bias of input projection layer of self-attention
        lowerCAmelCase__ :  List[str]							      =					state_dict.pop(f"""transformer.decoder.layers.{i}.self_attn.in_proj_weight"""			)
        lowerCAmelCase__ :  Union[str, Any]							      =					state_dict.pop(f"""transformer.decoder.layers.{i}.self_attn.in_proj_bias"""			)
        # next, add query, keys and values (in that order) to the state dict
        lowerCAmelCase__ :  Union[str, Any]							      =					in_proj_weight[:hidden_size, :]
        lowerCAmelCase__ :  Dict							      =					in_proj_bias[:hidden_size]
        lowerCAmelCase__ :  Tuple							      =					in_proj_weight[
            hidden_size : hidden_size * 2, :
        ]
        lowerCAmelCase__ :  Optional[Any]							      =					in_proj_bias[hidden_size : hidden_size * 2]
        lowerCAmelCase__ :  Tuple							      =					in_proj_weight[-hidden_size:, :]
        lowerCAmelCase__ :  str							      =					in_proj_bias[-hidden_size:]
def    _SCREAMING_SNAKE_CASE  (       ):



    """simple docstring"""





    lowerCAmelCase__ :  str							      =					"""http://images.cocodataset.org/val2017/000000039769.jpg"""
    lowerCAmelCase__ :  Optional[Any]							      =					Image.open(requests.get(UpperCamelCase							,    stream=UpperCamelCase			).raw			)

    return im
@torch.no_grad()
def    _SCREAMING_SNAKE_CASE  (       UpperCamelCase							,    UpperCamelCase							,    UpperCamelCase			):



    """simple docstring"""





    lowerCAmelCase__ :  Union[str, Any]							      =					get_deta_config(UpperCamelCase			)

    # load original state dict
    if model_name == "deta-swin-large":
        lowerCAmelCase__ :  Union[str, Any]							      =					hf_hub_download(repo_id="""nielsr/deta-checkpoints"""							,    filename="""adet_swin_ft.pth"""			)
    elif model_name == "deta-swin-large-o365":
        lowerCAmelCase__ :  List[Any]							      =					hf_hub_download(repo_id="""jozhang97/deta-swin-l-o365"""							,    filename="""deta_swin_pt_o365.pth"""			)
    else:
        raise ValueError(f"""Model name {model_name} not supported"""			)

    lowerCAmelCase__ :  str							      =					torch.load(UpperCamelCase							,    map_location="""cpu"""			)["""model"""]

    # original state dict
    for name, param in state_dict.items():
        print(UpperCamelCase							,    param.shape			)

    # rename keys
    lowerCAmelCase__ :  Dict							      =					create_rename_keys(UpperCamelCase			)
    for src, dest in rename_keys:
        rename_key(UpperCamelCase							,    UpperCamelCase							,    UpperCamelCase			)
    read_in_swin_q_k_v(UpperCamelCase							,    config.backbone_config			)
    read_in_decoder_q_k_v(UpperCamelCase							,    UpperCamelCase			)

    # fix some prefixes
    for key in state_dict.copy().keys():
        if "transformer.decoder.class_embed" in key or "transformer.decoder.bbox_embed" in key:
            lowerCAmelCase__ :  Dict							      =					state_dict.pop(UpperCamelCase			)
            lowerCAmelCase__ :  Union[str, Any]							      =					val
        if "input_proj" in key:
            lowerCAmelCase__ :  str							      =					state_dict.pop(UpperCamelCase			)
            lowerCAmelCase__ :  Any							      =					val
        if "level_embed" in key or "pos_trans" in key or "pix_trans" in key or "enc_output" in key:
            lowerCAmelCase__ :  Any							      =					state_dict.pop(UpperCamelCase			)
            lowerCAmelCase__ :  Tuple							      =					val

    # finally, create HuggingFace model and load state dict
    lowerCAmelCase__ :  Dict							      =					DetaForObjectDetection(UpperCamelCase			)
    model.load_state_dict(UpperCamelCase			)
    model.eval()

    lowerCAmelCase__ :  Optional[Any]							      =					"""cuda""" if torch.cuda.is_available() else """cpu"""
    model.to(UpperCamelCase			)

    # load image processor
    lowerCAmelCase__ :  List[Any]							      =					DetaImageProcessor(format="""coco_detection"""			)

    # verify our conversion on image
    lowerCAmelCase__ :  List[Any]							      =					prepare_img()
    lowerCAmelCase__ :  Optional[Any]							      =					processor(images=UpperCamelCase							,    return_tensors="""pt"""			)
    lowerCAmelCase__ :  int							      =					encoding["""pixel_values"""]
    lowerCAmelCase__ :  List[Any]							      =					model(pixel_values.to(UpperCamelCase			)			)

    # verify logits
    print("""Logits:"""							,    outputs.logits[0, :3, :3]			)
    print("""Boxes:"""							,    outputs.pred_boxes[0, :3, :3]			)
    if model_name == "deta-swin-large":
        lowerCAmelCase__ :  Any							      =					torch.tensor(
            [[-7.6308, -2.8485, -5.3737], [-7.2037, -4.5505, -4.8027], [-7.2943, -4.2611, -4.6617]]			)
        lowerCAmelCase__ :  Optional[Any]							      =					torch.tensor([[0.4987, 0.4969, 0.9999], [0.2549, 0.5498, 0.4805], [0.5498, 0.2757, 0.0569]]			)
    elif model_name == "deta-swin-large-o365":
        lowerCAmelCase__ :  int							      =					torch.tensor(
            [[-8.0122, -3.5720, -4.9717], [-8.1547, -3.6886, -4.6389], [-7.6610, -3.6194, -5.0134]]			)
        lowerCAmelCase__ :  Union[str, Any]							      =					torch.tensor([[0.2523, 0.5549, 0.4881], [0.7715, 0.4149, 0.4601], [0.5503, 0.2753, 0.0575]]			)
    assert torch.allclose(outputs.logits[0, :3, :3]							,    expected_logits.to(UpperCamelCase			)							,    atol=1e-4			)
    assert torch.allclose(outputs.pred_boxes[0, :3, :3]							,    expected_boxes.to(UpperCamelCase			)							,    atol=1e-4			)
    print("""Everything ok!"""			)

    if pytorch_dump_folder_path:
        # Save model and processor
        logger.info(f"""Saving PyTorch model and processor to {pytorch_dump_folder_path}..."""			)
        Path(UpperCamelCase			).mkdir(exist_ok=UpperCamelCase			)
        model.save_pretrained(UpperCamelCase			)
        processor.save_pretrained(UpperCamelCase			)

    # Push to hub
    if push_to_hub:
        print("""Pushing model and processor to hub..."""			)
        model.push_to_hub(f"""jozhang97/{model_name}"""			)
        processor.push_to_hub(f"""jozhang97/{model_name}"""			)


if __name__ == "__main__":
 _lowerCAmelCase      						=	argparse.ArgumentParser()

 parser.add_argument(
     '''--model_name''',
     type=str,
     default='''deta-swin-large''',
     choices=['''deta-swin-large''', '''deta-swin-large-o365'''],
     help='''Name of the model you\'d like to convert.''',
 )
 parser.add_argument(
     '''--pytorch_dump_folder_path''',
     default=None,
     type=str,
     help='''Path to the folder to output PyTorch model.''',
 )
 parser.add_argument(
     '''--push_to_hub''', action='''store_true''', help='''Whether or not to push the converted model to the 🤗 hub.'''
 )
 _lowerCAmelCase      						=	parser.parse_args()
 convert_deta_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)



from typing import TYPE_CHECKING

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


UpperCamelCase  							=						{
    '''configuration_electra''': ['''ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''ElectraConfig''', '''ElectraOnnxConfig'''],
    '''tokenization_electra''': ['''ElectraTokenizer'''],
}

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

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      UpperCamelCase  							=						[
          '''ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST''',
          '''ElectraForCausalLM''',
          '''ElectraForMaskedLM''',
          '''ElectraForMultipleChoice''',
          '''ElectraForPreTraining''',
          '''ElectraForQuestionAnswering''',
          '''ElectraForSequenceClassification''',
          '''ElectraForTokenClassification''',
          '''ElectraModel''',
          '''ElectraPreTrainedModel''',
          '''load_tf_weights_in_electra''',
      ]

try:
      if not is_tf_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      UpperCamelCase  							=						[
          '''TF_ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST''',
          '''TFElectraForMaskedLM''',
          '''TFElectraForMultipleChoice''',
          '''TFElectraForPreTraining''',
          '''TFElectraForQuestionAnswering''',
          '''TFElectraForSequenceClassification''',
          '''TFElectraForTokenClassification''',
          '''TFElectraModel''',
          '''TFElectraPreTrainedModel''',
      ]

try:
      if not is_flax_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      UpperCamelCase  							=						[
          '''FlaxElectraForCausalLM''',
          '''FlaxElectraForMaskedLM''',
          '''FlaxElectraForMultipleChoice''',
          '''FlaxElectraForPreTraining''',
          '''FlaxElectraForQuestionAnswering''',
          '''FlaxElectraForSequenceClassification''',
          '''FlaxElectraForTokenClassification''',
          '''FlaxElectraModel''',
          '''FlaxElectraPreTrainedModel''',
      ]


if TYPE_CHECKING:
      from .configuration_electra import ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP, ElectraConfig, ElectraOnnxConfig
      from .tokenization_electra import ElectraTokenizer

      try:
            if not is_tokenizers_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .tokenization_electra_fast import ElectraTokenizerFast

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_electra import (
                ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST,
                ElectraForCausalLM,
                ElectraForMaskedLM,
                ElectraForMultipleChoice,
                ElectraForPreTraining,
                ElectraForQuestionAnswering,
                ElectraForSequenceClassification,
                ElectraForTokenClassification,
                ElectraModel,
                ElectraPreTrainedModel,
                load_tf_weights_in_electra,
            )

      try:
            if not is_tf_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_tf_electra import (
                TF_ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST,
                TFElectraForMaskedLM,
                TFElectraForMultipleChoice,
                TFElectraForPreTraining,
                TFElectraForQuestionAnswering,
                TFElectraForSequenceClassification,
                TFElectraForTokenClassification,
                TFElectraModel,
                TFElectraPreTrainedModel,
            )

      try:
            if not is_flax_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_flax_electra import (
                FlaxElectraForCausalLM,
                FlaxElectraForMaskedLM,
                FlaxElectraForMultipleChoice,
                FlaxElectraForPreTraining,
                FlaxElectraForQuestionAnswering,
                FlaxElectraForSequenceClassification,
                FlaxElectraForTokenClassification,
                FlaxElectraModel,
                FlaxElectraPreTrainedModel,
            )

else:
      import sys

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



