





"""simple docstring"""
from argparse import ArgumentParser, Namespace

from ..utils import logging
from . import BaseTransformersCLICommand






def 					A__				(			UpperCamelCase       ):
							return ConvertCommand(
							    args.model_type					,  args.tf_checkpoint					,  args.pytorch_dump_output					,  args.config					,  args.finetuning_task_name       )


_snake_case     :		str       						= '\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 					_UpperCAmelCase   (	lowercase_ ):


					@staticmethod
					def 	lowerCamelCase       (					__UpperCamelCase			:ArgumentParser		):
												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[Any]     ,       __UpperCamelCase			:str     ,       __UpperCamelCase			:str     ,       __UpperCamelCase			:str     ,       __UpperCamelCase			:str     ,       __UpperCamelCase			:str     ,       *__UpperCamelCase			:List[Any]     ,       ):
												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			:Tuple		):
												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]"		)









"""simple docstring"""
import random
import unittest

import numpy as np

from diffusers import (
    DPMSolverMultistepScheduler,
    EulerAncestralDiscreteScheduler,
    EulerDiscreteScheduler,
    LMSDiscreteScheduler,
    OnnxStableDiffusionImgaImgPipeline,
    PNDMScheduler,
)
from diffusers.utils import floats_tensor
from diffusers.utils.testing_utils import (
    is_onnx_available,
    load_image,
    nightly,
    require_onnxruntime,
    require_torch_gpu,
)

from ..test_pipelines_onnx_common import OnnxPipelineTesterMixin


if is_onnx_available():
		import onnxruntime as ort






class 					_UpperCAmelCase   (	lowercase_     ,							unittest.TestCase ):
					UpperCamelCase      =							'''hf-internal-testing/tiny-random-OnnxStableDiffusionPipeline'''


					def 	lowerCamelCase       (					self			:Optional[int]     ,       __UpperCamelCase			:Union[str, Any]=0		):
												A		=  floats_tensor((1, 3, 1_28, 1_28)     ,       rng=random.Random(__UpperCamelCase		)		)
												A		=  np.random.RandomState(__UpperCamelCase		)
												A		=  {
												    "prompt": "A painting of a squirrel eating a burger",
												    "image": image,
												    "generator": generator,
												    "num_inference_steps": 3,
												    "strength": 0.75,
												    "guidance_scale": 7.5,
												    "output_type": "numpy",
												}
												return inputs


					def 	lowerCamelCase       (					self			:Any		):
												A		=  OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint     ,       provider="CPUExecutionProvider"		)
												pipe.set_progress_bar_config(disable=__UpperCamelCase		)

												A		=  self.get_dummy_inputs()
												A		=  pipe(**__UpperCamelCase		).images
												A		=  image[0, -3:, -3:, -1].flatten()

												assert image.shape == (1, 1_28, 1_28, 3)
												A		=  np.array([0.69_643, 0.58_484, 0.50_314, 0.58_760, 0.55_368, 0.59_643, 0.51_529, 0.41_217, 0.49_087]		)
												assert np.abs(image_slice - expected_slice		).max() < 1e-1


					def 	lowerCamelCase       (					self			:Dict		):
												A		=  OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint     ,       provider="CPUExecutionProvider"		)
												A		=  PNDMScheduler.from_config(pipe.scheduler.config     ,       skip_prk_steps=__UpperCamelCase		)
												pipe.set_progress_bar_config(disable=__UpperCamelCase		)

												A		=  self.get_dummy_inputs()
												A		=  pipe(**__UpperCamelCase		).images
												A		=  image[0, -3:, -3:, -1]

												assert image.shape == (1, 1_28, 1_28, 3)
												A		=  np.array([0.61_737, 0.54_642, 0.53_183, 0.54_465, 0.52_742, 0.60_525, 0.49_969, 0.40_655, 0.48_154]		)

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


					def 	lowerCamelCase       (					self			:Optional[Any]		):
												A		=  OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint     ,       provider="CPUExecutionProvider"		)
												A		=  LMSDiscreteScheduler.from_config(pipe.scheduler.config		)
												pipe.set_progress_bar_config(disable=__UpperCamelCase		)

												# warmup pass to apply optimizations
												A		=  pipe(**self.get_dummy_inputs()		)

												A		=  self.get_dummy_inputs()
												A		=  pipe(**__UpperCamelCase		).images
												A		=  image[0, -3:, -3:, -1]

												assert image.shape == (1, 1_28, 1_28, 3)
												A		=  np.array([0.52_761, 0.59_977, 0.49_033, 0.49_619, 0.54_282, 0.50_311, 0.47_600, 0.40_918, 0.45_203]		)

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


					def 	lowerCamelCase       (					self			:Dict		):
												A		=  OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint     ,       provider="CPUExecutionProvider"		)
												A		=  EulerDiscreteScheduler.from_config(pipe.scheduler.config		)
												pipe.set_progress_bar_config(disable=__UpperCamelCase		)

												A		=  self.get_dummy_inputs()
												A		=  pipe(**__UpperCamelCase		).images
												A		=  image[0, -3:, -3:, -1]

												assert image.shape == (1, 1_28, 1_28, 3)
												A		=  np.array([0.52_911, 0.60_004, 0.49_229, 0.49_805, 0.54_502, 0.50_680, 0.47_777, 0.41_028, 0.45_304]		)

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


					def 	lowerCamelCase       (					self			:Optional[Any]		):
												A		=  OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint     ,       provider="CPUExecutionProvider"		)
												A		=  EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config		)
												pipe.set_progress_bar_config(disable=__UpperCamelCase		)

												A		=  self.get_dummy_inputs()
												A		=  pipe(**__UpperCamelCase		).images
												A		=  image[0, -3:, -3:, -1]

												assert image.shape == (1, 1_28, 1_28, 3)
												A		=  np.array([0.52_911, 0.60_004, 0.49_229, 0.49_805, 0.54_502, 0.50_680, 0.47_777, 0.41_028, 0.45_304]		)

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


					def 	lowerCamelCase       (					self			:Union[str, Any]		):
												A		=  OnnxStableDiffusionImgaImgPipeline.from_pretrained(self.hub_checkpoint     ,       provider="CPUExecutionProvider"		)
												A		=  DPMSolverMultistepScheduler.from_config(pipe.scheduler.config		)
												pipe.set_progress_bar_config(disable=__UpperCamelCase		)

												A		=  self.get_dummy_inputs()
												A		=  pipe(**__UpperCamelCase		).images
												A		=  image[0, -3:, -3:, -1]

												assert image.shape == (1, 1_28, 1_28, 3)
												A		=  np.array([0.65_331, 0.58_277, 0.48_204, 0.56_059, 0.53_665, 0.56_235, 0.50_969, 0.40_009, 0.46_552]		)

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







@nightly
@require_onnxruntime
@require_torch_gpu
class 					_UpperCAmelCase   (	unittest.TestCase ):


					@property
					def 	lowerCamelCase       (					self			:Optional[Any]		):
												return (
												    "CUDAExecutionProvider",
												    {
												        "gpu_mem_limit": "15000000000",  # 15GB
												        "arena_extend_strategy": "kSameAsRequested",
												    },
												)


					@property
					def 	lowerCamelCase       (					self			:Optional[int]		):
												A		=  ort.SessionOptions()
												A		=  False
												return options


					def 	lowerCamelCase       (					self			:Dict		):
												A		=  load_image(
												    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
												    "/img2img/sketch-mountains-input.jpg"		)
												A		=  init_image.resize((7_68, 5_12)		)
												# using the PNDM scheduler by default
												A		=  OnnxStableDiffusionImgaImgPipeline.from_pretrained(
												    "CompVis/stable-diffusion-v1-4"     ,       revision="onnx"     ,       safety_checker=__UpperCamelCase     ,       feature_extractor=__UpperCamelCase     ,       provider=self.gpu_provider     ,       sess_options=self.gpu_options     ,       )
												pipe.set_progress_bar_config(disable=__UpperCamelCase		)

												A		=  "A fantasy landscape, trending on artstation"

												A		=  np.random.RandomState(0		)
												A		=  pipe(
												    prompt=__UpperCamelCase     ,       image=__UpperCamelCase     ,       strength=0.75     ,       guidance_scale=7.5     ,       num_inference_steps=10     ,       generator=__UpperCamelCase     ,       output_type="np"     ,       )
												A		=  output.images
												A		=  images[0, 2_55:2_58, 3_83:3_86, -1]

												assert images.shape == (1, 5_12, 7_68, 3)
												A		=  np.array([0.4_909, 0.5_059, 0.5_372, 0.4_623, 0.4_876, 0.5_049, 0.4_820, 0.4_956, 0.5_019]		)
												# TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues

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


					def 	lowerCamelCase       (					self			:Any		):
												A		=  load_image(
												    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
												    "/img2img/sketch-mountains-input.jpg"		)
												A		=  init_image.resize((7_68, 5_12)		)
												A		=  LMSDiscreteScheduler.from_pretrained(
												    "runwayml/stable-diffusion-v1-5"     ,       subfolder="scheduler"     ,       revision="onnx"		)
												A		=  OnnxStableDiffusionImgaImgPipeline.from_pretrained(
												    "runwayml/stable-diffusion-v1-5"     ,       revision="onnx"     ,       scheduler=__UpperCamelCase     ,       safety_checker=__UpperCamelCase     ,       feature_extractor=__UpperCamelCase     ,       provider=self.gpu_provider     ,       sess_options=self.gpu_options     ,       )
												pipe.set_progress_bar_config(disable=__UpperCamelCase		)

												A		=  "A fantasy landscape, trending on artstation"

												A		=  np.random.RandomState(0		)
												A		=  pipe(
												    prompt=__UpperCamelCase     ,       image=__UpperCamelCase     ,       strength=0.75     ,       guidance_scale=7.5     ,       num_inference_steps=20     ,       generator=__UpperCamelCase     ,       output_type="np"     ,       )
												A		=  output.images
												A		=  images[0, 2_55:2_58, 3_83:3_86, -1]

												assert images.shape == (1, 5_12, 7_68, 3)
												A		=  np.array([0.8_043, 0.926, 0.9_581, 0.8_119, 0.8_954, 0.913, 0.7_209, 0.7_463, 0.7_431]		)
												# TODO: lower the tolerance after finding the cause of onnxruntime reproducibility issues

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


