

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


lowercase_       		=  {
    "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 						_snake_case(    SCREAMING_SNAKE_CASE__			:	Optional[Any]    ,			SCREAMING_SNAKE_CASE__			:	Optional[Any]    ,			SCREAMING_SNAKE_CASE__			:	str    ,			SCREAMING_SNAKE_CASE__			:	Optional[Any]=None      )							->      Dict:





    '''simple docstring'''






    A__          =   XLNetConfig.from_json_file(SCREAMING_SNAKE_CASE__      )

    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(SCREAMING_SNAKE_CASE__      )
    elif "squad" in finetuning_task:
        A__          =   finetuning_task
        A__          =   XLNetForQuestionAnswering(SCREAMING_SNAKE_CASE__      )
    else:
        A__          =   XLNetLMHeadModel(SCREAMING_SNAKE_CASE__      )

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

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


if __name__ == "__main__":
     lowercase_       		=  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",
     )
     lowercase_       		=  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
     )




from timeit import timeit
def 						_snake_case(    SCREAMING_SNAKE_CASE__			:	int      )							->      int:





    '''simple docstring'''






    if number < 0:
        raise ValueError('the value of input must not be negative'      )
    A__          =   0
    while number:
        number &= number - 1
        result += 1
    return result
def 						_snake_case(    SCREAMING_SNAKE_CASE__			:	int      )							->      int:





    '''simple docstring'''






    if number < 0:
        raise ValueError('the value of input must not be negative'      )
    A__          =   0
    while number:
        if number % 2 == 1:
            result += 1
        number >>= 1
    return result
def 						_snake_case(    )							->      None:





    '''simple docstring'''






    def do_benchmark(SCREAMING_SNAKE_CASE__			:	int      ) -> None:
        A__          =   'import __main__ as z'
        print(f'Benchmark when {number = }:'      )
        print(f'{get_set_bits_count_using_modulo_operator(SCREAMING_SNAKE_CASE__      ) = }'      )
        A__          =   timeit('z.get_set_bits_count_using_modulo_operator(25)'    ,			setup=SCREAMING_SNAKE_CASE__      )
        print(f'timeit() runs in {timing} seconds'      )
        print(f'{get_set_bits_count_using_brian_kernighans_algorithm(SCREAMING_SNAKE_CASE__      ) = }'      )
        A__          =   timeit(
            'z.get_set_bits_count_using_brian_kernighans_algorithm(25)'    ,			setup=SCREAMING_SNAKE_CASE__    ,			)
        print(f'timeit() runs in {timing} seconds'      )

    for number in (25, 37, 58, 0):
        do_benchmark(SCREAMING_SNAKE_CASE__      )
        print()


if __name__ == "__main__":
     import doctest

     doctest.testmod()
     benchmark()

