


"""simple docstring"""







import argparse
import os

import torch

from transformers import (
    XLNetConfig,
    XLNetForQuestionAnswering,
    XLNetForSequenceClassification,
    XLNetLMHeadModel,
    load_tf_weights_in_xlnet,
)
from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging


lowerCamelCase_       :       List[Any]      						=  {
    """cola""": 2,
    """mnli""": 3,
    """mrpc""": 2,
    """sst-2""": 2,
    """sts-b""": 1,
    """qqp""": 2,
    """qnli""": 2,
    """rte""": 2,
    """wnli""": 2,
}


logging.set_verbosity_info()
def _A						(						lowercase	,   lowercase	,   lowercase	,   lowercase=None		):







    """simple docstring"""
    # Initialise PyTorch model
    a					=XLNetConfig.from_json_file(lowercase		)

    a					=finetuning_task.lower() if finetuning_task is not None else ''''''
    if finetuning_task in GLUE_TASKS_NUM_LABELS:
        print(f'''Building PyTorch XLNetForSequenceClassification model from configuration: {config}'''		)
        a					=finetuning_task
        a					=GLUE_TASKS_NUM_LABELS[finetuning_task]
        a					=XLNetForSequenceClassification(lowercase		)
    elif "squad" in finetuning_task:
        a					=finetuning_task
        a					=XLNetForQuestionAnswering(lowercase		)
    else:
        a					=XLNetLMHeadModel(lowercase		)

    # Load weights from tf checkpoint
    load_tf_weights_in_xlnet(lowercase	,   lowercase	,   lowercase		)

    # Save pytorch-model
    a					=os.path.join(lowercase	,   lowercase		)
    a					=os.path.join(lowercase	,   lowercase		)
    print(f'''Save PyTorch model to {os.path.abspath(lowercase		)}'''		)
    torch.save(model.state_dict()	,   lowercase		)
    print(f'''Save configuration file to {os.path.abspath(lowercase		)}'''		)
    with open(lowercase	,   '''w'''	,   encoding='''utf-8'''		) as f:
        f.write(config.to_json_string()		)


if __name__ == "__main__":
       lowerCamelCase_       :       List[Any]      						=  argparse.ArgumentParser()
       # Required parameters
       parser.add_argument(
           """--tf_checkpoint_path""", default=None, type=str, required=True, help="""Path to the TensorFlow checkpoint path."""
       )
       parser.add_argument(
           """--xlnet_config_file""",
           default=None,
           type=str,
           required=True,
           help=(
               """The config json file corresponding to the pre-trained XLNet model. \n"""
               """This specifies the model architecture."""
           ),
       )
       parser.add_argument(
           """--pytorch_dump_folder_path""",
           default=None,
           type=str,
           required=True,
           help="""Path to the folder to store the PyTorch model or dataset/vocab.""",
       )
       parser.add_argument(
           """--finetuning_task""",
           default=None,
           type=str,
           help="""Name of a task on which the XLNet TensorFlow model was fine-tuned""",
       )
       lowerCamelCase_       :       Dict      						=  parser.parse_args()
       print(args)

       convert_xlnet_checkpoint_to_pytorch(
           args.tf_checkpoint_path, args.xlnet_config_file, args.pytorch_dump_folder_path, args.finetuning_task
       )



"""simple docstring"""







import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ..auto.configuration_auto import CONFIG_MAPPING


lowerCamelCase_       :       int      						=  logging.get_logger(__name__)






class 				__A    (	_SCREAMING_SNAKE_CASE      ):






 """simple docstring"""




 __lowerCAmelCase			 =  "upernet"


 def __init__(		self			,   __A=None			,   __A=512			,   __A=0.02			,   __A=[1, 2, 3, 6]			,   __A=True			,   __A=0.4			,   __A=384			,   __A=256			,   __A=1			,   __A=False			,   __A=255			,   **__A			,   ) ->					Tuple:
     super().__init__(**__A						)

     if backbone_config is None:
         logger.info('''`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone.'''						)
         a					=CONFIG_MAPPING['''resnet'''](out_features=['''stage1''', '''stage2''', '''stage3''', '''stage4''']						)
     elif isinstance(__A			,   __A						):
         a					=backbone_config.get('''model_type'''						)
         a					=CONFIG_MAPPING[backbone_model_type]
         a					=config_class.from_dict(__A						)

     a					=backbone_config
     a					=hidden_size
     a					=initializer_range
     a					=pool_scales
     a					=use_auxiliary_head
     a					=auxiliary_loss_weight
     a					=auxiliary_in_channels
     a					=auxiliary_channels
     a					=auxiliary_num_convs
     a					=auxiliary_concat_input
     a					=loss_ignore_index





 def 				SCREAMING_SNAKE_CASE							(		self						) ->					Dict:
     a					=copy.deepcopy(self.__dict__						)
     a					=self.backbone_config.to_dict()
     a					=self.__class__.model_type
     return output