






from argparse import ArgumentParser, Namespace

from ..utils import logging
from . import BaseTransformersCLICommand
def 						_a    (      a :Namespace )							->			Optional[int]:
 return ConvertCommand(
     args.model_type	,							args.tf_checkpoint	,							args.pytorch_dump_output	,							args.config	,							args.finetuning_task_name )


UpperCAmelCase__				   =		"\ntransformers can only be used from the commandline to convert TensorFlow models in PyTorch, In that case, it requires\nTensorFlow to be installed. Please see https://www.tensorflow.org/install/ for installation instructions.\n"






class 		lowercase_					(	lowercase   ):






      '''simple docstring'''




      @staticmethod
      def       __lowerCAmelCase					(      __UpperCAmelCase      :						ArgumentParser  )    ->List[str]:




       """simple docstring"""


       a		  =      parser.add_parser(
           '''convert''' ,					help='''CLI tool to run convert model from original author checkpoints to Transformers PyTorch checkpoints.''' ,					)
       train_parser.add_argument('''--model_type''' ,					type=__UpperCAmelCase ,					required=__UpperCAmelCase ,					help='''Model\'s type.'''  )
       train_parser.add_argument(
           '''--tf_checkpoint''' ,					type=__UpperCAmelCase ,					required=__UpperCAmelCase ,					help='''TensorFlow checkpoint path or folder.'''  )
       train_parser.add_argument(
           '''--pytorch_dump_output''' ,					type=__UpperCAmelCase ,					required=__UpperCAmelCase ,					help='''Path to the PyTorch saved model output.'''  )
       train_parser.add_argument('''--config''' ,					type=__UpperCAmelCase ,					default='''''' ,					help='''Configuration file path or folder.'''  )
       train_parser.add_argument(
           '''--finetuning_task_name''' ,					type=__UpperCAmelCase ,					default=__UpperCAmelCase ,					help='''Optional fine-tuning task name if the TF model was a finetuned model.''' ,					)
       train_parser.set_defaults(func=__UpperCAmelCase  )







      def __init__(      self      :						Optional[int] ,					__UpperCAmelCase      :						str ,					__UpperCAmelCase      :						str ,					__UpperCAmelCase      :						str ,					__UpperCAmelCase      :						str ,					__UpperCAmelCase      :						str ,					*__UpperCAmelCase      :						Optional[Any] ,					)    ->Optional[Any]:




       """simple docstring"""


       a		  =      logging.get_logger('''transformers-cli/converting'''  )

       self._logger.info(F"""Loading model {model_type}"""  )
       a		  =      model_type
       a		  =      tf_checkpoint
       a		  =      pytorch_dump_output
       a		  =      config
       a		  =      finetuning_task_name







      def       __lowerCAmelCase					(      self      :						List[str]  )    ->Optional[Any]:




       """simple docstring"""


       if self._model_type == "albert":
        try:
         from ..models.albert.convert_albert_original_tf_checkpoint_to_pytorch import (
             convert_tf_checkpoint_to_pytorch,
         )
        except ImportError:
         raise ImportError(__UpperCAmelCase  )

        convert_tf_checkpoint_to_pytorch(self._tf_checkpoint ,					self._config ,					self._pytorch_dump_output  )
       elif self._model_type == "bert":
        try:
         from ..models.bert.convert_bert_original_tf_checkpoint_to_pytorch import (
             convert_tf_checkpoint_to_pytorch,
         )
        except ImportError:
         raise ImportError(__UpperCAmelCase  )

        convert_tf_checkpoint_to_pytorch(self._tf_checkpoint ,					self._config ,					self._pytorch_dump_output  )
       elif self._model_type == "funnel":
        try:
         from ..models.funnel.convert_funnel_original_tf_checkpoint_to_pytorch import (
             convert_tf_checkpoint_to_pytorch,
         )
        except ImportError:
         raise ImportError(__UpperCAmelCase  )

        convert_tf_checkpoint_to_pytorch(self._tf_checkpoint ,					self._config ,					self._pytorch_dump_output  )
       elif self._model_type == "t5":
        try:
         from ..models.ta.convert_ta_original_tf_checkpoint_to_pytorch import convert_tf_checkpoint_to_pytorch
        except ImportError:
         raise ImportError(__UpperCAmelCase  )

        convert_tf_checkpoint_to_pytorch(self._tf_checkpoint ,					self._config ,					self._pytorch_dump_output  )
       elif self._model_type == "gpt":
        from ..models.openai.convert_openai_original_tf_checkpoint_to_pytorch import (
            convert_openai_checkpoint_to_pytorch,
        )

        convert_openai_checkpoint_to_pytorch(self._tf_checkpoint ,					self._config ,					self._pytorch_dump_output  )
       elif self._model_type == "transfo_xl":
        try:
         from ..models.transfo_xl.convert_transfo_xl_original_tf_checkpoint_to_pytorch import (
             convert_transfo_xl_checkpoint_to_pytorch,
         )
        except ImportError:
         raise ImportError(__UpperCAmelCase  )

        if "ckpt" in self._tf_checkpoint.lower():
         a		  =      self._tf_checkpoint
         a		  =      ''''''
        else:
         a		  =      self._tf_checkpoint
         a		  =      ''''''
        convert_transfo_xl_checkpoint_to_pytorch(
            __UpperCAmelCase ,					self._config ,					self._pytorch_dump_output ,					__UpperCAmelCase  )
       elif self._model_type == "gpt2":
        try:
         from ..models.gpta.convert_gpta_original_tf_checkpoint_to_pytorch import (
             convert_gpta_checkpoint_to_pytorch,
         )
        except ImportError:
         raise ImportError(__UpperCAmelCase  )

        convert_gpta_checkpoint_to_pytorch(self._tf_checkpoint ,					self._config ,					self._pytorch_dump_output  )
       elif self._model_type == "xlnet":
        try:
         from ..models.xlnet.convert_xlnet_original_tf_checkpoint_to_pytorch import (
             convert_xlnet_checkpoint_to_pytorch,
         )
        except ImportError:
         raise ImportError(__UpperCAmelCase  )

        convert_xlnet_checkpoint_to_pytorch(
            self._tf_checkpoint ,					self._config ,					self._pytorch_dump_output ,					self._finetuning_task_name  )
       elif self._model_type == "xlm":
        from ..models.xlm.convert_xlm_original_pytorch_checkpoint_to_pytorch import (
            convert_xlm_checkpoint_to_pytorch,
        )

        convert_xlm_checkpoint_to_pytorch(self._tf_checkpoint ,					self._pytorch_dump_output  )
       elif self._model_type == "lxmert":
        from ..models.lxmert.convert_lxmert_original_tf_checkpoint_to_pytorch import (
            convert_lxmert_checkpoint_to_pytorch,
        )

        convert_lxmert_checkpoint_to_pytorch(self._tf_checkpoint ,					self._pytorch_dump_output  )
       elif self._model_type == "rembert":
        from ..models.rembert.convert_rembert_tf_checkpoint_to_pytorch import (
            convert_rembert_tf_checkpoint_to_pytorch,
        )

        convert_rembert_tf_checkpoint_to_pytorch(self._tf_checkpoint ,					self._config ,					self._pytorch_dump_output  )
       else:
        raise ValueError(
            '''--model_type should be selected in the list [bert, gpt, gpt2, t5, transfo_xl, xlnet, xlm, lxmert]'''  )










import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import HeunDiscreteScheduler, PriorTransformer, ShapEPipeline
from diffusers.pipelines.shap_e import ShapERenderer
from diffusers.utils import load_numpy, slow
from diffusers.utils.testing_utils import require_torch_gpu, torch_device

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference






class 		lowercase_					(	lowercase ,  unittest.TestCase   ):






      '''simple docstring'''




      __snake_case       =  ShapEPipeline
      __snake_case       =  ['''prompt''']
      __snake_case       =  ['''prompt''']
      __snake_case       =  [
          '''num_images_per_prompt''',
          '''num_inference_steps''',
          '''generator''',
          '''latents''',
          '''guidance_scale''',
          '''frame_size''',
          '''output_type''',
          '''return_dict''',
      ]
      __snake_case       =  False







      @property
      def       __lowerCAmelCase					(      self      :						Union[str, Any]  )    ->Union[str, Any]:




       """simple docstring"""


       return 32







      @property
      def       __lowerCAmelCase					(      self      :						Optional[Any]  )    ->List[str]:




       """simple docstring"""


       return 32







      @property
      def       __lowerCAmelCase					(      self      :						Any  )    ->Tuple:




       """simple docstring"""


       return self.time_input_dim * 4







      @property
      def       __lowerCAmelCase					(      self      :						Tuple  )    ->Optional[Any]:




       """simple docstring"""


       return 8







      @property
      def       __lowerCAmelCase					(      self      :						Tuple  )    ->str:




       """simple docstring"""


       a		  =      CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''  )
       return tokenizer







      @property
      def       __lowerCAmelCase					(      self      :						Union[str, Any]  )    ->List[Any]:




       """simple docstring"""


       torch.manual_seed(0  )
       a		  =      CLIPTextConfig(
           bos_token_id=0 ,					eos_token_id=2 ,					hidden_size=self.text_embedder_hidden_size ,					projection_dim=self.text_embedder_hidden_size ,					intermediate_size=37 ,					layer_norm_eps=1e-0_5 ,					num_attention_heads=4 ,					num_hidden_layers=5 ,					pad_token_id=1 ,					vocab_size=1_000 ,					)
       return CLIPTextModelWithProjection(__UpperCAmelCase  )







      @property
      def       __lowerCAmelCase					(      self      :						Dict  )    ->Union[str, Any]:




       """simple docstring"""


       torch.manual_seed(0  )

       a		  =      {
           '''num_attention_heads''': 2,
           '''attention_head_dim''': 16,
           '''embedding_dim''': self.time_input_dim,
           '''num_embeddings''': 32,
           '''embedding_proj_dim''': self.text_embedder_hidden_size,
           '''time_embed_dim''': self.time_embed_dim,
           '''num_layers''': 1,
           '''clip_embed_dim''': self.time_input_dim * 2,
           '''additional_embeddings''': 0,
           '''time_embed_act_fn''': '''gelu''',
           '''norm_in_type''': '''layer''',
           '''encoder_hid_proj_type''': None,
           '''added_emb_type''': None,
       }

       a		  =      PriorTransformer(**__UpperCAmelCase  )
       return model







      @property
      def       __lowerCAmelCase					(      self      :						List[Any]  )    ->List[str]:




       """simple docstring"""


       torch.manual_seed(0  )

       a		  =      {
           '''param_shapes''': (
               (self.renderer_dim, 93),
               (self.renderer_dim, 8),
               (self.renderer_dim, 8),
               (self.renderer_dim, 8),
           ),
           '''d_latent''': self.time_input_dim,
           '''d_hidden''': self.renderer_dim,
           '''n_output''': 12,
           '''background''': (
               0.1,
               0.1,
               0.1,
           ),
       }
       a		  =      ShapERenderer(**__UpperCAmelCase  )
       return model







      def       __lowerCAmelCase					(      self      :						List[Any]  )    ->Any:




       """simple docstring"""


       a		  =      self.dummy_prior
       a		  =      self.dummy_text_encoder
       a		  =      self.dummy_tokenizer
       a		  =      self.dummy_renderer

       a		  =      HeunDiscreteScheduler(
           beta_schedule='''exp''' ,					num_train_timesteps=1_024 ,					prediction_type='''sample''' ,					use_karras_sigmas=__UpperCAmelCase ,					clip_sample=__UpperCAmelCase ,					clip_sample_range=1.0 ,					)
       a		  =      {
           '''prior''': prior,
           '''text_encoder''': text_encoder,
           '''tokenizer''': tokenizer,
           '''renderer''': renderer,
           '''scheduler''': scheduler,
       }

       return components







      def       __lowerCAmelCase					(      self      :						Tuple ,					__UpperCAmelCase      :						Optional[Any] ,					__UpperCAmelCase      :						str=0  )    ->Optional[int]:




       """simple docstring"""


       if str(__UpperCAmelCase  ).startswith('''mps'''  ):
        a		  =      torch.manual_seed(__UpperCAmelCase  )
       else:
        a		  =      torch.Generator(device=__UpperCAmelCase  ).manual_seed(__UpperCAmelCase  )
       a		  =      {
           '''prompt''': '''horse''',
           '''generator''': generator,
           '''num_inference_steps''': 1,
           '''frame_size''': 32,
           '''output_type''': '''np''',
       }
       return inputs







      def       __lowerCAmelCase					(      self      :						Dict  )    ->Optional[int]:




       """simple docstring"""


       a		  =      '''cpu'''

       a		  =      self.get_dummy_components()

       a		  =      self.pipeline_class(**__UpperCAmelCase  )
       a		  =      pipe.to(__UpperCAmelCase  )

       pipe.set_progress_bar_config(disable=__UpperCAmelCase  )

       a		  =      pipe(**self.get_dummy_inputs(__UpperCAmelCase  )  )
       a		  =      output.images[0]
       a		  =      image[0, -3:, -3:, -1]

       assert image.shape == (20, 32, 32, 3)

       a		  =      np.array(
           [
               0.00039216,
               0.00039216,
               0.00039216,
               0.00039216,
               0.00039216,
               0.00039216,
               0.00039216,
               0.00039216,
               0.00039216,
           ]  )

       assert np.abs(image_slice.flatten() - expected_slice  ).max() < 1e-2







      def       __lowerCAmelCase					(      self      :						Dict  )    ->Optional[Any]:




       """simple docstring"""


       self._test_inference_batch_consistent(batch_sizes=[1, 2]  )







      def       __lowerCAmelCase					(      self      :						Optional[Any]  )    ->Tuple:




       """simple docstring"""


       a		  =      torch_device == '''cpu'''
       a		  =      True

       self._test_inference_batch_single_identical(
           batch_size=2 ,					test_max_difference=__UpperCAmelCase ,					relax_max_difference=__UpperCAmelCase ,					)







      def       __lowerCAmelCase					(      self      :						str  )    ->Optional[int]:




       """simple docstring"""


       a		  =      self.get_dummy_components()
       a		  =      self.pipeline_class(**__UpperCAmelCase  )
       a		  =      pipe.to(__UpperCAmelCase  )
       pipe.set_progress_bar_config(disable=__UpperCAmelCase  )

       a		  =      1
       a		  =      2

       a		  =      self.get_dummy_inputs(__UpperCAmelCase  )

       for key in inputs.keys():
        if key in self.batch_params:
         a		  =      batch_size * [inputs[key]]

       a		  =      pipe(**__UpperCAmelCase ,					num_images_per_prompt=__UpperCAmelCase  )[0]

       assert images.shape[0] == batch_size * num_images_per_prompt






@slow
@require_torch_gpu
class 		lowercase_					(	unittest.TestCase   ):






      '''simple docstring'''




      def       __lowerCAmelCase					(      self      :						int  )    ->Any:




       """simple docstring"""


       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()







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




       """simple docstring"""


       a		  =      load_numpy(
           '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
           '''/shap_e/test_shap_e_np_out.npy'''  )
       a		  =      ShapEPipeline.from_pretrained('''openai/shap-e'''  )
       a		  =      pipe.to(__UpperCAmelCase  )
       pipe.set_progress_bar_config(disable=__UpperCAmelCase  )

       a		  =      torch.Generator(device=__UpperCAmelCase  ).manual_seed(0  )

       a		  =      pipe(
           '''a shark''' ,					generator=__UpperCAmelCase ,					guidance_scale=15.0 ,					num_inference_steps=64 ,					frame_size=64 ,					output_type='''np''' ,					).images[0]

       assert images.shape == (20, 64, 64, 3)

       assert_mean_pixel_difference(__UpperCAmelCase ,					__UpperCAmelCase  )


