


'''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 			lowercase				(_A   ,						_A   ,						_A   ,						_A=None					):







       """simple docstring"""







       _lowerCAmelCase    :							Tuple   			=       XLNetConfig.from_json_file(_A					)

       _lowerCAmelCase    :							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}'					)
              _lowerCAmelCase    :							Union[str, Any]   			=       finetuning_task
              _lowerCAmelCase    :							Tuple   			=       GLUE_TASKS_NUM_LABELS[finetuning_task]
              _lowerCAmelCase    :							List[Any]   			=       XLNetForSequenceClassification(_A					)
       elif "squad" in finetuning_task:
              _lowerCAmelCase    :							int   			=       finetuning_task
              _lowerCAmelCase    :							Optional[int]   			=       XLNetForQuestionAnswering(_A					)
       else:
              _lowerCAmelCase    :							Optional[int]   			=       XLNetLMHeadModel(_A					)

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

       # Save pytorch-model
       _lowerCAmelCase    :							int   			=       os.path.join(_A   ,						_A					)
       _lowerCAmelCase    :							Dict   			=       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__":
       lowerCAmelCase    :     str					=						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    :     int					=						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 unittest

from transformers import AutoTokenizer, is_flax_available
from transformers.testing_utils import require_flax, require_sentencepiece, require_tokenizers, slow


if is_flax_available():
       import jax.numpy as jnp

       from transformers import FlaxXLMRobertaModel
@require_sentencepiece
@require_tokenizers
@require_flax
class 	UpperCamelCase__					( unittest.TestCase	):



     """simple docstring"""






     @slow
     def a	( self   ):

            '''simple docstring'''

            _lowerCAmelCase    :							List[str]   			=       FlaxXLMRobertaModel.from_pretrained('xlm-roberta-base'   )
            _lowerCAmelCase    :							Optional[Any]   			=       AutoTokenizer.from_pretrained('xlm-roberta-base'   )
            _lowerCAmelCase    :							Dict   			=       'The dog is cute and lives in the garden house'
            _lowerCAmelCase    :							List[str]   			=       jnp.array([tokenizer.encode(snake_case__   )]   )

            _lowerCAmelCase    :							Optional[int]   			=       (1, 12, 768)  # batch_size, sequence_length, embedding_vector_dim
            _lowerCAmelCase    :							Tuple   			=       jnp.array(
                [[-0.0101, 0.1218, -0.0803, 0.0801, 0.1327, 0.0776, -0.1215, 0.2383, 0.3338, 0.3106, 0.0300, 0.0252]]   )

            _lowerCAmelCase    :							Union[str, Any]   			=       model(snake_case__   )['last_hidden_state']
            self.assertEqual(output.shape      ,	snake_case__   )
            # compare the actual values for a slice of last dim
            self.assertTrue(jnp.allclose(output[:, :, -1]      ,	snake_case__      ,	atol=1E-3   )   )

