


import argparse
import os
import shutil
from pathlib import Path

import onnx
import torch
from packaging import version
from torch.onnx import export

from diffusers import OnnxRuntimeModel, OnnxStableDiffusionPipeline, StableDiffusionPipeline


__UpperCamelCase       :       Optional[Any]						       =				version.parse(version.parse(torch.__version__).base_version) < version.parse("1.11")

def 			_a  (				SCREAMING_SNAKE_CASE	:				Tuple    , SCREAMING_SNAKE_CASE	:				tuple    , SCREAMING_SNAKE_CASE	:				Path    , SCREAMING_SNAKE_CASE	:				List[Any]    , SCREAMING_SNAKE_CASE	:				Optional[Any]    , SCREAMING_SNAKE_CASE	:				Any    , SCREAMING_SNAKE_CASE	:				Optional[int]    , SCREAMING_SNAKE_CASE	:				Optional[int]=False    , ):







 """simple docstring"""



 output_path.parent.mkdir(parents=SCREAMING_SNAKE_CASE    , exist_ok=SCREAMING_SNAKE_CASE     )
 # PyTorch deprecated the `enable_onnx_checker` and `use_external_data_format` arguments in v1.11,
 # so we check the torch version for backwards compatibility
 if is_torch_less_than_1_11:
  export(
      SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE    , f=output_path.as_posix()    , input_names=SCREAMING_SNAKE_CASE    , output_names=SCREAMING_SNAKE_CASE    , dynamic_axes=SCREAMING_SNAKE_CASE    , do_constant_folding=SCREAMING_SNAKE_CASE    , use_external_data_format=SCREAMING_SNAKE_CASE    , enable_onnx_checker=SCREAMING_SNAKE_CASE    , opset_version=SCREAMING_SNAKE_CASE    , )
 else:
  export(
      SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE    , f=output_path.as_posix()    , input_names=SCREAMING_SNAKE_CASE    , output_names=SCREAMING_SNAKE_CASE    , dynamic_axes=SCREAMING_SNAKE_CASE    , do_constant_folding=SCREAMING_SNAKE_CASE    , opset_version=SCREAMING_SNAKE_CASE    , )

@torch.no_grad()
def 			_a  (				SCREAMING_SNAKE_CASE	:				str    , SCREAMING_SNAKE_CASE	:				str    , SCREAMING_SNAKE_CASE	:				int    , SCREAMING_SNAKE_CASE	:				bool = False     ):







 """simple docstring"""



 UpperCamelCase__					:    Dict          =   torch.floataa if fpaa else torch.floataa
 if fpaa and torch.cuda.is_available():
  UpperCamelCase__					:    str          =   '''cuda'''
 elif fpaa and not torch.cuda.is_available():
  raise ValueError('''`float16` model export is only supported on GPUs with CUDA'''     )
 else:
  UpperCamelCase__					:    int          =   '''cpu'''
 UpperCamelCase__					:    Dict          =   StableDiffusionPipeline.from_pretrained(SCREAMING_SNAKE_CASE    , torch_dtype=SCREAMING_SNAKE_CASE     ).to(SCREAMING_SNAKE_CASE     )
 UpperCamelCase__					:    str          =   Path(SCREAMING_SNAKE_CASE     )

 # TEXT ENCODER
 UpperCamelCase__					:    List[str]          =   pipeline.text_encoder.config.max_position_embeddings
 UpperCamelCase__					:    Any          =   pipeline.text_encoder.config.hidden_size
 UpperCamelCase__					:    Tuple          =   pipeline.tokenizer(
     '''A sample prompt'''    , padding='''max_length'''    , max_length=pipeline.tokenizer.model_max_length    , truncation=SCREAMING_SNAKE_CASE    , return_tensors='''pt'''    , )
 onnx_export(
     pipeline.text_encoder    , model_args=(text_input.input_ids.to(device=SCREAMING_SNAKE_CASE    , dtype=torch.intaa     ))    , output_path=output_path / '''text_encoder''' / '''model.onnx'''    , ordered_input_names=['''input_ids''']    , output_names=['''last_hidden_state''', '''pooler_output''']    , dynamic_axes={
         '''input_ids''': {0: '''batch''', 1: '''sequence'''},
     }    , opset=SCREAMING_SNAKE_CASE    , )
 del pipeline.text_encoder

 # UNET
 UpperCamelCase__					:    Any          =   pipeline.unet.config.in_channels
 UpperCamelCase__					:    Tuple          =   pipeline.unet.config.sample_size
 UpperCamelCase__					:    Union[str, Any]          =   output_path / '''unet''' / '''model.onnx'''
 onnx_export(
     pipeline.unet    , model_args=(
         torch.randn(2    , SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     ).to(device=SCREAMING_SNAKE_CASE    , dtype=SCREAMING_SNAKE_CASE     ),
         torch.randn(2     ).to(device=SCREAMING_SNAKE_CASE    , dtype=SCREAMING_SNAKE_CASE     ),
         torch.randn(2    , SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     ).to(device=SCREAMING_SNAKE_CASE    , dtype=SCREAMING_SNAKE_CASE     ),
         False,
     )    , output_path=SCREAMING_SNAKE_CASE    , ordered_input_names=['''sample''', '''timestep''', '''encoder_hidden_states''', '''return_dict''']    , output_names=['''out_sample''']    , dynamic_axes={
         '''sample''': {0: '''batch''', 1: '''channels''', 2: '''height''', 3: '''width'''},
         '''timestep''': {0: '''batch'''},
         '''encoder_hidden_states''': {0: '''batch''', 1: '''sequence'''},
     }    , opset=SCREAMING_SNAKE_CASE    , use_external_data_format=SCREAMING_SNAKE_CASE    , )
 UpperCamelCase__					:    Any          =   str(unet_path.absolute().as_posix()     )
 UpperCamelCase__					:    Any          =   os.path.dirname(SCREAMING_SNAKE_CASE     )
 UpperCamelCase__					:    Any          =   onnx.load(SCREAMING_SNAKE_CASE     )
 # clean up existing tensor files
 shutil.rmtree(SCREAMING_SNAKE_CASE     )
 os.mkdir(SCREAMING_SNAKE_CASE     )
 # collate external tensor files into one
 onnx.save_model(
     SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE    , save_as_external_data=SCREAMING_SNAKE_CASE    , all_tensors_to_one_file=SCREAMING_SNAKE_CASE    , location='''weights.pb'''    , convert_attribute=SCREAMING_SNAKE_CASE    , )
 del pipeline.unet

 # VAE ENCODER
 UpperCamelCase__					:    Dict          =   pipeline.vae
 UpperCamelCase__					:    Optional[int]          =   vae_encoder.config.in_channels
 UpperCamelCase__					:    Union[str, Any]          =   vae_encoder.config.sample_size
 # need to get the raw tensor output (sample) from the encoder
 UpperCamelCase__					:    List[str]          =   lambda SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     : vae_encoder.encode(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     )[0].sample()
 onnx_export(
     SCREAMING_SNAKE_CASE    , model_args=(
         torch.randn(1    , SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     ).to(device=SCREAMING_SNAKE_CASE    , dtype=SCREAMING_SNAKE_CASE     ),
         False,
     )    , output_path=output_path / '''vae_encoder''' / '''model.onnx'''    , ordered_input_names=['''sample''', '''return_dict''']    , output_names=['''latent_sample''']    , dynamic_axes={
         '''sample''': {0: '''batch''', 1: '''channels''', 2: '''height''', 3: '''width'''},
     }    , opset=SCREAMING_SNAKE_CASE    , )

 # VAE DECODER
 UpperCamelCase__					:    List[Any]          =   pipeline.vae
 UpperCamelCase__					:    Tuple          =   vae_decoder.config.latent_channels
 UpperCamelCase__					:    List[str]          =   vae_decoder.config.out_channels
 # forward only through the decoder part
 UpperCamelCase__					:    Optional[Any]          =   vae_encoder.decode
 onnx_export(
     SCREAMING_SNAKE_CASE    , model_args=(
         torch.randn(1    , SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     ).to(device=SCREAMING_SNAKE_CASE    , dtype=SCREAMING_SNAKE_CASE     ),
         False,
     )    , output_path=output_path / '''vae_decoder''' / '''model.onnx'''    , ordered_input_names=['''latent_sample''', '''return_dict''']    , output_names=['''sample''']    , dynamic_axes={
         '''latent_sample''': {0: '''batch''', 1: '''channels''', 2: '''height''', 3: '''width'''},
     }    , opset=SCREAMING_SNAKE_CASE    , )
 del pipeline.vae

 # SAFETY CHECKER
 if pipeline.safety_checker is not None:
  UpperCamelCase__					:    int          =   pipeline.safety_checker
  UpperCamelCase__					:    str          =   safety_checker.config.vision_config.num_channels
  UpperCamelCase__					:    int          =   safety_checker.config.vision_config.image_size
  UpperCamelCase__					:    Optional[Any]          =   safety_checker.forward_onnx
  onnx_export(
      pipeline.safety_checker    , model_args=(
          torch.randn(
              1    , SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE    , ).to(device=SCREAMING_SNAKE_CASE    , dtype=SCREAMING_SNAKE_CASE     ),
          torch.randn(1    , SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     ).to(device=SCREAMING_SNAKE_CASE    , dtype=SCREAMING_SNAKE_CASE     ),
      )    , output_path=output_path / '''safety_checker''' / '''model.onnx'''    , ordered_input_names=['''clip_input''', '''images''']    , output_names=['''out_images''', '''has_nsfw_concepts''']    , dynamic_axes={
          '''clip_input''': {0: '''batch''', 1: '''channels''', 2: '''height''', 3: '''width'''},
          '''images''': {0: '''batch''', 1: '''height''', 2: '''width''', 3: '''channels'''},
      }    , opset=SCREAMING_SNAKE_CASE    , )
  del pipeline.safety_checker
  UpperCamelCase__					:    List[Any]          =   OnnxRuntimeModel.from_pretrained(output_path / '''safety_checker'''     )
  UpperCamelCase__					:    List[str]          =   pipeline.feature_extractor
 else:
  UpperCamelCase__					:    Union[str, Any]          =   None
  UpperCamelCase__					:    int          =   None

 UpperCamelCase__					:    List[str]          =   OnnxStableDiffusionPipeline(
     vae_encoder=OnnxRuntimeModel.from_pretrained(output_path / '''vae_encoder'''     )    , vae_decoder=OnnxRuntimeModel.from_pretrained(output_path / '''vae_decoder'''     )    , text_encoder=OnnxRuntimeModel.from_pretrained(output_path / '''text_encoder'''     )    , tokenizer=pipeline.tokenizer    , unet=OnnxRuntimeModel.from_pretrained(output_path / '''unet'''     )    , scheduler=pipeline.scheduler    , safety_checker=SCREAMING_SNAKE_CASE    , feature_extractor=SCREAMING_SNAKE_CASE    , requires_safety_checker=safety_checker is not None    , )

 onnx_pipeline.save_pretrained(SCREAMING_SNAKE_CASE     )
 print('''ONNX pipeline saved to'''    , SCREAMING_SNAKE_CASE     )

 del pipeline
 del onnx_pipeline
 UpperCamelCase__					:    Tuple          =   OnnxStableDiffusionPipeline.from_pretrained(SCREAMING_SNAKE_CASE    , provider='''CPUExecutionProvider'''     )
 print('''ONNX pipeline is loadable'''     )


if __name__ == "__main__":
       __UpperCamelCase       :       str						       =				argparse.ArgumentParser()

       parser.add_argument(
           "--model_path",
           type=str,
           required=True,
           help="Path to the `diffusers` checkpoint to convert (either a local directory or on the Hub).",
       )

       parser.add_argument("--output_path", type=str, required=True, help="Path to the output model.")

       parser.add_argument(
           "--opset",
           default=14,
           type=int,
           help="The version of the ONNX operator set to use.",
       )
       parser.add_argument("--fp16", action="store_true", default=False, help="Export the models in `float16` mode")

       __UpperCamelCase       :       List[str]						       =				parser.parse_args()

       convert_models(args.model_path, args.output_path, args.opset, args.fpaa)






from argparse import ArgumentParser, Namespace

from ..utils import logging
from . import BaseTransformersCLICommand

def 			_a  (				SCREAMING_SNAKE_CASE	:				Namespace     ):







 """simple docstring"""



 return ConvertCommand(
     args.model_type    , args.tf_checkpoint    , args.pytorch_dump_output    , args.config    , args.finetuning_task_name     )


__UpperCamelCase       :       List[Any]						       =				"\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       __magic_name__	(     __lowerCAmelCase):


     @staticmethod
     def      UpperCAmelCase__	(      lowerCamelCase__							:     ArgumentParser			)  ->      Optional[int]:





      '''simple docstring'''






      UpperCamelCase__					:    int          =   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=lowerCamelCase__							,	required=lowerCamelCase__							,	help='''Model\'s type.'''			)
      train_parser.add_argument(
          '''--tf_checkpoint'''							,	type=lowerCamelCase__							,	required=lowerCamelCase__							,	help='''TensorFlow checkpoint path or folder.'''			)
      train_parser.add_argument(
          '''--pytorch_dump_output'''							,	type=lowerCamelCase__							,	required=lowerCamelCase__							,	help='''Path to the PyTorch saved model output.'''			)
      train_parser.add_argument('''--config'''							,	type=lowerCamelCase__							,	default=''''''							,	help='''Configuration file path or folder.'''			)
      train_parser.add_argument(
          '''--finetuning_task_name'''							,	type=lowerCamelCase__							,	default=lowerCamelCase__							,	help='''Optional fine-tuning task name if the TF model was a finetuned model.'''							,	)
      train_parser.set_defaults(func=lowerCamelCase__			)


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





      '''simple docstring'''






      UpperCamelCase__					:    List[Any]          =   logging.get_logger('''transformers-cli/converting'''			)

      self._logger.info(F"Loading model {model_type}"			)
      UpperCamelCase__					:    List[str]          =   model_type
      UpperCamelCase__					:    Optional[int]          =   tf_checkpoint
      UpperCamelCase__					:    List[Any]          =   pytorch_dump_output
      UpperCamelCase__					:    List[Any]          =   config
      UpperCamelCase__					:    Any          =   finetuning_task_name


     def      UpperCAmelCase__	(      self							:     Optional[Any]			)  ->      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(lowerCamelCase__			)

       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(lowerCamelCase__			)

       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(lowerCamelCase__			)

       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(lowerCamelCase__			)

       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(lowerCamelCase__			)

       if "ckpt" in self._tf_checkpoint.lower():
        UpperCamelCase__					:    str          =   self._tf_checkpoint
        UpperCamelCase__					:    List[Any]          =   ''''''
       else:
        UpperCamelCase__					:    Any          =   self._tf_checkpoint
        UpperCamelCase__					:    List[Any]          =   ''''''
       convert_transfo_xl_checkpoint_to_pytorch(
           lowerCamelCase__							,	self._config							,	self._pytorch_dump_output							,	lowerCamelCase__			)
      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(lowerCamelCase__			)

       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(lowerCamelCase__			)

       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]'''			)


