






'''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


SCREAMING_SNAKE_CASE__											=     {
    """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 					lowercase__				(   __UpperCamelCase	,		__UpperCamelCase	,		__UpperCamelCase	,		__UpperCamelCase=None					)->				str:
      # Initialise PyTorch model
      UpperCamelCase       						=      XLNetConfig.from_json_file(_lowerCAmelCase					)

      UpperCamelCase       						=      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}"					)
            UpperCamelCase       						=      finetuning_task
            UpperCamelCase       						=      GLUE_TASKS_NUM_LABELS[finetuning_task]
            UpperCamelCase       						=      XLNetForSequenceClassification(_lowerCAmelCase					)
      elif "squad" in finetuning_task:
            UpperCamelCase       						=      finetuning_task
            UpperCamelCase       						=      XLNetForQuestionAnswering(_lowerCAmelCase					)
      else:
            UpperCamelCase       						=      XLNetLMHeadModel(_lowerCAmelCase					)

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

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


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

from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
)


SCREAMING_SNAKE_CASE__											=     {
    'configuration_swiftformer': [
        'SWIFTFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'SwiftFormerConfig',
        'SwiftFormerOnnxConfig',
    ]
}

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     SCREAMING_SNAKE_CASE__											=     [
         'SWIFTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST',
         'SwiftFormerForImageClassification',
         'SwiftFormerModel',
         'SwiftFormerPreTrainedModel',
     ]

if TYPE_CHECKING:
     from .configuration_swiftformer import (
         SWIFTFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
         SwiftFormerConfig,
         SwiftFormerOnnxConfig,
     )

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_swiftformer import (
              SWIFTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
              SwiftFormerForImageClassification,
              SwiftFormerModel,
              SwiftFormerPreTrainedModel,
          )

else:
     import sys

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