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


UpperCamelCase__    							= {
    '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        lowerCAmelCase_			(					__A,  __A,  __A,  __A=None							)					->    Dict:







      '''simple docstring'''


      UpperCAmelCase__								=  XLNetConfig.from_json_file(__A							)

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

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

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


if __name__ == "__main__":
      UpperCamelCase__    							= 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',
      )
      UpperCamelCase__    							= 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 __future__ import annotations




def        lowerCAmelCase_			(					__A,  __A,  __A,  )					->    tuple:







      '''simple docstring'''


      if (electron_conc, hole_conc, intrinsic_conc).count(0							) != 1:
            raise ValueError("You cannot supply more or less than 2 values"							)
      elif electron_conc < 0:
            raise ValueError("Electron concentration cannot be negative in a semiconductor"							)
      elif hole_conc < 0:
            raise ValueError("Hole concentration cannot be negative in a semiconductor"							)
      elif intrinsic_conc < 0:
            raise ValueError(
                "Intrinsic concentration cannot be negative in a semiconductor"							)
      elif electron_conc == 0:
            return (
                "electron_conc",
                intrinsic_conc**2 / hole_conc,
            )
      elif hole_conc == 0:
            return (
                "hole_conc",
                intrinsic_conc**2 / electron_conc,
            )
      elif intrinsic_conc == 0:
            return (
                "intrinsic_conc",
                (electron_conc * hole_conc) ** 0.5,
            )
      else:
            return (-1, -1)


if __name__ == "__main__":
      import doctest

      doctest.testmod()



