





from typing import Optional, Tuple, Union

import tensorflow as tf

from ...activations_tf import ACTaFN
from ...file_utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward
from ...modeling_tf_outputs import (
    TFBaseModelOutputWithNoAttention,
    TFBaseModelOutputWithPoolingAndNoAttention,
    TFSequenceClassifierOutput,
)
from ...modeling_tf_utils import TFPreTrainedModel, TFSequenceClassificationLoss, keras_serializable, unpack_inputs
from ...tf_utils import shape_list
from ...utils import logging
from .configuration_regnet import RegNetConfig


snake_case								=							logging.get_logger(__name__)

# General docstring
snake_case								=							"RegNetConfig"

# Base docstring
snake_case								=							"facebook/regnet-y-040"
snake_case								=							[1, 1_0_8_8, 7, 7]

# Image classification docstring
snake_case								=							"facebook/regnet-y-040"
snake_case								=							"tabby, tabby cat"

snake_case								=							[
    "facebook/regnet-y-040",
    # See all regnet models at https://huggingface.co/models?filter=regnet
]





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







       """simple docstring"""





       def __init__(     self						:						int    ,__A						:						Optional[int]    ,__A						:						Optional[Any] = 3    ,__A						:						List[Any] = 1    ,__A						:						List[Any] = 1    ,__A						:						Dict = "relu"    ,**__A						:						Optional[int]    ,)    ->       Union[str, Any]:
         super().__init__(**a__	)
         # The padding and conv has been verified in
         # https://colab.research.google.com/gist/sayakpaul/854bc10eeaf21c9ee2119e0b9f3841a7/scratchpad.ipynb
         _lowercase						    =			tf.keras.layers.ZeroPaddingaD(padding=kernel_size // 2	)
         _lowercase						    =			tf.keras.layers.ConvaD(
             filters=a__    ,kernel_size=a__    ,strides=a__    ,padding='VALID'    ,groups=a__    ,use_bias=a__    ,name='convolution'    ,)
         _lowercase						    =			tf.keras.layers.BatchNormalization(epsilon=1e-5    ,momentum=0.9    ,name='normalization'	)
         _lowercase						    =			ACTaFN[activation] if activation is not None else tf.identity







       def  __UpperCAmelCase			(     self						:						Union[str, Any]    ,__A						:						List[Any]	)    ->       Union[str, Any]:
         _lowercase						    =			self.convolution(self.padding(a__	)	)
         _lowercase						    =			self.normalization(a__	)
         _lowercase						    =			self.activation(a__	)
         return hidden_state





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







       """simple docstring"""





       def __init__(     self						:						str    ,__A						:						Optional[int]    ,**__A						:						Tuple	)    ->       Dict:
         super().__init__(**a__	)
         _lowercase						    =			config.num_channels
         _lowercase						    =			TFRegNetConvLayer(
             out_channels=config.embedding_size    ,kernel_size=3    ,stride=2    ,activation=config.hidden_act    ,name='embedder'    ,)







       def  __UpperCAmelCase			(     self						:						str    ,__A						:						int	)    ->       List[Any]:
         _lowercase						    =			shape_list(a__	)[1]
         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.'	)

         # When running on CPU, `tf.keras.layers.Conv2D` doesn't support `NCHW` format.
         # So change the input format from `NCHW` to `NHWC`.
         # shape = (batch_size, in_height, in_width, in_channels=num_channels)
         _lowercase						    =			tf.transpose(a__    ,perm=(0, 2, 3, 1)	)
         _lowercase						    =			self.embedder(a__	)
         return hidden_state





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







       """simple docstring"""





       def __init__(     self						:						Union[str, Any]    ,__A						:						Optional[int]    ,__A						:						int = 2    ,**__A						:						List[Any]	)    ->       Optional[Any]:
         super().__init__(**a__	)
         _lowercase						    =			tf.keras.layers.ConvaD(
             filters=a__    ,kernel_size=1    ,strides=a__    ,use_bias=a__    ,name='convolution'	)
         _lowercase						    =			tf.keras.layers.BatchNormalization(epsilon=1e-5    ,momentum=0.9    ,name='normalization'	)







       def  __UpperCAmelCase			(     self						:						str    ,__A						:						Optional[Any]    ,__A						:						Dict = False	)    ->       tf.Tensor:
         return self.normalization(self.convolution(a__	)    ,training=a__	)





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







       """simple docstring"""





       def __init__(     self						:						Union[str, Any]    ,__A						:						Optional[Any]    ,__A						:						List[Any]    ,**__A						:						Tuple	)    ->       Tuple:
         super().__init__(**a__	)
         _lowercase						    =			tf.keras.layers.GlobalAveragePoolingaD(keepdims=a__    ,name='pooler'	)
         _lowercase						    =			[
             tf.keras.layers.ConvaD(filters=a__    ,kernel_size=1    ,activation='relu'    ,name='attention.0'	),
             tf.keras.layers.ConvaD(filters=a__    ,kernel_size=1    ,activation='sigmoid'    ,name='attention.2'	),
         ]







       def  __UpperCAmelCase			(     self						:						Tuple    ,__A						:						str	)    ->       Optional[Any]:
         # [batch_size, h, w, num_channels] -> [batch_size, 1, 1, num_channels]
         _lowercase						    =			self.pooler(a__	)
         for layer_module in self.attention:
           _lowercase						    =			layer_module(a__	)
         _lowercase						    =			hidden_state * pooled
         return hidden_state





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







       """simple docstring"""





       def __init__(     self						:						Tuple    ,__A						:						Optional[int]    ,__A						:						int    ,__A						:						Union[str, Any]    ,__A						:						Union[str, Any] = 1    ,**__A						:						Dict	)    ->       List[Any]:
         super().__init__(**a__	)
         _lowercase						    =			in_channels != out_channels or stride != 1
         _lowercase						    =			max(1    ,out_channels // config.groups_width	)
         _lowercase						    =			(
             TFRegNetShortCut(a__    ,stride=a__    ,name='shortcut'	)
             if should_apply_shortcut
             else tf.keras.layers.Activation('linear'    ,name='shortcut'	)
         )
         # `self.layers` instead of `self.layer` because that is a reserved argument.
         _lowercase						    =			[
             TFRegNetConvLayer(a__    ,kernel_size=1    ,activation=config.hidden_act    ,name='layer.0'	),
             TFRegNetConvLayer(
                 a__    ,stride=a__    ,groups=a__    ,activation=config.hidden_act    ,name='layer.1'	),
             TFRegNetConvLayer(a__    ,kernel_size=1    ,activation=a__    ,name='layer.2'	),
         ]
         _lowercase						    =			ACTaFN[config.hidden_act]







       def  __UpperCAmelCase			(     self						:						int    ,__A						:						Tuple	)    ->       Dict:
         _lowercase						    =			hidden_state
         for layer_module in self.layers:
           _lowercase						    =			layer_module(a__	)
         _lowercase						    =			self.shortcut(a__	)
         hidden_state += residual
         _lowercase						    =			self.activation(a__	)
         return hidden_state





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







       """simple docstring"""





       def __init__(     self						:						int    ,__A						:						Optional[Any]    ,__A						:						Union[str, Any]    ,__A						:						List[Any]    ,__A						:						Dict = 1    ,**__A						:						Dict	)    ->       Tuple:
         super().__init__(**a__	)
         _lowercase						    =			in_channels != out_channels or stride != 1
         _lowercase						    =			max(1    ,out_channels // config.groups_width	)
         _lowercase						    =			(
             TFRegNetShortCut(a__    ,stride=a__    ,name='shortcut'	)
             if should_apply_shortcut
             else tf.keras.layers.Activation('linear'    ,name='shortcut'	)
         )
         _lowercase						    =			[
             TFRegNetConvLayer(a__    ,kernel_size=1    ,activation=config.hidden_act    ,name='layer.0'	),
             TFRegNetConvLayer(
                 a__    ,stride=a__    ,groups=a__    ,activation=config.hidden_act    ,name='layer.1'	),
             TFRegNetSELayer(a__    ,reduced_channels=int(round(in_channels / 4	)	)    ,name='layer.2'	),
             TFRegNetConvLayer(a__    ,kernel_size=1    ,activation=a__    ,name='layer.3'	),
         ]
         _lowercase						    =			ACTaFN[config.hidden_act]







       def  __UpperCAmelCase			(     self						:						List[str]    ,__A						:						str	)    ->       List[str]:
         _lowercase						    =			hidden_state
         for layer_module in self.layers:
           _lowercase						    =			layer_module(a__	)
         _lowercase						    =			self.shortcut(a__	)
         hidden_state += residual
         _lowercase						    =			self.activation(a__	)
         return hidden_state





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







       """simple docstring"""





       def __init__(     self						:						Union[str, Any]    ,__A						:						Optional[int]    ,__A						:						Any    ,__A						:						Dict    ,__A						:						Optional[Any] = 2    ,__A						:						Dict = 2    ,**__A						:						int	)    ->       Union[str, Any]:
         super().__init__(**a__	)

         _lowercase						    =			TFRegNetXLayer if config.layer_type == 'x' else TFRegNetYLayer
         _lowercase						    =			[
             # downsampling is done in the first layer with stride of 2
             layer(a__    ,a__    ,a__    ,stride=a__    ,name='layers.0'	),
             *[layer(a__    ,a__    ,a__    ,name=F"""layers.{i+1}"""	) for i in range(depth - 1	)],
         ]







       def  __UpperCAmelCase			(     self						:						List[str]    ,__A						:						Optional[Any]	)    ->       Dict:
         for layer_module in self.layers:
           _lowercase						    =			layer_module(a__	)
         return hidden_state





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







       """simple docstring"""





       def __init__(     self						:						Tuple    ,__A						:						int    ,**__A						:						Optional[Any]	)    ->       Dict:
         super().__init__(**a__	)
         _lowercase						    =			[]
         # based on `downsample_in_first_stage`, the first layer of the first stage may or may not downsample the input
         self.stages.append(
             TFRegNetStage(
                 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'    ,)	)
         _lowercase						    =			zip(config.hidden_sizes    ,config.hidden_sizes[1:]	)
         for i, ((in_channels, out_channels), depth) in enumerate(zip(a__    ,config.depths[1:]	)	):
           self.stages.append(TFRegNetStage(a__    ,a__    ,a__    ,depth=a__    ,name=F"""stages.{i+1}"""	)	)







       def  __UpperCAmelCase			(     self						:						Dict    ,__A						:						Tuple    ,__A						:						int = False    ,__A						:						Union[str, Any] = True	)    ->       TFBaseModelOutputWithNoAttention:
         _lowercase						    =			() if output_hidden_states else None

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

           _lowercase						    =			stage_module(a__	)

         if output_hidden_states:
           _lowercase						    =			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__	)





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







       """simple docstring"""





       SCREAMING_SNAKE_CASE_   :			List[Any]  			=	RegNetConfig







       def __init__(     self						:						int    ,__A						:						int    ,**__A						:						str	)    ->       str:
         super().__init__(**a__	)
         _lowercase						    =			config
         _lowercase						    =			TFRegNetEmbeddings(a__    ,name='embedder'	)
         _lowercase						    =			TFRegNetEncoder(a__    ,name='encoder'	)
         _lowercase						    =			tf.keras.layers.GlobalAveragePoolingaD(keepdims=a__    ,name='pooler'	)







       @unpack_inputs
       def  __UpperCAmelCase			(     self						:						str    ,__A						:						Optional[int]    ,__A						:						Tuple = None    ,__A						:						str = None    ,__A						:						Union[str, Any] = False    ,)    ->       TFBaseModelOutputWithPoolingAndNoAttention:
         _lowercase						    =			(
             output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
         )
         _lowercase						    =			return_dict if return_dict is not None else self.config.use_return_dict

         _lowercase						    =			self.embedder(a__    ,training=a__	)

         _lowercase						    =			self.encoder(
             a__    ,output_hidden_states=a__    ,return_dict=a__    ,training=a__	)

         _lowercase						    =			encoder_outputs[0]
         _lowercase						    =			self.pooler(a__	)

         # Change to NCHW output format have uniformity in the modules
         _lowercase						    =			tf.transpose(a__    ,perm=(0, 3, 1, 2)	)
         _lowercase						    =			tf.transpose(a__    ,perm=(0, 3, 1, 2)	)

         # Change the other hidden state outputs to NCHW as well
         if output_hidden_states:
           _lowercase						    =			tuple([tf.transpose(a__    ,perm=(0, 3, 1, 2)	) for h in encoder_outputs[1]]	)

         if not return_dict:
           return (last_hidden_state, pooled_output) + encoder_outputs[1:]

         return TFBaseModelOutputWithPoolingAndNoAttention(
             last_hidden_state=a__    ,pooler_output=a__    ,hidden_states=hidden_states if output_hidden_states else encoder_outputs.hidden_states    ,)





class 					A_					(   __snake_case						):







       """simple docstring"""





       SCREAMING_SNAKE_CASE_   :			str  			=	RegNetConfig
       SCREAMING_SNAKE_CASE_   :			Any  			=	'''regnet'''
       SCREAMING_SNAKE_CASE_   :			List[Any]  			=	'''pixel_values'''







       @property
       def  __UpperCAmelCase			(     self						:						List[Any]	)    ->       int:
         return {"pixel_values": tf.TensorSpec(shape=(None, self.config.num_channels, 224, 224)    ,dtype=tf.floataa	)}
snake_case								=							R"\n    Parameters:\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        config ([`RegNetConfig`]): 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            [`ConveNextImageProcessor.__call__`] for details.\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"





@add_start_docstrings(
    '''The bare RegNet model outputting raw features without any specific head on top.'''       ,						__snake_case       ,						)
class 					A_					(   __snake_case						):







       """simple docstring"""





       def __init__(     self						:						List[str]    ,__A						:						Union[str, Any]    ,*__A						:						List[Any]    ,**__A						:						List[str]	)    ->       Optional[Any]:
         super().__init__(a__    ,*a__    ,**a__	)
         _lowercase						    =			TFRegNetMainLayer(a__    ,name='regnet'	)







       @unpack_inputs
       @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    ,)
       def  __UpperCAmelCase			(     self						:						Optional[int]    ,__A						:						Tuple    ,__A						:						Union[str, Any] = None    ,__A						:						Dict = None    ,__A						:						int=False    ,)    ->       Union[TFBaseModelOutputWithPoolingAndNoAttention, Tuple[tf.Tensor]]:
         _lowercase						    =			(
             output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
         )
         _lowercase						    =			return_dict if return_dict is not None else self.config.use_return_dict

         _lowercase						    =			self.regnet(
             pixel_values=a__    ,output_hidden_states=a__    ,return_dict=a__    ,training=a__    ,)
         if not return_dict:
           return (outputs[0],) + outputs[1:]

         return TFBaseModelOutputWithPoolingAndNoAttention(
             last_hidden_state=outputs.last_hidden_state    ,pooler_output=outputs.pooler_output    ,hidden_states=outputs.hidden_states    ,)





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







       """simple docstring"""





       def __init__(     self						:						Dict    ,__A						:						Dict    ,*__A						:						List[Any]    ,**__A						:						List[str]	)    ->       str:
         super().__init__(a__    ,*a__    ,**a__	)
         _lowercase						    =			config.num_labels
         _lowercase						    =			TFRegNetMainLayer(a__    ,name='regnet'	)
         # classification head
         _lowercase						    =			[
             tf.keras.layers.Flatten(),
             tf.keras.layers.Dense(config.num_labels    ,name='classifier.1'	) if config.num_labels > 0 else tf.identity,
         ]







       @unpack_inputs
       @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    ,)
       def  __UpperCAmelCase			(     self						:						List[Any]    ,__A						:						Tuple = None    ,__A						:						str = None    ,__A						:						Optional[int] = None    ,__A						:						str = None    ,__A						:						List[str]=False    ,)    ->       Union[TFSequenceClassifierOutput, Tuple[tf.Tensor]]:
         _lowercase						    =			(
             output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
         )
         _lowercase						    =			return_dict if return_dict is not None else self.config.use_return_dict

         _lowercase						    =			self.regnet(
             a__    ,output_hidden_states=a__    ,return_dict=a__    ,training=a__	)

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

         _lowercase						    =			self.classifier[0](a__	)
         _lowercase						    =			self.classifier[1](a__	)

         _lowercase						    =			None if labels is None else self.hf_compute_loss(labels=a__    ,logits=a__	)

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

         return TFSequenceClassifierOutput(loss=a__    ,logits=a__    ,hidden_states=outputs.hidden_states	)



import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    StableDiffusionAttendAndExcitePipeline,
    UNetaDConditionModel,
)
from diffusers.utils import load_numpy, skip_mps, slow
from diffusers.utils.testing_utils import require_torch_gpu

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


_lowercase							:   Optional[int]						=						False






@skip_mps
class    _UpperCamelCase     (       __snake_case     ,		__snake_case     ,		__snake_case     ,		unittest.TestCase					):

				"""simple docstring"""







				lowerCAmelCase					=			StableDiffusionAttendAndExcitePipeline
				lowerCAmelCase					=			False
				lowerCAmelCase					=			TEXT_TO_IMAGE_PARAMS
				lowerCAmelCase					=			TEXT_TO_IMAGE_BATCH_PARAMS.union({'token_indices'}					)
				lowerCAmelCase					=			TEXT_TO_IMAGE_IMAGE_PARAMS
				lowerCAmelCase					=			TEXT_TO_IMAGE_IMAGE_PARAMS

				@classmethod
				def   _UpperCAmelCase       (    cls )						->					List[Any]:
					super().setUpClass()
					torch.use_deterministic_algorithms(a__ )

				@classmethod
				def   _UpperCAmelCase       (    cls )						->					Tuple:
					super().tearDownClass()
					torch.use_deterministic_algorithms(a__ )

				def   _UpperCAmelCase       (    self )						->					Dict:
					torch.manual_seed(0 )
					A             =					UNetaDConditionModel(
					    block_out_channels=(32, 64)					, layers_per_block=1					, sample_size=32					, in_channels=4					, out_channels=4					, down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")					, up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")					, cross_attention_dim=32					, attention_head_dim=(2, 4)					, use_linear_projection=a__					, )
					A             =					DDIMScheduler(
					    beta_start=0.0_00_85					, beta_end=0.0_12					, beta_schedule="""scaled_linear"""					, clip_sample=a__					, set_alpha_to_one=a__					, )
					torch.manual_seed(0 )
					A             =					AutoencoderKL(
					    block_out_channels=[32, 64]					, in_channels=3					, out_channels=3					, down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]					, up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]					, latent_channels=4					, sample_size=128					, )
					torch.manual_seed(0 )
					A             =					CLIPTextConfig(
					    bos_token_id=0					, eos_token_id=2					, hidden_size=32					, intermediate_size=37					, layer_norm_eps=1e-05					, num_attention_heads=4					, num_hidden_layers=5					, pad_token_id=1					, vocab_size=1000					, hidden_act="""gelu"""					, projection_dim=512					, )
					A             =					CLIPTextModel(a__ )
					A             =					CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip""" )

					A             =					{
					    """unet""": unet,
					    """scheduler""": scheduler,
					    """vae""": vae,
					    """text_encoder""": text_encoder,
					    """tokenizer""": tokenizer,
					    """safety_checker""": None,
					    """feature_extractor""": None,
					}

					return components

				def   _UpperCAmelCase       (    self					, a__					, a__=0 )						->					Optional[Any]:
					if str(a__ ).startswith("""mps""" ):
						A             =					torch.manual_seed(a__ )
					else:
						A             =					torch.Generator(device=a__ ).manual_seed(a__ )
					A             =					A             =					{
					    """prompt""": """a cat and a frog""",
					    """token_indices""": [2, 5],
					    """generator""": generator,
					    """num_inference_steps""": 1,
					    """guidance_scale""": 6.0,
					    """output_type""": """numpy""",
					    """max_iter_to_alter""": 2,
					    """thresholds""": {0: 0.7},
					}
					return inputs

				def   _UpperCAmelCase       (    self )						->					Union[str, Any]:
					A             =					"""cpu"""

					A             =					self.get_dummy_components()
					A             =					self.pipeline_class(**a__ )
					pipe.to(a__ )
					pipe.set_progress_bar_config(disable=a__ )

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

					self.assertEqual(image.shape					, (1, 64, 64, 3) )
					A             =					np.array(
					    [0.63_90_53_64, 0.62_89_73_07, 0.48_59_90_17, 0.5_13_36_24, 0.5_55_00_48, 0.45_76_95_16, 0.50_32_69_73, 0.5_02_31_39, 0.45_38_44_96] )
					A             =					np.abs(image_slice.flatten() - expected_slice ).max()
					self.assertLessEqual(a__					, 1e-3 )

				def   _UpperCAmelCase       (    self )						->					List[Any]:
					super().test_cpu_offload_forward_pass(expected_max_diff=5e-4 )

				def   _UpperCAmelCase       (    self )						->					Dict:
					# NOTE: Larger batch sizes cause this test to timeout, only test on smaller batches
					self._test_inference_batch_consistent(batch_sizes=[1, 2] )

				def   _UpperCAmelCase       (    self )						->					Any:
					self._test_inference_batch_single_identical(batch_size=2					, expected_max_diff=7e-4 )

				def   _UpperCAmelCase       (    self )						->					Optional[Any]:
					super().test_dict_tuple_outputs_equivalent(expected_max_difference=3e-3 )

				def   _UpperCAmelCase       (    self )						->					str:
					super().test_pt_np_pil_outputs_equivalent(expected_max_diff=5e-4 )

				def   _UpperCAmelCase       (    self )						->					int:
					super().test_save_load_local(expected_max_difference=5e-4 )

				def   _UpperCAmelCase       (    self )						->					Optional[Any]:
					super().test_save_load_optional_components(expected_max_difference=4e-4 )






@require_torch_gpu
@slow
class    _UpperCamelCase     (       unittest.TestCase					):

				"""simple docstring"""







				@classmethod
				def   _UpperCAmelCase       (    cls )						->					Tuple:
					super().setUpClass()
					torch.use_deterministic_algorithms(a__ )

				@classmethod
				def   _UpperCAmelCase       (    cls )						->					Dict:
					super().tearDownClass()
					torch.use_deterministic_algorithms(a__ )

				def   _UpperCAmelCase       (    self )						->					Optional[Any]:
					super().tearDown()
					gc.collect()
					torch.cuda.empty_cache()

				def   _UpperCAmelCase       (    self )						->					int:
					A             =					torch.manual_seed(51 )

					A             =					StableDiffusionAttendAndExcitePipeline.from_pretrained(
					    """CompVis/stable-diffusion-v1-4"""					, safety_checker=a__					, torch_dtype=torch.floataa )
					pipe.to("""cuda""" )

					A             =					"""a painting of an elephant with glasses"""
					A             =					[5, 7]

					A             =					pipe(
					    prompt=a__					, token_indices=a__					, guidance_scale=7.5					, generator=a__					, num_inference_steps=5					, max_iter_to_alter=5					, output_type="""numpy"""					, ).images[0]

					A             =					load_numpy(
					    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/attend-and-excite/elephant_glasses.npy""" )
					assert np.abs((expected_image - image).max() ) < 5e-1



