
"""simple docstring"""




import random
import unittest

import torch

from diffusers import IFImgaImgSuperResolutionPipeline
from diffusers.utils import floats_tensor
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import skip_mps, torch_device

from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin
from . import IFPipelineTesterMixin







@skip_mps
class   _lowercase						(       lowerCAmelCase_	,   lowerCAmelCase_	,   unittest.TestCase				):


     '''simple docstring'''





     _A								=							IFImgaImgSuperResolutionPipeline
     _A								=							TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'width', 'height'}
     _A								=							TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({'original_image'}				)
     _A								=							PipelineTesterMixin.required_optional_params - {'latents'}



     def  lowerCAmelCase__       (      self  )->					Any:
          return self._get_superresolution_dummy_components()



     def  lowerCAmelCase__       (      self ,			__UpperCamelCase ,			__UpperCamelCase=0  )->					List[str]:
          if str(__UpperCamelCase  ).startswith("mps"  ):
               UpperCAmelCase__							: Optional[int] 							=						torch.manual_seed(__UpperCamelCase  )
          else:
               UpperCAmelCase__							: str 							=						torch.Generator(device=__UpperCamelCase  ).manual_seed(__UpperCamelCase  )

          UpperCAmelCase__							: List[Any] 							=						floats_tensor((1, 3, 32, 32) ,			rng=random.Random(__UpperCamelCase  )  ).to(__UpperCamelCase  )
          UpperCAmelCase__							: Union[str, Any] 							=						floats_tensor((1, 3, 16, 16) ,			rng=random.Random(__UpperCamelCase  )  ).to(__UpperCamelCase  )

          UpperCAmelCase__							: Dict 							=						{
              "prompt": "A painting of a squirrel eating a burger",
              "image": image,
              "original_image": original_image,
              "generator": generator,
              "num_inference_steps": 2,
              "output_type": "numpy",
          }

          return inputs



     @unittest.skipIf(
         torch_device != "cuda" or not is_xformers_available() ,			reason="XFormers attention is only available with CUDA and `xformers` installed" ,			)
     def  lowerCAmelCase__       (      self  )->					Tuple:
          self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3  )



     def  lowerCAmelCase__       (      self  )->					List[str]:
          self._test_save_load_optional_components()



     @unittest.skipIf(torch_device != "cuda" ,			reason="float16 requires CUDA"  )
     def  lowerCAmelCase__       (      self  )->					str:
          # Due to non-determinism in save load of the hf-internal-testing/tiny-random-t5 text encoder
          super().test_save_load_floataa(expected_max_diff=1E-1  )



     def  lowerCAmelCase__       (      self  )->					Tuple:
          self._test_attention_slicing_forward_pass(expected_max_diff=1E-2  )



     def  lowerCAmelCase__       (      self  )->					List[Any]:
          self._test_save_load_local()



     def  lowerCAmelCase__       (      self  )->					Union[str, Any]:
          self._test_inference_batch_single_identical(
              expected_max_diff=1E-2 ,			)





"""simple docstring"""




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__ (				lowerCAmelCase	:       List[Any]       ,    lowerCAmelCase	:       Any       ,    lowerCAmelCase	:       List[Any]		):






     '''simple docstring'''
     # Construct model
     if gpta_config_file == "":
          UpperCAmelCase__							: Optional[int] 							=						GPTaConfig()
     else:
          UpperCAmelCase__							: Dict 							=						GPTaConfig.from_json_file(lowerCAmelCase		)
     UpperCAmelCase__							: Optional[Any] 							=						GPTaModel(lowerCAmelCase		)

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

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


if __name__ == "__main__":
    A__      :	Optional[int]          =    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."""
        ),
    )
    A__      :	Optional[Any]          =    parser.parse_args()
    convert_gpta_checkpoint_to_pytorch(args.gpta_checkpoint_path, args.gpta_config_file, args.pytorch_dump_folder_path)



