
"""simple docstring"""




from typing import Optional, Tuple, Union

import tensorflow as tf

from ...activations_tf import ACTaFN
from ...modeling_tf_outputs import (
    TFBaseModelOutputWithNoAttention,
    TFBaseModelOutputWithPoolingAndNoAttention,
    TFImageClassifierOutputWithNoAttention,
)
from ...modeling_tf_utils import TFPreTrainedModel, TFSequenceClassificationLoss, keras_serializable, unpack_inputs
from ...tf_utils import shape_list
from ...utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward, logging
from .configuration_resnet import ResNetConfig


snake_case    =		logging.get_logger(__name__)

# General docstring
snake_case    =		'ResNetConfig'

# Base docstring
snake_case    =		'microsoft/resnet-50'
snake_case    =		[1, 2_0_4_8, 7, 7]

# Image classification docstring
snake_case    =		'microsoft/resnet-50'
snake_case    =		'tiger cat'

snake_case    =		[
    'microsoft/resnet-50',
    # See all resnet models at https://huggingface.co/models?filter=resnet
]




class      UpperCamelCase	(       tf.keras.layers.Layer      ):

				"""simple docstring"""



				def __init__(				self		,	lowercase__		,	lowercase__ = 3		,	lowercase__ = 1		,	lowercase__ = "relu"		,	**lowercase__			)    ->    None:
									"""simple docstring"""







									super().__init__(**_A			)
									SCREAMING_SNAKE_CASE				=	kernel_size // 2
									SCREAMING_SNAKE_CASE				=	tf.keras.layers.ConvaD(
									    _A		,	kernel_size=_A		,	strides=_A		,	padding='valid'		,	use_bias=_A		,	name='convolution'			)
									# Use same default momentum and epsilon as PyTorch equivalent
									SCREAMING_SNAKE_CASE				=	tf.keras.layers.BatchNormalization(epsilon=1E-5		,	momentum=0.9		,	name='normalization'			)
									SCREAMING_SNAKE_CASE				=	ACTaFN[activation] if activation is not None else tf.keras.layers.Activation('linear'			)


				def 							A					(				self		,	lowercase__			)    ->    tf.Tensor:
									"""simple docstring"""







									SCREAMING_SNAKE_CASE				=	SCREAMING_SNAKE_CASE				=	(self.pad_value, self.pad_value)
									SCREAMING_SNAKE_CASE				=	tf.pad(_A		,	[(0, 0), height_pad, width_pad, (0, 0)]			)
									SCREAMING_SNAKE_CASE				=	self.conv(_A			)
									return hidden_state




				def 							A					(				self		,	lowercase__		,	lowercase__ = False			)    ->    tf.Tensor:
									"""simple docstring"""







									SCREAMING_SNAKE_CASE				=	self.convolution(_A			)
									SCREAMING_SNAKE_CASE				=	self.normalization(_A		,	training=_A			)
									SCREAMING_SNAKE_CASE				=	self.activation(_A			)
									return hidden_state






class      UpperCamelCase	(       tf.keras.layers.Layer      ):

				"""simple docstring"""



				def __init__(				self		,	lowercase__		,	**lowercase__			)    ->    None:
									"""simple docstring"""







									super().__init__(**_A			)
									SCREAMING_SNAKE_CASE				=	TFResNetConvLayer(
									    config.embedding_size		,	kernel_size=7		,	stride=2		,	activation=config.hidden_act		,	name='embedder'		,	)
									SCREAMING_SNAKE_CASE				=	tf.keras.layers.MaxPoolaD(pool_size=3		,	strides=2		,	padding='valid'		,	name='pooler'			)
									SCREAMING_SNAKE_CASE				=	config.num_channels




				def 							A					(				self		,	lowercase__		,	lowercase__ = False			)    ->    tf.Tensor:
									"""simple docstring"""







									SCREAMING_SNAKE_CASE	,    SCREAMING_SNAKE_CASE	,    SCREAMING_SNAKE_CASE	,    SCREAMING_SNAKE_CASE				=	shape_list(_A			)
									if tf.executing_eagerly() and num_channels != self.num_channels:
														raise ValueError(
														    'Make sure that the channel dimension of the pixel values match with the one set in the configuration.'			)
									SCREAMING_SNAKE_CASE				=	pixel_values
									SCREAMING_SNAKE_CASE				=	self.embedder(_A			)
									SCREAMING_SNAKE_CASE				=	tf.pad(_A		,	[[0, 0], [1, 1], [1, 1], [0, 0]]			)
									SCREAMING_SNAKE_CASE				=	self.pooler(_A			)
									return hidden_state






class      UpperCamelCase	(       tf.keras.layers.Layer      ):

				"""simple docstring"""



				def __init__(				self		,	lowercase__		,	lowercase__ = 2		,	**lowercase__			)    ->    None:
									"""simple docstring"""







									super().__init__(**_A			)
									SCREAMING_SNAKE_CASE				=	tf.keras.layers.ConvaD(
									    _A		,	kernel_size=1		,	strides=_A		,	use_bias=_A		,	name='convolution'			)
									# Use same default momentum and epsilon as PyTorch equivalent
									SCREAMING_SNAKE_CASE				=	tf.keras.layers.BatchNormalization(epsilon=1E-5		,	momentum=0.9		,	name='normalization'			)




				def 							A					(				self		,	lowercase__		,	lowercase__ = False			)    ->    tf.Tensor:
									"""simple docstring"""







									SCREAMING_SNAKE_CASE				=	x
									SCREAMING_SNAKE_CASE				=	self.convolution(_A			)
									SCREAMING_SNAKE_CASE				=	self.normalization(_A		,	training=_A			)
									return hidden_state






class      UpperCamelCase	(       tf.keras.layers.Layer      ):

				"""simple docstring"""



				def __init__(				self		,	lowercase__		,	lowercase__		,	lowercase__ = 1		,	lowercase__ = "relu"		,	**lowercase__			)    ->    None:
									"""simple docstring"""







									super().__init__(**_A			)
									SCREAMING_SNAKE_CASE				=	in_channels != out_channels or stride != 1
									SCREAMING_SNAKE_CASE				=	TFResNetConvLayer(_A		,	stride=_A		,	name='layer.0'			)
									SCREAMING_SNAKE_CASE				=	TFResNetConvLayer(_A		,	activation=_A		,	name='layer.1'			)
									SCREAMING_SNAKE_CASE				=	(
									    TFResNetShortCut(_A		,	stride=_A		,	name='shortcut'			)
									    if should_apply_shortcut
									    else tf.keras.layers.Activation('linear'		,	name='shortcut'			)
									)
									SCREAMING_SNAKE_CASE				=	ACTaFN[activation]




				def 							A					(				self		,	lowercase__		,	lowercase__ = False			)    ->    tf.Tensor:
									"""simple docstring"""







									SCREAMING_SNAKE_CASE				=	hidden_state
									SCREAMING_SNAKE_CASE				=	self.conva(_A		,	training=_A			)
									SCREAMING_SNAKE_CASE				=	self.conva(_A		,	training=_A			)
									SCREAMING_SNAKE_CASE				=	self.shortcut(_A		,	training=_A			)
									hidden_state += residual
									SCREAMING_SNAKE_CASE				=	self.activation(_A			)
									return hidden_state






class      UpperCamelCase	(       tf.keras.layers.Layer      ):

				"""simple docstring"""



				def __init__(				self		,	lowercase__		,	lowercase__		,	lowercase__ = 1		,	lowercase__ = "relu"		,	lowercase__ = 4		,	**lowercase__		,	)    ->    None:
									"""simple docstring"""







									super().__init__(**_A			)
									SCREAMING_SNAKE_CASE				=	in_channels != out_channels or stride != 1
									SCREAMING_SNAKE_CASE				=	out_channels // reduction
									SCREAMING_SNAKE_CASE				=	TFResNetConvLayer(_A		,	kernel_size=1		,	name='layer.0'			)
									SCREAMING_SNAKE_CASE				=	TFResNetConvLayer(_A		,	stride=_A		,	name='layer.1'			)
									SCREAMING_SNAKE_CASE				=	TFResNetConvLayer(_A		,	kernel_size=1		,	activation=_A		,	name='layer.2'			)
									SCREAMING_SNAKE_CASE				=	(
									    TFResNetShortCut(_A		,	stride=_A		,	name='shortcut'			)
									    if should_apply_shortcut
									    else tf.keras.layers.Activation('linear'		,	name='shortcut'			)
									)
									SCREAMING_SNAKE_CASE				=	ACTaFN[activation]




				def 							A					(				self		,	lowercase__		,	lowercase__ = False			)    ->    tf.Tensor:
									"""simple docstring"""







									SCREAMING_SNAKE_CASE				=	hidden_state
									SCREAMING_SNAKE_CASE				=	self.conva(_A		,	training=_A			)
									SCREAMING_SNAKE_CASE				=	self.conva(_A		,	training=_A			)
									SCREAMING_SNAKE_CASE				=	self.conva(_A		,	training=_A			)
									SCREAMING_SNAKE_CASE				=	self.shortcut(_A		,	training=_A			)
									hidden_state += residual
									SCREAMING_SNAKE_CASE				=	self.activation(_A			)
									return hidden_state






class      UpperCamelCase	(       tf.keras.layers.Layer      ):

				"""simple docstring"""



				def __init__(				self		,	lowercase__		,	lowercase__		,	lowercase__		,	lowercase__ = 2		,	lowercase__ = 2		,	**lowercase__			)    ->    None:
									"""simple docstring"""







									super().__init__(**_A			)

									SCREAMING_SNAKE_CASE				=	TFResNetBottleNeckLayer if config.layer_type == 'bottleneck' else TFResNetBasicLayer

									SCREAMING_SNAKE_CASE				=	[layer(_A		,	_A		,	stride=_A		,	activation=config.hidden_act		,	name='layers.0'			)]
									layers += [
									    layer(_A		,	_A		,	activation=config.hidden_act		,	name=f'''layers.{i + 1}'''			)
									    for i in range(depth - 1			)
									]
									SCREAMING_SNAKE_CASE				=	layers




				def 							A					(				self		,	lowercase__		,	lowercase__ = False			)    ->    tf.Tensor:
									"""simple docstring"""







									for layer in self.stage_layers:
														SCREAMING_SNAKE_CASE				=	layer(_A		,	training=_A			)
									return hidden_state






class      UpperCamelCase	(       tf.keras.layers.Layer      ):

				"""simple docstring"""



				def __init__(				self		,	lowercase__		,	**lowercase__			)    ->    None:
									"""simple docstring"""







									super().__init__(**_A			)
									# based on `downsample_in_first_stage` the first layer of the first stage may or may not downsample the input
									SCREAMING_SNAKE_CASE				=	[
									    TFResNetStage(
									        _A		,	config.embedding_size		,	config.hidden_sizes[0]		,	stride=2 if config.downsample_in_first_stage else 1		,	depth=config.depths[0]		,	name='stages.0'		,	)
									]
									for i, (in_channels, out_channels, depth) in enumerate(
									    zip(config.hidden_sizes		,	config.hidden_sizes[1:]		,	config.depths[1:]			)			):
														self.stages.append(TFResNetStage(_A		,	_A		,	_A		,	depth=_A		,	name=f'''stages.{i + 1}'''			)			)




				def 							A					(				self		,	lowercase__		,	lowercase__ = False		,	lowercase__ = True		,	lowercase__ = False		,	)    ->    TFBaseModelOutputWithNoAttention:
									"""simple docstring"""







									SCREAMING_SNAKE_CASE				=	() if output_hidden_states else None

									for stage_module in self.stages:
														if output_hidden_states:
																			SCREAMING_SNAKE_CASE				=	hidden_states + (hidden_state,)

														SCREAMING_SNAKE_CASE				=	stage_module(_A		,	training=_A			)

									if output_hidden_states:
														SCREAMING_SNAKE_CASE				=	hidden_states + (hidden_state,)

									if not return_dict:
														return tuple(v for v in [hidden_state, hidden_states] if v is not None			)

									return TFBaseModelOutputWithNoAttention(last_hidden_state=_A		,	hidden_states=_A			)






class      UpperCamelCase	(       A_      ):

				"""simple docstring"""



				UpperCAmelCase_				:      Union[str, Any]						  =				ResNetConfig
				UpperCAmelCase_				:      Tuple						  =				"resnet"
				UpperCAmelCase_				:      Optional[int]						  =				"pixel_values"


				@property
				def 							A					(				self			)    ->    int:
									"""simple docstring"""







									return {"pixel_values": tf.TensorSpec(shape=(None, self.config.num_channels, 224, 224)		,	dtype=tf.floataa			)}






snake_case    =		R'\n    This model is a TensorFlow\n    [tf.keras.layers.Layer](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Layer) sub-class. Use it as a\n    regular TensorFlow Module and refer to the TensorFlow documentation for all matter related to general usage and\n    behavior.\n\n    Parameters:\n        config ([`ResNetConfig`]): Model configuration class with all the parameters of the model.\n            Initializing with a config file does not load the weights associated with the model, only the\n            configuration. Check out the [`~TFPreTrainedModel.from_pretrained`] method to load the model weights.\n'


snake_case    =		R'\n    Args:\n        pixel_values (`tf.Tensor` of shape `(batch_size, num_channels, height, width)`):\n            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See\n            [`ConvNextImageProcessor.__call__`] for details.\n\n        output_hidden_states (`bool`, *optional*):\n            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for\n            more detail.\n        return_dict (`bool`, *optional*):\n            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.\n'




@keras_serializable
class      UpperCamelCase	(       tf.keras.layers.Layer      ):

				"""simple docstring"""



				UpperCAmelCase_				:      Optional[Any]						  =				ResNetConfig


				def __init__(				self		,	lowercase__		,	**lowercase__			)    ->    None:
									"""simple docstring"""







									super().__init__(**_A			)
									SCREAMING_SNAKE_CASE				=	config
									SCREAMING_SNAKE_CASE				=	TFResNetEmbeddings(_A		,	name='embedder'			)
									SCREAMING_SNAKE_CASE				=	TFResNetEncoder(_A		,	name='encoder'			)
									SCREAMING_SNAKE_CASE				=	tf.keras.layers.GlobalAveragePoolingaD(keepdims=_A			)




				@unpack_inputs
				def 							A					(				self		,	lowercase__		,	lowercase__ = None		,	lowercase__ = None		,	lowercase__ = False		,	)    ->    Union[Tuple[tf.Tensor], TFBaseModelOutputWithPoolingAndNoAttention]:
									"""simple docstring"""







									SCREAMING_SNAKE_CASE				=	(
									    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
									)
									SCREAMING_SNAKE_CASE				=	return_dict if return_dict is not None else self.config.use_return_dict

									# TF 2.0 image layers can't use NCHW format when running on CPU.
									# We transpose to NHWC format and then transpose back after the full forward pass.
									# (batch_size, num_channels, height, width) -> (batch_size, height, width, num_channels)
									SCREAMING_SNAKE_CASE				=	tf.transpose(_A		,	perm=[0, 2, 3, 1]			)
									SCREAMING_SNAKE_CASE				=	self.embedder(_A		,	training=_A			)

									SCREAMING_SNAKE_CASE				=	self.encoder(
									    _A		,	output_hidden_states=_A		,	return_dict=_A		,	training=_A			)

									SCREAMING_SNAKE_CASE				=	encoder_outputs[0]

									SCREAMING_SNAKE_CASE				=	self.pooler(_A			)

									# Transpose all the outputs to the NCHW format
									# (batch_size, height, width, num_channels) -> (batch_size, num_channels, height, width)
									SCREAMING_SNAKE_CASE				=	tf.transpose(_A		,	(0, 3, 1, 2)			)
									SCREAMING_SNAKE_CASE				=	tf.transpose(_A		,	(0, 3, 1, 2)			)
									SCREAMING_SNAKE_CASE				=	()
									for hidden_state in encoder_outputs[1:]:
														SCREAMING_SNAKE_CASE				=	hidden_states + tuple(tf.transpose(_A		,	(0, 3, 1, 2)			) for h in hidden_state			)

									if not return_dict:
														return (last_hidden_state, pooled_output) + hidden_states

									SCREAMING_SNAKE_CASE				=	hidden_states if output_hidden_states else None

									return TFBaseModelOutputWithPoolingAndNoAttention(
									    last_hidden_state=_A		,	pooler_output=_A		,	hidden_states=_A		,	)






@add_start_docstrings(
    "The bare ResNet model outputting raw features without any specific head on top."  ,      A_  ,      )
class      UpperCamelCase	(       A_      ):

				"""simple docstring"""



				def __init__(				self		,	lowercase__		,	**lowercase__			)    ->    None:
									"""simple docstring"""







									super().__init__(_A		,	**_A			)
									SCREAMING_SNAKE_CASE				=	TFResNetMainLayer(config=_A		,	name='resnet'			)




				@add_start_docstrings_to_model_forward(_A			)
				@add_code_sample_docstrings(
				    checkpoint=_CHECKPOINT_FOR_DOC		,	output_type=_A		,	config_class=_CONFIG_FOR_DOC		,	modality='vision'		,	expected_output=_EXPECTED_OUTPUT_SHAPE		,	)
				@unpack_inputs
				def 							A					(				self		,	lowercase__		,	lowercase__ = None		,	lowercase__ = None		,	lowercase__ = False		,	)    ->    Union[Tuple[tf.Tensor], TFBaseModelOutputWithPoolingAndNoAttention]:
									"""simple docstring"""







									SCREAMING_SNAKE_CASE				=	(
									    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
									)
									SCREAMING_SNAKE_CASE				=	return_dict if return_dict is not None else self.config.use_return_dict

									SCREAMING_SNAKE_CASE				=	self.resnet(
									    pixel_values=_A		,	output_hidden_states=_A		,	return_dict=_A		,	training=_A		,	)
									return resnet_outputs






@add_start_docstrings(
    "\n    ResNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for\n    ImageNet.\n    "  ,      A_  ,      )
class      UpperCamelCase	(       A_  ,      A_      ):

				"""simple docstring"""



				def __init__(				self		,	lowercase__		,	**lowercase__			)    ->    None:
									"""simple docstring"""







									super().__init__(_A		,	**_A			)
									SCREAMING_SNAKE_CASE				=	config.num_labels
									SCREAMING_SNAKE_CASE				=	TFResNetMainLayer(_A		,	name='resnet'			)
									# classification head
									SCREAMING_SNAKE_CASE				=	(
									    tf.keras.layers.Dense(config.num_labels		,	name='classifier.1'			)
									    if config.num_labels > 0
									    else tf.keras.layers.Activation('linear'		,	name='classifier.1'			)
									)


				def 							A					(				self		,	lowercase__			)    ->    tf.Tensor:
									"""simple docstring"""







									SCREAMING_SNAKE_CASE				=	tf.keras.layers.Flatten()(_A			)
									SCREAMING_SNAKE_CASE				=	self.classifier_layer(_A			)
									return logits




				@add_start_docstrings_to_model_forward(_A			)
				@add_code_sample_docstrings(
				    checkpoint=_IMAGE_CLASS_CHECKPOINT		,	output_type=_A		,	config_class=_CONFIG_FOR_DOC		,	expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT		,	)
				@unpack_inputs
				def 							A					(				self		,	lowercase__ = None		,	lowercase__ = None		,	lowercase__ = None		,	lowercase__ = None		,	lowercase__ = False		,	)    ->    Union[Tuple[tf.Tensor], TFImageClassifierOutputWithNoAttention]:
									"""simple docstring"""







									SCREAMING_SNAKE_CASE				=	return_dict if return_dict is not None else self.config.use_return_dict

									SCREAMING_SNAKE_CASE				=	self.resnet(
									    _A		,	output_hidden_states=_A		,	return_dict=_A		,	training=_A			)

									SCREAMING_SNAKE_CASE				=	outputs.pooler_output if return_dict else outputs[1]

									SCREAMING_SNAKE_CASE				=	self.classifier(_A			)

									SCREAMING_SNAKE_CASE				=	None if labels is None else self.hf_compute_loss(_A		,	_A			)

									if not return_dict:
														SCREAMING_SNAKE_CASE				=	(logits,) + outputs[2:]
														return (loss,) + output if loss is not None else output

									return TFImageClassifierOutputWithNoAttention(loss=_A		,	logits=_A		,	hidden_states=outputs.hidden_states			)


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  					= logging.get_logger(__name__)  # pylint: disable=invalid-name


_A  					= "\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      lowerCamelCase		(  A_  ):





     def __init__(self      :    Tuple				,    _A      :    UNetaDModel				,    _A      :    CMStochasticIterativeScheduler   )						->						None:
         super().__init__()

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

         snake_case      =					None





     def 		UpperCAmelCase(self      :    Dict				,    _A      :    List[str]=0   )						->						Any:
         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"   )

         snake_case      =					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)

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

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





     def 		UpperCAmelCase(self      :    str				,    _A      :    Optional[Any]=0   )						->						Union[str, Any]:
         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."   )

         snake_case      =					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)

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

         if self.safety_checker is not None:
             snake_case     ,							snake_case      =					cpu_offload_with_hook(self.safety_checker				,    _A				,    prev_module_hook=_A   )

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





     @property
     # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device
     def 		UpperCAmelCase(self      :    Dict   )						->						Any:
         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





     def 		UpperCAmelCase(self      :    Dict				,    _A      :    List[str]				,    _A      :    Tuple				,    _A      :    List[str]				,    _A      :    List[Any]				,    _A      :    Dict				,    _A      :    List[str]				,    _A      :    List[str]				,    _A      :    Optional[Any]=None   )						->						Tuple:
         snake_case      =					(batch_size, num_channels, height, width)
         if isinstance(_A				,    _A   ) and len(_A   ) != batch_size:
             raise ValueError(
                 f'You have passed a list of generators of length {len(_A   )}, 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:
             snake_case      =					randn_tensor(_A				,    generator=_A				,    device=_A				,    dtype=_A   )
         else:
             snake_case      =					latents.to(device=_A				,    dtype=_A   )

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





     def 		UpperCAmelCase(self      :    List[Any]				,    _A      :    torch.FloatTensor				,    _A      :    str = "pil"   )						->						str:
         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
         snake_case      =					(sample / 2 + 0.5).clamp(0				,    1   )
         if output_type == "pt":
             return sample

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

         # Output_type must be 'pil'
         snake_case      =					self.numpy_to_pil(_A   )
         return sample





     def 		UpperCAmelCase(self      :    str				,    _A      :    List[Any]				,    _A      :    Optional[Any]				,    _A      :    List[Any]=None   )						->						List[str]:
         if self.unet.config.num_class_embeds is not None:
             if isinstance(_A				,    _A   ):
                 snake_case      =					torch.tensor(_A				,    dtype=torch.int   )
             elif isinstance(_A				,    _A   ):
                 assert batch_size == 1, "Batch size must be 1 if classes is an int"
                 snake_case      =					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
                 snake_case      =					torch.randint(0				,    self.unet.config.num_class_embeds				,    size=(batch_size,)   )
             snake_case      =					class_labels.to(_A   )
         else:
             snake_case      =					None
         return class_labels





     def 		UpperCAmelCase(self      :    Optional[Any]				,    _A      :    Tuple				,    _A      :    Union[str, Any]				,    _A      :    Dict				,    _A      :    Union[str, Any]				,    _A      :    Any				,    _A      :    str   )						->						Optional[Any]:
         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:
             snake_case      =					(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(_A				,    _A   ) or callback_steps <= 0)
         ):
             raise ValueError(
                 f'`callback_steps` has to be a positive integer but is {callback_steps} of type'
                 f' {type(_A   )}.'   )





     @torch.no_grad()
     @replace_example_docstring(_A   )
     def __call__(self      :    Union[str, Any]				,    _A      :    int = 1				,    _A      :    Optional[Union[torch.Tensor, List[int], int]] = None				,    _A      :    int = 1				,    _A      :    List[int] = None				,    _A      :    Optional[Union[torch.Generator, List[torch.Generator]]] = None				,    _A      :    Optional[torch.FloatTensor] = None				,    _A      :    Optional[str] = "pil"				,    _A      :    bool = True				,    _A      :    Optional[Callable[[int, int, torch.FloatTensor], None]] = None				,    _A      :    int = 1				,    )						->						List[str]:
         snake_case      =					self.unet.config.sample_size
         snake_case      =					self._execution_device

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

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

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

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

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

                 snake_case      =					self.scheduler.step(_A				,    _A				,    _A				,    generator=_A   )[0]

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

        # 6. Post-process image sample
         snake_case      =					self.postprocess_image(_A				,    output_type=_A   )

         # 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=_A   )

