





import os
import sys
import tempfile

import torch

from .state import AcceleratorState
from .utils import PrecisionType, PrepareForLaunch, is_mps_available, patch_environment





def     _UpperCamelCase     (a__   :str   ,			a__   :List[str]=()   ,			a__   :Union[str, Any]=None   ,			a__   :str="no"   ,			a__   :Any="29500"       ):






							"""simple docstring"""





							UpperCamelCase__				     =			False
							UpperCamelCase__				     =			False
							if any(key.startswith("""KAGGLE"""       ) for key in os.environ.keys()       ):
														UpperCamelCase__				     =			True
							elif "IPython" in sys.modules:
														UpperCamelCase__				     =			"""google.colab""" in str(sys.modules["""IPython"""].get_ipython()       )

							try:
														UpperCamelCase__				     =			PrecisionType(mixed_precision.lower()       )
							except ValueError:
														raise ValueError(
														    f"""Unknown mixed_precision mode: {args.mixed_precision.lower()}. Choose between {PrecisionType.list()}."""       )

							if (in_colab or in_kaggle) and (os.environ.get("""TPU_NAME"""   ,			a__       ) is not None):
														# TPU launch
														import torch_xla.distributed.xla_multiprocessing as xmp

														if len(AcceleratorState._shared_state       ) > 0:
																					raise ValueError(
																					    """To train on TPU in Colab or Kaggle Kernel, the `Accelerator` should only be initialized inside """
																					    """your training function. Restart your notebook and make sure no cells initializes an """
																					    """`Accelerator`."""       )
														if num_processes is None:
																					UpperCamelCase__				     =			8

														UpperCamelCase__				     =			PrepareForLaunch(a__   ,			distributed_type="""TPU"""       )
														print(f"""Launching a training on {num_processes} TPU cores."""       )
														xmp.spawn(a__   ,			args=a__   ,			nprocs=a__   ,			start_method="""fork"""       )
							elif in_colab:
														# No need for a distributed launch otherwise as it's either CPU or one GPU.
														if torch.cuda.is_available():
																					print("""Launching training on one GPU."""       )
														else:
																					print("""Launching training on one CPU."""       )
														function(*a__       )
							else:
														if num_processes is None:
																					raise ValueError(
																					    """You have to specify the number of GPUs you would like to use, add `num_processes=...` to your call."""       )

														if num_processes > 1:
																					# Multi-GPU launch
																					from torch.multiprocessing import start_processes
																					from torch.multiprocessing.spawn import ProcessRaisedException

																					if len(AcceleratorState._shared_state       ) > 0:
																												raise ValueError(
																												    """To launch a multi-GPU training from your notebook, the `Accelerator` should only be initialized """
																												    """inside your training function. Restart your notebook and make sure no cells initializes an """
																												    """`Accelerator`."""       )

																					if torch.cuda.is_initialized():
																												raise ValueError(
																												    """To launch a multi-GPU training from your notebook, you need to avoid running any instruction """
																												    """using `torch.cuda` in any cell. Restart your notebook and make sure no cells use any CUDA """
																												    """function."""       )

																					# torch.distributed will expect a few environment variable to be here. We set the ones common to each
																					# process here (the other ones will be set be the launcher).
																					with patch_environment(
																					    world_size=a__   ,			master_addr="""127.0.01"""   ,			master_port=a__   ,			mixed_precision=a__       ):
																												UpperCamelCase__				     =			PrepareForLaunch(a__   ,			distributed_type="""MULTI_GPU"""       )
																												print(f"""Launching training on {num_processes} GPUs."""       )
																												try:
																																			start_processes(a__   ,			args=a__   ,			nprocs=a__   ,			start_method="""fork"""       )
																												except ProcessRaisedException as e:
																																			if "Cannot re-initialize CUDA in forked subprocess" in e.args[0]:
																																										raise RuntimeError(
																																										    """CUDA has been initialized before the `notebook_launcher` could create a forked subprocess. """
																																										    """This likely stems from an outside import causing issues once the `notebook_launcher()` is called. """
																																										    """Please review your imports and test them when running the `notebook_launcher()` to identify """
																																										    """which one is problematic."""       ) from e

														else:
																					# No need for a distributed launch otherwise as it's either CPU, GPU or MPS.
																					if is_mps_available():
																												UpperCamelCase__				     =			"""1"""
																												print("""Launching training on MPS."""       )
																					elif torch.cuda.is_available():
																												print("""Launching training on one GPU."""       )
																					else:
																												print("""Launching training on CPU."""       )
																					function(*a__       )





def     _UpperCamelCase     (a__   :Optional[int]   ,			a__   :int=()   ,			a__   :List[Any]=2       ):






							"""simple docstring"""





							from torch.multiprocessing import start_processes

							with tempfile.NamedTemporaryFile() as tmp_file:
														# torch.distributed will expect a few environment variable to be here. We set the ones common to each
														# process here (the other ones will be set be the launcher).
														with patch_environment(
														    world_size=a__   ,			master_addr="""127.0.01"""   ,			master_port="""29500"""   ,			accelerate_mixed_precision="""no"""   ,			accelerate_debug_rdv_file=tmp_file.name   ,			accelerate_use_cpu="""yes"""   ,			):
																					UpperCamelCase__				     =			PrepareForLaunch(a__   ,			debug=a__       )
																					start_processes(a__   ,			args=a__   ,			nprocs=a__   ,			start_method="""fork"""       )











import argparse

from transformers import CLIPImageProcessor, CLIPVisionModelWithProjection

from diffusers import UnCLIPImageVariationPipeline, UnCLIPPipeline


if __name__ == "__main__":
					UpperCamelCase__											= argparse.ArgumentParser()

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

					parser.add_argument(
					    "--txt2img_unclip",
					    default="kakaobrain/karlo-v1-alpha",
					    type=str,
					    required=False,
					    help="The pretrained txt2img unclip.",
					)

					UpperCamelCase__											= parser.parse_args()

					UpperCamelCase__											= UnCLIPPipeline.from_pretrained(args.txtaimg_unclip)

					UpperCamelCase__											= CLIPImageProcessor()
					UpperCamelCase__											= CLIPVisionModelWithProjection.from_pretrained("openai/clip-vit-large-patch14")

					UpperCamelCase__											= UnCLIPImageVariationPipeline(
					    decoder=txtaimg.decoder,
					    text_encoder=txtaimg.text_encoder,
					    tokenizer=txtaimg.tokenizer,
					    text_proj=txtaimg.text_proj,
					    feature_extractor=feature_extractor,
					    image_encoder=image_encoder,
					    super_res_first=txtaimg.super_res_first,
					    super_res_last=txtaimg.super_res_last,
					    decoder_scheduler=txtaimg.decoder_scheduler,
					    super_res_scheduler=txtaimg.super_res_scheduler,
					)

					imgaimg.save_pretrained(args.dump_path)




