



'''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[str]		 =		{
    "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       ):
  a		:      Union[str, Any]       =  XLNetConfig.from_json_file(lowerCamelCase__       )

  a		:      Dict       =  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		:      int       =  finetuning_task
    a		:      int       =  GLUE_TASKS_NUM_LABELS[finetuning_task]
    a		:      List[str]       =  XLNetForSequenceClassification(lowerCamelCase__       )
  elif "squad" in finetuning_task:
    a		:      Optional[Any]       =  finetuning_task
    a		:      Dict       =  XLNetForQuestionAnswering(lowerCamelCase__       )
  else:
    a		:      Tuple       =  XLNetLMHeadModel(lowerCamelCase__       )

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

  # Save pytorch-model
  a		:      int       =  os.path.join(lowerCamelCase__				,    lowerCamelCase__       )
  a		:      List[str]       =  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__":
     lowerCAmelCase:      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:      List[str]		 =		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 collections import OrderedDict
from typing import TYPE_CHECKING, Any, Mapping, Optional

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


if TYPE_CHECKING:
     from ... import FeatureExtractionMixin, TensorType

lowerCAmelCase:      List[Any]		 =		logging.get_logger(__name__)

lowerCAmelCase:      List[str]		 =		{
    'openai/imagegpt-small': '',
    'openai/imagegpt-medium': '',
    'openai/imagegpt-large': '',
}

class 							a__(      lowerCamelCase__			):
    lowercase__				=					"""imagegpt"""
    lowercase__				=					["""past_key_values"""]
    lowercase__				=					{
        """hidden_size""": """n_embd""",
        """max_position_embeddings""": """n_positions""",
        """num_attention_heads""": """n_head""",
        """num_hidden_layers""": """n_layer""",
    }







    def __init__(   self				:						List[str]		,    __snake_case				:						int=5_12 + 1		,    __snake_case				:						Optional[Any]=32 * 32		,    __snake_case				:						Optional[Any]=5_12		,    __snake_case				:						List[str]=24		,    __snake_case				:						Tuple=8		,    __snake_case				:						Optional[int]=None		,    __snake_case				:						Dict="quick_gelu"		,    __snake_case				:						Dict=0.1		,    __snake_case				:						List[str]=0.1		,    __snake_case				:						Optional[Any]=0.1		,    __snake_case				:						Tuple=1e-5		,    __snake_case				:						Union[str, Any]=0.02		,    __snake_case				:						Optional[int]=True		,    __snake_case				:						Dict=True		,    __snake_case				:						str=False		,    __snake_case				:						Any=False		,    __snake_case				:						List[Any]=False		,    **__snake_case				:						List[str]		,    ):
      a		:      Optional[Any]       =  vocab_size
      a		:      Union[str, Any]       =  n_positions
      a		:      int       =  n_embd
      a		:      int       =  n_layer
      a		:      str       =  n_head
      a		:      int       =  n_inner
      a		:      int       =  activation_function
      a		:      Any       =  resid_pdrop
      a		:      Tuple       =  embd_pdrop
      a		:      List[Any]       =  attn_pdrop
      a		:      Tuple       =  layer_norm_epsilon
      a		:      Any       =  initializer_range
      a		:      str       =  scale_attn_weights
      a		:      List[Any]       =  use_cache
      a		:      Any       =  scale_attn_by_inverse_layer_idx
      a		:      Optional[Any]       =  reorder_and_upcast_attn
      a		:      str       =  tie_word_embeddings

      super().__init__(tie_word_embeddings=__snake_case		,    **__snake_case			)

class 							a__(      lowerCamelCase__			):







    @property
    def     lowercase_ (   self				:						Union[str, Any]			):
      return OrderedDict(
          [
              ('input_ids', {0: 'batch', 1: 'sequence'}),
          ]			)







    def     lowercase_ (   self				:						Union[str, Any]		,    __snake_case				:						"FeatureExtractionMixin"		,    __snake_case				:						int = 1		,    __snake_case				:						int = -1		,    __snake_case				:						bool = False		,    __snake_case				:						Optional["TensorType"] = None		,    __snake_case				:						int = 3		,    __snake_case				:						int = 32		,    __snake_case				:						int = 32		,    ):
      a		:      Dict       =  self._generate_dummy_images(__snake_case		,    __snake_case		,    __snake_case		,    __snake_case			)
      a		:      Union[str, Any]       =  dict(preprocessor(images=__snake_case		,    return_tensors=__snake_case			)			)

      return inputs