



from typing import List, Optional, Union

import torch

from ...models import UNetaDConditionModel, VQModel
from ...pipelines import DiffusionPipeline
from ...pipelines.pipeline_utils import ImagePipelineOutput
from ...schedulers import DDPMScheduler
from ...utils import (
    is_accelerate_available,
    is_accelerate_version,
    logging,
    randn_tensor,
    replace_example_docstring,
)


_snake_case	=						logging.get_logger(__name__)  # pylint: disable=invalid-name

_snake_case	=						"\n    Examples:\n        ```py\n        >>> import torch\n        >>> import numpy as np\n\n        >>> from diffusers import KandinskyV22PriorPipeline, KandinskyV22ControlnetPipeline\n        >>> from transformers import pipeline\n        >>> from diffusers.utils import load_image\n\n\n        >>> def make_hint(image, depth_estimator):\n        ...     image = depth_estimator(image)[\"depth\"]\n        ...     image = np.array(image)\n        ...     image = image[:, :, None]\n        ...     image = np.concatenate([image, image, image], axis=2)\n        ...     detected_map = torch.from_numpy(image).float() / 255.0\n        ...     hint = detected_map.permute(2, 0, 1)\n        ...     return hint\n\n\n        >>> depth_estimator = pipeline(\"depth-estimation\")\n\n        >>> pipe_prior = KandinskyV22PriorPipeline.from_pretrained(\n        ...     \"kandinsky-community/kandinsky-2-2-prior\", torch_dtype=torch.float16\n        ... )\n        >>> pipe_prior = pipe_prior.to(\"cuda\")\n\n        >>> pipe = KandinskyV22ControlnetPipeline.from_pretrained(\n        ...     \"kandinsky-community/kandinsky-2-2-controlnet-depth\", torch_dtype=torch.float16\n        ... )\n        >>> pipe = pipe.to(\"cuda\")\n\n\n        >>> img = load_image(\n        ...     \"https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main\"\n        ...     \"/kandinsky/cat.png\"\n        ... ).resize((768, 768))\n\n        >>> hint = make_hint(img, depth_estimator).unsqueeze(0).half().to(\"cuda\")\n\n        >>> prompt = \"A robot, 4k photo\"\n        >>> negative_prior_prompt = \"lowres, text, error, cropped, worst quality, low quality, jpeg artifacts, ugly, duplicate, morbid, mutilated, out of frame, extra fingers, mutated hands, poorly drawn hands, poorly drawn face, mutation, deformed, blurry, dehydrated, bad anatomy, bad proportions, extra limbs, cloned face, disfigured, gross proportions, malformed limbs, missing arms, missing legs, extra arms, extra legs, fused fingers, too many fingers, long neck, username, watermark, signature\"\n\n        >>> generator = torch.Generator(device=\"cuda\").manual_seed(43)\n\n        >>> image_emb, zero_image_emb = pipe_prior(\n        ...     prompt=prompt, negative_prompt=negative_prior_prompt, generator=generator\n        ... ).to_tuple()\n\n        >>> images = pipe(\n        ...     image_embeds=image_emb,\n        ...     negative_image_embeds=zero_image_emb,\n        ...     hint=hint,\n        ...     num_inference_steps=50,\n        ...     generator=generator,\n        ...     height=768,\n        ...     width=768,\n        ... ).images\n\n        >>> images[0].save(\"robot_cat.png\")\n        ```\n"






def        A       (      _lowerCamelCase       ,				_lowerCamelCase       ,				_lowerCamelCase=8						):





							'''simple docstring'''




							_lowerCAmelCase  :							Tuple				     =					height // scale_factor**2
							if height % scale_factor**2 != 0:
														new_height += 1
							_lowerCAmelCase  :							List[Any]				     =					width // scale_factor**2
							if width % scale_factor**2 != 0:
														new_width += 1
							return new_height * scale_factor, new_width * scale_factor



class 						UpperCAmelCase_					( a):







							def __init__(     self,    __a,    __a,    __a,    ):

														'''simple docstring'''

														super().__init__()

														self.register_modules(
														    unet=__a,    scheduler=__a,    movq=__a,    )
														_lowerCAmelCase  :							List[str]				     =					2 ** (len(self.movq.config.block_out_channels) - 1)







							def      snake_case__   (     self,    __a,    __a,    __a,    __a,    __a,    __a):

														'''simple docstring'''

														if latents is None:
																					_lowerCAmelCase  :							int				     =					randn_tensor(__a,    generator=__a,    device=__a,    dtype=__a)
														else:
																					if latents.shape != shape:
																												raise ValueError(f"Unexpected latents shape, got {latents.shape}, expected {shape}")
																					_lowerCAmelCase  :							List[Any]				     =					latents.to(__a)

														_lowerCAmelCase  :							List[Any]				     =					latents * scheduler.init_noise_sigma
														return latents







							def      snake_case__   (     self,    __a=0):

														'''simple docstring'''

														if is_accelerate_available():
																					from accelerate import cpu_offload
														else:
																					raise ImportError("Please install accelerate via `pip install accelerate`")

														_lowerCAmelCase  :							List[Any]				     =					torch.device(f"cuda:{gpu_id}")

														_lowerCAmelCase  :							str				     =					[
														    self.unet,
														    self.movq,
														]
														for cpu_offloaded_model in models:
																					if cpu_offloaded_model is not None:
																												cpu_offload(__a,    __a)







							def      snake_case__   (     self,    __a=0):

														'''simple docstring'''

														if is_accelerate_available() and is_accelerate_version(">=",    "0.17.0.dev0"):
																					from accelerate import cpu_offload_with_hook
														else:
																					raise ImportError("`enable_model_cpu_offload` requires `accelerate v0.17.0` or higher.")

														_lowerCAmelCase  :							Optional[Any]				     =					torch.device(f"cuda:{gpu_id}")

														if self.device.type != "cpu":
																					self.to("cpu",    silence_dtype_warnings=__a)
																					torch.cuda.empty_cache()  # otherwise we don't see the memory savings (but they probably exist)

														_lowerCAmelCase  :							str				     =					None
														for cpu_offloaded_model in [self.unet, self.movq]:
																					_lowerCAmelCase     ,					_lowerCAmelCase  :							Any				     =					cpu_offload_with_hook(__a,    __a,    prev_module_hook=__a)

														# We'll offload the last model manually.
														_lowerCAmelCase  :							Dict				     =					hook







							@property
							# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device
							def      snake_case__   (     self):

														'''simple docstring'''

														if not hasattr(self.unet,    "_hf_hook"):
																					return self.device
														for module in self.unet.modules():
																					if (
																					    hasattr(__a,    "_hf_hook")
																					    and hasattr(module._hf_hook,    "execution_device")
																					    and module._hf_hook.execution_device is not None
																					):
																												return torch.device(module._hf_hook.execution_device)
														return self.device







							@torch.no_grad()
							@replace_example_docstring(__a)
							def __call__(     self,    __a,    __a,    __a,    __a = 512,    __a = 512,    __a = 100,    __a = 4.0,    __a = 1,    __a = None,    __a = None,    __a = "pil",    __a = True,    ):

														'''simple docstring'''

														_lowerCAmelCase  :							List[str]				     =					self._execution_device

														_lowerCAmelCase  :							int				     =					guidance_scale > 1.0

														if isinstance(__a,    __a):
																					_lowerCAmelCase  :							int				     =					torch.cat(__a,    dim=0)
														if isinstance(__a,    __a):
																					_lowerCAmelCase  :							Any				     =					torch.cat(__a,    dim=0)
														if isinstance(__a,    __a):
																					_lowerCAmelCase  :							Tuple				     =					torch.cat(__a,    dim=0)

														_lowerCAmelCase  :							Any				     =					image_embeds.shape[0] * num_images_per_prompt

														if do_classifier_free_guidance:
																					_lowerCAmelCase  :							Dict				     =					image_embeds.repeat_interleave(__a,    dim=0)
																					_lowerCAmelCase  :							int				     =					negative_image_embeds.repeat_interleave(__a,    dim=0)
																					_lowerCAmelCase  :							Optional[int]				     =					hint.repeat_interleave(__a,    dim=0)

														_lowerCAmelCase  :							Optional[Any]				     =					torch.cat([negative_image_embeds, image_embeds],    dim=0).to(dtype=self.unet.dtype,    device=__a)
														_lowerCAmelCase  :							str				     =					torch.cat([hint, hint],    dim=0).to(dtype=self.unet.dtype,    device=__a)
														self.scheduler.set_timesteps(__a,    device=__a)
														_lowerCAmelCase  :							Optional[Any]				     =					self.scheduler.timesteps

														_lowerCAmelCase  :							Tuple				     =					self.movq.config.latent_channels

														_lowerCAmelCase     ,					_lowerCAmelCase  :							Any				     =					downscale_height_and_width(__a,    __a,    self.movq_scale_factor)

														# create initial latent
														_lowerCAmelCase  :							Dict				     =					self.prepare_latents(
														    (batch_size, num_channels_latents, height, width),    image_embeds.dtype,    __a,    __a,    __a,    self.scheduler,    )

														for i, t in enumerate(self.progress_bar(__a)):
																					# expand the latents if we are doing classifier free guidance
																					_lowerCAmelCase  :							List[str]				     =					torch.cat([latents] * 2) if do_classifier_free_guidance else latents

																					_lowerCAmelCase  :							Optional[int]				     =					{"image_embeds": image_embeds, "hint": hint}
																					_lowerCAmelCase  :							List[Any]				     =					self.unet(
																					    sample=__a,    timestep=__a,    encoder_hidden_states=__a,    added_cond_kwargs=__a,    return_dict=__a,    )[0]

																					if do_classifier_free_guidance:
																												_lowerCAmelCase     ,					_lowerCAmelCase  :							Dict				     =					noise_pred.split(latents.shape[1],    dim=1)
																												_lowerCAmelCase     ,					_lowerCAmelCase  :							Optional[Any]				     =					noise_pred.chunk(2)
																												_lowerCAmelCase     ,					_lowerCAmelCase  :							Union[str, Any]				     =					variance_pred.chunk(2)
																												_lowerCAmelCase  :							Union[str, Any]				     =					noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
																												_lowerCAmelCase  :							Union[str, Any]				     =					torch.cat([noise_pred, variance_pred_text],    dim=1)

																					if not (
																					    hasattr(self.scheduler.config,    "variance_type")
																					    and self.scheduler.config.variance_type in ["learned", "learned_range"]
																					):
																												_lowerCAmelCase     ,					_lowerCAmelCase  :							Any				     =					noise_pred.split(latents.shape[1],    dim=1)

																					# compute the previous noisy sample x_t -> x_t-1
																					_lowerCAmelCase  :							Tuple				     =					self.scheduler.step(
																					    __a,    __a,    __a,    generator=__a,    )[0]
														# post-processing
														_lowerCAmelCase  :							List[str]				     =					self.movq.decode(__a,    force_not_quantize=__a)["sample"]

														if output_type not in ["pt", "np", "pil"]:
																					raise ValueError(f"Only the output types `pt`, `pil` and `np` are supported not output_type={output_type}")

														if output_type in ["np", "pil"]:
																					_lowerCAmelCase  :							Tuple				     =					image * 0.5 + 0.5
																					_lowerCAmelCase  :							int				     =					image.clamp(0,    1)
																					_lowerCAmelCase  :							int				     =					image.cpu().permute(0,    2,    3,    1).float().numpy()

														if output_type == "pil":
																					_lowerCAmelCase  :							Any				     =					self.numpy_to_pil(__a)

														if not return_dict:
																					return (image,)

														return ImagePipelineOutput(images=__a)





import argparse
import os

import torch

from transformers import (
    XLNetConfig,
    XLNetForQuestionAnswering,
    XLNetForSequenceClassification,
    XLNetLMHeadModel,
    load_tf_weights_in_xlnet,
)
from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging


_snake_case	=						{
    "cola": 2,
    "mnli": 3,
    "mrpc": 2,
    "sst-2": 2,
    "sts-b": 1,
    "qqp": 2,
    "qnli": 2,
    "rte": 2,
    "wnli": 2,
}


logging.set_verbosity_info()






def        A       (      _lowerCamelCase       ,				_lowerCamelCase       ,				_lowerCamelCase       ,				_lowerCamelCase=None						):





							'''simple docstring'''




							_lowerCAmelCase  :							Optional[Any]				     =					XLNetConfig.from_json_file(_lowerCamelCase						)

							_lowerCAmelCase  :							Any				     =					finetuning_task.lower() if finetuning_task is not None else ""
							if finetuning_task in GLUE_TASKS_NUM_LABELS:
														print(F"Building PyTorch XLNetForSequenceClassification model from configuration: {config}"						)
														_lowerCAmelCase  :							Any				     =					finetuning_task
														_lowerCAmelCase  :							Any				     =					GLUE_TASKS_NUM_LABELS[finetuning_task]
														_lowerCAmelCase  :							Union[str, Any]				     =					XLNetForSequenceClassification(_lowerCamelCase						)
							elif "squad" in finetuning_task:
														_lowerCAmelCase  :							Union[str, Any]				     =					finetuning_task
														_lowerCAmelCase  :							Any				     =					XLNetForQuestionAnswering(_lowerCamelCase						)
							else:
														_lowerCAmelCase  :							Union[str, Any]				     =					XLNetLMHeadModel(_lowerCamelCase						)

							# Load weights from tf checkpoint
							load_tf_weights_in_xlnet(_lowerCamelCase       ,				_lowerCamelCase       ,				_lowerCamelCase						)

							# Save pytorch-model
							_lowerCAmelCase  :							Optional[int]				     =					os.path.join(_lowerCamelCase       ,				_lowerCamelCase						)
							_lowerCAmelCase  :							Dict				     =					os.path.join(_lowerCamelCase       ,				_lowerCamelCase						)
							print(F"Save PyTorch model to {os.path.abspath(_lowerCamelCase						)}"						)
							torch.save(model.state_dict()       ,				_lowerCamelCase						)
							print(F"Save configuration file to {os.path.abspath(_lowerCamelCase						)}"						)
							with open(_lowerCamelCase       ,				"w"       ,				encoding="utf-8"						) as f:
														f.write(config.to_json_string()						)


if __name__ == "__main__":
						_snake_case	=						argparse.ArgumentParser()
						# Required parameters
						parser.add_argument(
						    "--tf_checkpoint_path", default=None, type=str, required=True, help="Path to the TensorFlow checkpoint path."
						)
						parser.add_argument(
						    "--xlnet_config_file",
						    default=None,
						    type=str,
						    required=True,
						    help=(
						        "The config json file corresponding to the pre-trained XLNet model. \n"
						        "This specifies the model architecture."
						    ),
						)
						parser.add_argument(
						    "--pytorch_dump_folder_path",
						    default=None,
						    type=str,
						    required=True,
						    help="Path to the folder to store the PyTorch model or dataset/vocab.",
						)
						parser.add_argument(
						    "--finetuning_task",
						    default=None,
						    type=str,
						    help="Name of a task on which the XLNet TensorFlow model was fine-tuned",
						)
						_snake_case	=						parser.parse_args()
						print(args)

						convert_xlnet_checkpoint_to_pytorch(
						    args.tf_checkpoint_path, args.xlnet_config_file, args.pytorch_dump_folder_path, args.finetuning_task
						)
