




from typing import Callable, List, Optional, Union

import torch

from ...models import UNetaDModel
from ...schedulers import CMStochasticIterativeScheduler
from ...utils import (
    is_accelerate_available,
    is_accelerate_version,
    logging,
    randn_tensor,
    replace_example_docstring,
)
from ..pipeline_utils import DiffusionPipeline, ImagePipelineOutput


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


__A						:		List[Any]          =						"\n    Examples:\n        ```py\n        >>> import torch\n\n        >>> from diffusers import ConsistencyModelPipeline\n\n        >>> device = \"cuda\"\n        >>> # Load the cd_imagenet64_l2 checkpoint.\n        >>> model_id_or_path = \"openai/diffusers-cd_imagenet64_l2\"\n        >>> pipe = ConsistencyModelPipeline.from_pretrained(model_id_or_path, torch_dtype=torch.float16)\n        >>> pipe.to(device)\n\n        >>> # Onestep Sampling\n        >>> image = pipe(num_inference_steps=1).images[0]\n        >>> image.save(\"cd_imagenet64_l2_onestep_sample.png\")\n\n        >>> # Onestep sampling, class-conditional image generation\n        >>> # ImageNet-64 class label 145 corresponds to king penguins\n        >>> image = pipe(num_inference_steps=1, class_labels=145).images[0]\n        >>> image.save(\"cd_imagenet64_l2_onestep_sample_penguin.png\")\n\n        >>> # Multistep sampling, class-conditional image generation\n        >>> # Timesteps can be explicitly specified; the particular timesteps below are from the original Github repo:\n        >>> # https://github.com/openai/consistency_models/blob/main/scripts/launch.sh#L77\n        >>> image = pipe(num_inference_steps=None, timesteps=[22, 0], class_labels=145).images[0]\n        >>> image.save(\"cd_imagenet64_l2_multistep_sample_penguin.png\")\n        ```\n"

class 		lowercase_       (	lowerCAmelCase__				):




					def __init__(   self:		Tuple,     _lowercase:		UNetaDModel,     _lowercase:		CMStochasticIterativeScheduler):


									'''simple docstring'''


									super().__init__()

									self.register_modules(
									    unet=_lowercase,     scheduler=_lowercase,     )

									__lowerCAmelCase					=  None




					def     _lowercase						(   self:		List[str],     _lowercase:		Tuple=0):


									'''simple docstring'''


									if is_accelerate_available() and is_accelerate_version(""">=""",     """0.14.0"""):
													from accelerate import cpu_offload
									else:
													raise ImportError("""`enable_sequential_cpu_offload` requires `accelerate v0.14.0` or higher""")

									__lowerCAmelCase					=  torch.device(f'''cuda:{gpu_id}''')

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

									for cpu_offloaded_model in [self.unet]:
													cpu_offload(_lowercase,     _lowercase)

									if self.safety_checker is not None:
													cpu_offload(self.safety_checker,     execution_device=_lowercase,     offload_buffers=_lowercase)




					def     _lowercase						(   self:		Optional[Any],     _lowercase:		Optional[int]=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					=  torch.device(f'''cuda:{gpu_id}''')

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

									__lowerCAmelCase					=  None
									for cpu_offloaded_model in [self.unet]:
													__lowerCAmelCase	,				__lowerCAmelCase					=  cpu_offload_with_hook(_lowercase,     _lowercase,     prev_module_hook=_lowercase)

									if self.safety_checker is not None:
													__lowerCAmelCase	,				__lowerCAmelCase					=  cpu_offload_with_hook(self.safety_checker,     _lowercase,     prev_module_hook=_lowercase)

									# We'll offload the last model manually.
									__lowerCAmelCase					=  hook




					@property
					# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device
					def     _lowercase						(   self:		Union[str, Any]):


									'''simple docstring'''


									if not hasattr(self.unet,     """_hf_hook"""):
													return self.device
									for module in self.unet.modules():
													if (
													    hasattr(_lowercase,     """_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




					def     _lowercase						(   self:		Optional[int],     _lowercase:		Dict,     _lowercase:		Dict,     _lowercase:		int,     _lowercase:		List[Any],     _lowercase:		List[str],     _lowercase:		Any,     _lowercase:		Optional[Any],     _lowercase:		List[Any]=None):


									'''simple docstring'''


									__lowerCAmelCase					=  (batch_size, num_channels, height, width)
									if isinstance(_lowercase,     _lowercase) and len(_lowercase) != batch_size:
													raise ValueError(
													    f'''You have passed a list of generators of length {len(_lowercase)}, but requested an effective batch'''
													    f''' size of {batch_size}. Make sure the batch size matches the length of the generators.''')

									if latents is None:
													__lowerCAmelCase					=  randn_tensor(_lowercase,     generator=_lowercase,     device=_lowercase,     dtype=_lowercase)
									else:
													__lowerCAmelCase					=  latents.to(device=_lowercase,     dtype=_lowercase)

									# scale the initial noise by the standard deviation required by the scheduler
									__lowerCAmelCase					=  latents * self.scheduler.init_noise_sigma
									return latents




					def     _lowercase						(   self:		List[Any],     _lowercase:		torch.FloatTensor,     _lowercase:		str = "pil"):


									'''simple docstring'''


									if output_type not in ["pt", "np", "pil"]:
													raise ValueError(
													    f'''output_type={output_type} is not supported. Make sure to choose one of [\'pt\', \'np\', or \'pil\']''')

									# Equivalent to diffusers.VaeImageProcessor.denormalize
									__lowerCAmelCase					=  (sample / 2 + 0.5).clamp(0,     1)
									if output_type == "pt":
													return sample

									# Equivalent to diffusers.VaeImageProcessor.pt_to_numpy
									__lowerCAmelCase					=  sample.cpu().permute(0,     2,     3,     1).numpy()
									if output_type == "np":
													return sample

									# Output_type must be 'pil'
									__lowerCAmelCase					=  self.numpy_to_pil(_lowercase)
									return sample




					def     _lowercase						(   self:		Tuple,     _lowercase:		str,     _lowercase:		Tuple,     _lowercase:		List[str]=None):


									'''simple docstring'''


									if self.unet.config.num_class_embeds is not None:
													if isinstance(_lowercase,     _lowercase):
																	__lowerCAmelCase					=  torch.tensor(_lowercase,     dtype=torch.int)
													elif isinstance(_lowercase,     _lowercase):
																	assert batch_size == 1, "Batch size must be 1 if classes is an int"
																	__lowerCAmelCase					=  torch.tensor([class_labels],     dtype=torch.int)
													elif class_labels is None:
																	# Randomly generate batch_size class labels
																	# TODO: should use generator here? int analogue of randn_tensor is not exposed in ...utils
																	__lowerCAmelCase					=  torch.randint(0,     self.unet.config.num_class_embeds,     size=(batch_size,))
													__lowerCAmelCase					=  class_labels.to(_lowercase)
									else:
													__lowerCAmelCase					=  None
									return class_labels




					def     _lowercase						(   self:		Union[str, Any],     _lowercase:		Optional[int],     _lowercase:		Dict,     _lowercase:		Optional[Any],     _lowercase:		Dict,     _lowercase:		Any,     _lowercase:		Tuple):


									'''simple docstring'''


									if num_inference_steps is None and timesteps is None:
													raise ValueError("""Exactly one of `num_inference_steps` or `timesteps` must be supplied.""")

									if num_inference_steps is not None and timesteps is not None:
													logger.warning(
													    f'''Both `num_inference_steps`: {num_inference_steps} and `timesteps`: {timesteps} are supplied;'''
													    """ `timesteps` will be used over `num_inference_steps`.""")

									if latents is not None:
													__lowerCAmelCase					=  (batch_size, 3, img_size, img_size)
													if latents.shape != expected_shape:
																	raise ValueError(f'''The shape of latents is {latents.shape} but is expected to be {expected_shape}.''')

									if (callback_steps is None) or (
									    callback_steps is not None and (not isinstance(_lowercase,     _lowercase) or callback_steps <= 0)
									):
													raise ValueError(
													    f'''`callback_steps` has to be a positive integer but is {callback_steps} of type'''
													    f''' {type(_lowercase)}.''')







					@torch.no_grad()
					@replace_example_docstring(_lowercase)
					def __call__(   self:		Dict,     _lowercase:		int = 1,     _lowercase:		Optional[Union[torch.Tensor, List[int], int]] = None,     _lowercase:		int = 1,     _lowercase:		List[int] = None,     _lowercase:		Optional[Union[torch.Generator, List[torch.Generator]]] = None,     _lowercase:		Optional[torch.FloatTensor] = None,     _lowercase:		Optional[str] = "pil",     _lowercase:		bool = True,     _lowercase:		Optional[Callable[[int, int, torch.FloatTensor], None]] = None,     _lowercase:		int = 1,     ):


									'''simple docstring'''


									__lowerCAmelCase					=  self.unet.config.sample_size
									__lowerCAmelCase					=  self._execution_device

									# 1. Check inputs
									self.check_inputs(_lowercase,     _lowercase,     _lowercase,     _lowercase,     _lowercase,     _lowercase)

									# 2. Prepare image latents
									# Sample image latents x_0 ~ N(0, sigma_0^2 * I)
									__lowerCAmelCase					=  self.prepare_latents(
									    batch_size=_lowercase,     num_channels=self.unet.config.in_channels,     height=_lowercase,     width=_lowercase,     dtype=self.unet.dtype,     device=_lowercase,     generator=_lowercase,     latents=_lowercase,     )

									# 3. Handle class_labels for class-conditional models
									__lowerCAmelCase					=  self.prepare_class_labels(_lowercase,     _lowercase,     class_labels=_lowercase)

									# 4. Prepare timesteps
									if timesteps is not None:
													self.scheduler.set_timesteps(timesteps=_lowercase,     device=_lowercase)
													__lowerCAmelCase					=  self.scheduler.timesteps
													__lowerCAmelCase					=  len(_lowercase)
									else:
													self.scheduler.set_timesteps(_lowercase)
													__lowerCAmelCase					=  self.scheduler.timesteps

									# 5. Denoising loop
									# Multistep sampling: implements Algorithm 1 in the paper
									with self.progress_bar(total=_lowercase) as progress_bar:
													for i, t in enumerate(_lowercase):
																	__lowerCAmelCase					=  self.scheduler.scale_model_input(_lowercase,     _lowercase)
																	__lowerCAmelCase					=  self.unet(_lowercase,     _lowercase,     class_labels=_lowercase,     return_dict=_lowercase)[0]

																	__lowerCAmelCase					=  self.scheduler.step(_lowercase,     _lowercase,     _lowercase,     generator=_lowercase)[0]

																	# call the callback, if provided
																	progress_bar.update()
																	if callback is not None and i % callback_steps == 0:
																					callback(_lowercase,     _lowercase,     _lowercase)

        # 6. Post-process image sample
									__lowerCAmelCase					=  self.postprocess_image(_lowercase,     output_type=_lowercase)

									# Offload last model to CPU
									if hasattr(self,     """final_offload_hook""") and self.final_offload_hook is not None:
													self.final_offload_hook.offload()

									if not return_dict:
													return (image,)

									return ImagePipelineOutput(images=_lowercase)











from typing import Optional

from ..utils.logging import get_logger
from .audio_classificiation import AudioClassification
from .automatic_speech_recognition import AutomaticSpeechRecognition
from .base import TaskTemplate
from .image_classification import ImageClassification
from .language_modeling import LanguageModeling
from .question_answering import QuestionAnsweringExtractive
from .summarization import Summarization
from .text_classification import TextClassification


_lowerCAmelCase    : Any		= [
    "AutomaticSpeechRecognition",
    "AudioClassification",
    "ImageClassification",
    "LanguageModeling",
    "QuestionAnsweringExtractive",
    "Summarization",
    "TaskTemplate",
    "TextClassification",
]

_lowerCAmelCase    : Dict		= get_logger(__name__)


_lowerCAmelCase    : Optional[Any]		= {
    AutomaticSpeechRecognition.task: AutomaticSpeechRecognition,
    AudioClassification.task: AudioClassification,
    ImageClassification.task: ImageClassification,
    LanguageModeling.task: LanguageModeling,
    QuestionAnsweringExtractive.task: QuestionAnsweringExtractive,
    Summarization.task: Summarization,
    TextClassification.task: TextClassification,
}



def     lowerCAmelCase		(		_lowerCAmelCase				: dict						):




 """simple docstring"""







 UpperCAmelCase__							=    task_template_dict.get("task"						)
 if task_name is None:
  logger.warning(F'''Couldn\'t find template for task \'{task_name}\'. Available templates: {list(_lowerCAmelCase						)}'''						)
  return None
 UpperCAmelCase__							=    NAMEaTEMPLATE.get(_lowerCAmelCase						)
 return template.from_dict(_lowerCAmelCase						)





