





import unittest

import numpy as np

from transformers.testing_utils import require_flax, require_tf, require_torch
from transformers.utils import (
    expand_dims,
    flatten_dict,
    is_flax_available,
    is_tf_available,
    is_torch_available,
    reshape,
    squeeze,
    transpose,
)


if is_flax_available():
    import jax.numpy as jnp

if is_tf_available():
    import tensorflow as tf

if is_torch_available():
    import torch





class 			A__   (							unittest.TestCase     ):




   """simple docstring"""



   def 							__lowercase		( self)      ->						Dict:







          '''simple docstring'''

          a__						:     List[str]			=    {
              """task_specific_params""": {
                  """summarization""": {"""length_penalty""": 1.0, """max_length""": 128, """min_length""": 12, """num_beams""": 4},
                  """summarization_cnn""": {"""length_penalty""": 2.0, """max_length""": 142, """min_length""": 56, """num_beams""": 4},
                  """summarization_xsum""": {"""length_penalty""": 1.0, """max_length""": 62, """min_length""": 11, """num_beams""": 6},
              }
          }
          a__						:     Optional[Any]			=    {
              """task_specific_params.summarization.length_penalty""": 1.0,
              """task_specific_params.summarization.max_length""": 128,
              """task_specific_params.summarization.min_length""": 12,
              """task_specific_params.summarization.num_beams""": 4,
              """task_specific_params.summarization_cnn.length_penalty""": 2.0,
              """task_specific_params.summarization_cnn.max_length""": 142,
              """task_specific_params.summarization_cnn.min_length""": 56,
              """task_specific_params.summarization_cnn.num_beams""": 4,
              """task_specific_params.summarization_xsum.length_penalty""": 1.0,
              """task_specific_params.summarization_xsum.max_length""": 62,
              """task_specific_params.summarization_xsum.min_length""": 11,
              """task_specific_params.summarization_xsum.num_beams""": 6,
          }

          self.assertEqual(flatten_dict(_SCREAMING_SNAKE_CASE) ,  _SCREAMING_SNAKE_CASE)

   def 							__lowercase		( self)      ->						str:







          '''simple docstring'''

          a__						:     str			=    np.random.randn(3 ,  4)
          self.assertTrue(np.allclose(transpose(_SCREAMING_SNAKE_CASE) ,  x.transpose()))

          a__						:     List[Any]			=    np.random.randn(3 ,  4 ,  5)
          self.assertTrue(np.allclose(transpose(_SCREAMING_SNAKE_CASE ,  axes=(1, 2, 0)) ,  x.transpose((1, 2, 0))))

   @require_torch
   def 							__lowercase		( self)      ->						Union[str, Any]:







          '''simple docstring'''

          a__						:     Optional[int]			=    np.random.randn(3 ,  4)
          a__						:     Tuple			=    torch.tensor(_SCREAMING_SNAKE_CASE)
          self.assertTrue(np.allclose(transpose(_SCREAMING_SNAKE_CASE) ,  transpose(_SCREAMING_SNAKE_CASE).numpy()))

          a__						:     List[str]			=    np.random.randn(3 ,  4 ,  5)
          a__						:     List[str]			=    torch.tensor(_SCREAMING_SNAKE_CASE)
          self.assertTrue(np.allclose(transpose(_SCREAMING_SNAKE_CASE ,  axes=(1, 2, 0)) ,  transpose(_SCREAMING_SNAKE_CASE ,  axes=(1, 2, 0)).numpy()))

   @require_tf
   def 							__lowercase		( self)      ->						str:







          '''simple docstring'''

          a__						:     Optional[int]			=    np.random.randn(3 ,  4)
          a__						:     Dict			=    tf.constant(_SCREAMING_SNAKE_CASE)
          self.assertTrue(np.allclose(transpose(_SCREAMING_SNAKE_CASE) ,  transpose(_SCREAMING_SNAKE_CASE).numpy()))

          a__						:     List[Any]			=    np.random.randn(3 ,  4 ,  5)
          a__						:     List[Any]			=    tf.constant(_SCREAMING_SNAKE_CASE)
          self.assertTrue(np.allclose(transpose(_SCREAMING_SNAKE_CASE ,  axes=(1, 2, 0)) ,  transpose(_SCREAMING_SNAKE_CASE ,  axes=(1, 2, 0)).numpy()))

   @require_flax
   def 							__lowercase		( self)      ->						Tuple:







          '''simple docstring'''

          a__						:     List[Any]			=    np.random.randn(3 ,  4)
          a__						:     Union[str, Any]			=    jnp.array(_SCREAMING_SNAKE_CASE)
          self.assertTrue(np.allclose(transpose(_SCREAMING_SNAKE_CASE) ,  np.asarray(transpose(_SCREAMING_SNAKE_CASE))))

          a__						:     Dict			=    np.random.randn(3 ,  4 ,  5)
          a__						:     int			=    jnp.array(_SCREAMING_SNAKE_CASE)
          self.assertTrue(np.allclose(transpose(_SCREAMING_SNAKE_CASE ,  axes=(1, 2, 0)) ,  np.asarray(transpose(_SCREAMING_SNAKE_CASE ,  axes=(1, 2, 0)))))

   def 							__lowercase		( self)      ->						Union[str, Any]:







          '''simple docstring'''

          a__						:     str			=    np.random.randn(3 ,  4)
          self.assertTrue(np.allclose(reshape(_SCREAMING_SNAKE_CASE ,  (4, 3)) ,  np.reshape(_SCREAMING_SNAKE_CASE ,  (4, 3))))

          a__						:     Any			=    np.random.randn(3 ,  4 ,  5)
          self.assertTrue(np.allclose(reshape(_SCREAMING_SNAKE_CASE ,  (12, 5)) ,  np.reshape(_SCREAMING_SNAKE_CASE ,  (12, 5))))

   @require_torch
   def 							__lowercase		( self)      ->						List[str]:







          '''simple docstring'''

          a__						:     int			=    np.random.randn(3 ,  4)
          a__						:     str			=    torch.tensor(_SCREAMING_SNAKE_CASE)
          self.assertTrue(np.allclose(reshape(_SCREAMING_SNAKE_CASE ,  (4, 3)) ,  reshape(_SCREAMING_SNAKE_CASE ,  (4, 3)).numpy()))

          a__						:     Dict			=    np.random.randn(3 ,  4 ,  5)
          a__						:     Tuple			=    torch.tensor(_SCREAMING_SNAKE_CASE)
          self.assertTrue(np.allclose(reshape(_SCREAMING_SNAKE_CASE ,  (12, 5)) ,  reshape(_SCREAMING_SNAKE_CASE ,  (12, 5)).numpy()))

   @require_tf
   def 							__lowercase		( self)      ->						List[Any]:







          '''simple docstring'''

          a__						:     int			=    np.random.randn(3 ,  4)
          a__						:     Union[str, Any]			=    tf.constant(_SCREAMING_SNAKE_CASE)
          self.assertTrue(np.allclose(reshape(_SCREAMING_SNAKE_CASE ,  (4, 3)) ,  reshape(_SCREAMING_SNAKE_CASE ,  (4, 3)).numpy()))

          a__						:     Optional[Any]			=    np.random.randn(3 ,  4 ,  5)
          a__						:     List[Any]			=    tf.constant(_SCREAMING_SNAKE_CASE)
          self.assertTrue(np.allclose(reshape(_SCREAMING_SNAKE_CASE ,  (12, 5)) ,  reshape(_SCREAMING_SNAKE_CASE ,  (12, 5)).numpy()))

   @require_flax
   def 							__lowercase		( self)      ->						str:







          '''simple docstring'''

          a__						:     Optional[Any]			=    np.random.randn(3 ,  4)
          a__						:     Union[str, Any]			=    jnp.array(_SCREAMING_SNAKE_CASE)
          self.assertTrue(np.allclose(reshape(_SCREAMING_SNAKE_CASE ,  (4, 3)) ,  np.asarray(reshape(_SCREAMING_SNAKE_CASE ,  (4, 3)))))

          a__						:     List[str]			=    np.random.randn(3 ,  4 ,  5)
          a__						:     List[str]			=    jnp.array(_SCREAMING_SNAKE_CASE)
          self.assertTrue(np.allclose(reshape(_SCREAMING_SNAKE_CASE ,  (12, 5)) ,  np.asarray(reshape(_SCREAMING_SNAKE_CASE ,  (12, 5)))))

   def 							__lowercase		( self)      ->						int:







          '''simple docstring'''

          a__						:     List[str]			=    np.random.randn(1 ,  3 ,  4)
          self.assertTrue(np.allclose(squeeze(_SCREAMING_SNAKE_CASE) ,  np.squeeze(_SCREAMING_SNAKE_CASE)))

          a__						:     Union[str, Any]			=    np.random.randn(1 ,  4 ,  1 ,  5)
          self.assertTrue(np.allclose(squeeze(_SCREAMING_SNAKE_CASE ,  axis=2) ,  np.squeeze(_SCREAMING_SNAKE_CASE ,  axis=2)))

   @require_torch
   def 							__lowercase		( self)      ->						int:







          '''simple docstring'''

          a__						:     List[Any]			=    np.random.randn(1 ,  3 ,  4)
          a__						:     List[str]			=    torch.tensor(_SCREAMING_SNAKE_CASE)
          self.assertTrue(np.allclose(squeeze(_SCREAMING_SNAKE_CASE) ,  squeeze(_SCREAMING_SNAKE_CASE).numpy()))

          a__						:     int			=    np.random.randn(1 ,  4 ,  1 ,  5)
          a__						:     Tuple			=    torch.tensor(_SCREAMING_SNAKE_CASE)
          self.assertTrue(np.allclose(squeeze(_SCREAMING_SNAKE_CASE ,  axis=2) ,  squeeze(_SCREAMING_SNAKE_CASE ,  axis=2).numpy()))

   @require_tf
   def 							__lowercase		( self)      ->						str:







          '''simple docstring'''

          a__						:     int			=    np.random.randn(1 ,  3 ,  4)
          a__						:     Dict			=    tf.constant(_SCREAMING_SNAKE_CASE)
          self.assertTrue(np.allclose(squeeze(_SCREAMING_SNAKE_CASE) ,  squeeze(_SCREAMING_SNAKE_CASE).numpy()))

          a__						:     Dict			=    np.random.randn(1 ,  4 ,  1 ,  5)
          a__						:     List[str]			=    tf.constant(_SCREAMING_SNAKE_CASE)
          self.assertTrue(np.allclose(squeeze(_SCREAMING_SNAKE_CASE ,  axis=2) ,  squeeze(_SCREAMING_SNAKE_CASE ,  axis=2).numpy()))

   @require_flax
   def 							__lowercase		( self)      ->						Union[str, Any]:







          '''simple docstring'''

          a__						:     int			=    np.random.randn(1 ,  3 ,  4)
          a__						:     Optional[Any]			=    jnp.array(_SCREAMING_SNAKE_CASE)
          self.assertTrue(np.allclose(squeeze(_SCREAMING_SNAKE_CASE) ,  np.asarray(squeeze(_SCREAMING_SNAKE_CASE))))

          a__						:     Optional[Any]			=    np.random.randn(1 ,  4 ,  1 ,  5)
          a__						:     Optional[Any]			=    jnp.array(_SCREAMING_SNAKE_CASE)
          self.assertTrue(np.allclose(squeeze(_SCREAMING_SNAKE_CASE ,  axis=2) ,  np.asarray(squeeze(_SCREAMING_SNAKE_CASE ,  axis=2))))

   def 							__lowercase		( self)      ->						List[str]:







          '''simple docstring'''

          a__						:     Dict			=    np.random.randn(3 ,  4)
          self.assertTrue(np.allclose(expand_dims(_SCREAMING_SNAKE_CASE ,  axis=1) ,  np.expand_dims(_SCREAMING_SNAKE_CASE ,  axis=1)))

   @require_torch
   def 							__lowercase		( self)      ->						str:







          '''simple docstring'''

          a__						:     Tuple			=    np.random.randn(3 ,  4)
          a__						:     str			=    torch.tensor(_SCREAMING_SNAKE_CASE)
          self.assertTrue(np.allclose(expand_dims(_SCREAMING_SNAKE_CASE ,  axis=1) ,  expand_dims(_SCREAMING_SNAKE_CASE ,  axis=1).numpy()))

   @require_tf
   def 							__lowercase		( self)      ->						Optional[Any]:







          '''simple docstring'''

          a__						:     int			=    np.random.randn(3 ,  4)
          a__						:     List[str]			=    tf.constant(_SCREAMING_SNAKE_CASE)
          self.assertTrue(np.allclose(expand_dims(_SCREAMING_SNAKE_CASE ,  axis=1) ,  expand_dims(_SCREAMING_SNAKE_CASE ,  axis=1).numpy()))

   @require_flax
   def 							__lowercase		( self)      ->						List[Any]:







          '''simple docstring'''

          a__						:     Optional[int]			=    np.random.randn(3 ,  4)
          a__						:     Optional[Any]			=    jnp.array(_SCREAMING_SNAKE_CASE)
          self.assertTrue(np.allclose(expand_dims(_SCREAMING_SNAKE_CASE ,  axis=1) ,  np.asarray(expand_dims(_SCREAMING_SNAKE_CASE ,  axis=1))))









import argparse

import torch

from transformers import GPTaConfig, GPTaModel, load_tf_weights_in_gpta
from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging


logging.set_verbosity_info()



def A_     (		A__		,				A__		,				A__    )  ->		Any:
       # Construct model
       if gpta_config_file == "":
              a__						:     Optional[int]			=    GPTaConfig()
       else:
              a__						:     List[str]			=    GPTaConfig.from_json_file(A__    )
       a__						:     List[str]			=    GPTaModel(A__    )

       # Load weights from numpy
       load_tf_weights_in_gpta(A__		,				A__		,				A__    )

       # Save pytorch-model
       a__						:     Optional[Any]			=    pytorch_dump_folder_path + '/' + WEIGHTS_NAME
       a__						:     Any			=    pytorch_dump_folder_path + '/' + CONFIG_NAME
       print(F'Save PyTorch model to {pytorch_weights_dump_path}'    )
       torch.save(model.state_dict()		,				A__    )
       print(F'Save configuration file to {pytorch_config_dump_path}'    )
       with open(A__		,				'w'		,				encoding='utf-8'    ) as f:
              f.write(config.to_json_string()    )


if __name__ == "__main__":
    lowercase				:	Dict      						=  argparse.ArgumentParser()
    # Required parameters
    parser.add_argument(
        """--gpt2_checkpoint_path""", default=None, type=str, required=True, help="""Path to the TensorFlow checkpoint path."""
    )
    parser.add_argument(
        """--pytorch_dump_folder_path""", default=None, type=str, required=True, help="""Path to the output PyTorch model."""
    )
    parser.add_argument(
        """--gpt2_config_file""",
        default="""""",
        type=str,
        help=(
            """An optional config json file corresponding to the pre-trained OpenAI model. \n"""
            """This specifies the model architecture."""
        ),
    )
    lowercase				:	int      						=  parser.parse_args()
    convert_gpta_checkpoint_to_pytorch(args.gpta_checkpoint_path, args.gpta_config_file, args.pytorch_dump_folder_path)


