
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


_A  					= logging.get_logger(__name__)

# General docstring
_A  					= "ResNetConfig"

# Base docstring
_A  					= "microsoft/resnet-50"
_A  					= [1, 20_48, 7, 7]

# Image classification docstring
_A  					= "microsoft/resnet-50"
_A  					= "tiger cat"

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







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





     def __init__(self      :    int				,    _A      :    int				,    _A      :    int = 3				,    _A      :    int = 1				,    _A      :    str = "relu"				,    **_A      :    List[str]   )						->						None:
         super().__init__(**_A   )
         snake_case      =					kernel_size // 2
         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
         snake_case      =					tf.keras.layers.BatchNormalization(epsilon=1E-5				,    momentum=0.9				,    name="normalization"   )
         snake_case      =					ACTaFN[activation] if activation is not None else tf.keras.layers.Activation("linear"   )





     def 		UpperCAmelCase(self      :    Tuple				,    _A      :    tf.Tensor   )						->						tf.Tensor:
         # Pad to match that done in the PyTorch Conv2D model
         snake_case      =					snake_case      =					(self.pad_value, self.pad_value)
         snake_case      =					tf.pad(_A				,    [(0, 0), height_pad, width_pad, (0, 0)]   )
         snake_case      =					self.conv(_A   )
         return hidden_state





     def 		UpperCAmelCase(self      :    Any				,    _A      :    tf.Tensor				,    _A      :    bool = False   )						->						tf.Tensor:
         snake_case      =					self.convolution(_A   )
         snake_case      =					self.normalization(_A				,    training=_A   )
         snake_case      =					self.activation(_A   )
         return hidden_state







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





     def __init__(self      :    Optional[int]				,    _A      :    ResNetConfig				,    **_A      :    Any   )						->						None:
         super().__init__(**_A   )
         snake_case      =					TFResNetConvLayer(
             config.embedding_size				,    kernel_size=7				,    stride=2				,    activation=config.hidden_act				,    name="embedder"				,    )
         snake_case      =					tf.keras.layers.MaxPoolaD(pool_size=3				,    strides=2				,    padding="valid"				,    name="pooler"   )
         snake_case      =					config.num_channels





     def 		UpperCAmelCase(self      :    Dict				,    _A      :    tf.Tensor				,    _A      :    bool = False   )						->						tf.Tensor:
         snake_case     ,							snake_case     ,							snake_case     ,							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."   )
         snake_case      =					pixel_values
         snake_case      =					self.embedder(_A   )
         snake_case      =					tf.pad(_A				,    [[0, 0], [1, 1], [1, 1], [0, 0]]   )
         snake_case      =					self.pooler(_A   )
         return hidden_state







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





     def __init__(self      :    List[str]				,    _A      :    int				,    _A      :    int = 2				,    **_A      :    List[Any]   )						->						None:
         super().__init__(**_A   )
         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
         snake_case      =					tf.keras.layers.BatchNormalization(epsilon=1E-5				,    momentum=0.9				,    name="normalization"   )





     def 		UpperCAmelCase(self      :    str				,    _A      :    tf.Tensor				,    _A      :    bool = False   )						->						tf.Tensor:
         snake_case      =					x
         snake_case      =					self.convolution(_A   )
         snake_case      =					self.normalization(_A				,    training=_A   )
         return hidden_state







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





     def __init__(self      :    int				,    _A      :    int				,    _A      :    int				,    _A      :    int = 1				,    _A      :    str = "relu"				,    **_A      :    int   )						->						None:
         super().__init__(**_A   )
         snake_case      =					in_channels != out_channels or stride != 1
         snake_case      =					TFResNetConvLayer(_A				,    stride=_A				,    name="layer.0"   )
         snake_case      =					TFResNetConvLayer(_A				,    activation=_A				,    name="layer.1"   )
         snake_case      =					(
             TFResNetShortCut(_A				,    stride=_A				,    name="shortcut"   )
             if should_apply_shortcut
             else tf.keras.layers.Activation("linear"				,    name="shortcut"   )
         )
         snake_case      =					ACTaFN[activation]





     def 		UpperCAmelCase(self      :    int				,    _A      :    tf.Tensor				,    _A      :    bool = False   )						->						tf.Tensor:
         snake_case      =					hidden_state
         snake_case      =					self.conva(_A				,    training=_A   )
         snake_case      =					self.conva(_A				,    training=_A   )
         snake_case      =					self.shortcut(_A				,    training=_A   )
         hidden_state += residual
         snake_case      =					self.activation(_A   )
         return hidden_state







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





     def __init__(self      :    Any				,    _A      :    int				,    _A      :    int				,    _A      :    int = 1				,    _A      :    str = "relu"				,    _A      :    int = 4				,    **_A      :    List[Any]				,    )						->						None:
         super().__init__(**_A   )
         snake_case      =					in_channels != out_channels or stride != 1
         snake_case      =					out_channels // reduction
         snake_case      =					TFResNetConvLayer(_A				,    kernel_size=1				,    name="layer.0"   )
         snake_case      =					TFResNetConvLayer(_A				,    stride=_A				,    name="layer.1"   )
         snake_case      =					TFResNetConvLayer(_A				,    kernel_size=1				,    activation=_A				,    name="layer.2"   )
         snake_case      =					(
             TFResNetShortCut(_A				,    stride=_A				,    name="shortcut"   )
             if should_apply_shortcut
             else tf.keras.layers.Activation("linear"				,    name="shortcut"   )
         )
         snake_case      =					ACTaFN[activation]





     def 		UpperCAmelCase(self      :    List[str]				,    _A      :    tf.Tensor				,    _A      :    bool = False   )						->						tf.Tensor:
         snake_case      =					hidden_state
         snake_case      =					self.conva(_A				,    training=_A   )
         snake_case      =					self.conva(_A				,    training=_A   )
         snake_case      =					self.conva(_A				,    training=_A   )
         snake_case      =					self.shortcut(_A				,    training=_A   )
         hidden_state += residual
         snake_case      =					self.activation(_A   )
         return hidden_state







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





     def __init__(self      :    List[str]				,    _A      :    ResNetConfig				,    _A      :    int				,    _A      :    int				,    _A      :    int = 2				,    _A      :    int = 2				,    **_A      :    Union[str, Any]   )						->						None:
         super().__init__(**_A   )

         snake_case      =					TFResNetBottleNeckLayer if config.layer_type == "bottleneck" else TFResNetBasicLayer

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





     def 		UpperCAmelCase(self      :    Optional[Any]				,    _A      :    tf.Tensor				,    _A      :    bool = False   )						->						tf.Tensor:
         for layer in self.stage_layers:
             snake_case      =					layer(_A				,    training=_A   )
         return hidden_state







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





     def __init__(self      :    List[Any]				,    _A      :    ResNetConfig				,    **_A      :    List[str]   )						->						None:
         super().__init__(**_A   )
         # based on `downsample_in_first_stage` the first layer of the first stage may or may not downsample the input
         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 		UpperCAmelCase(self      :    Dict				,    _A      :    tf.Tensor				,    _A      :    bool = False				,    _A      :    bool = True				,    _A      :    bool = False				,    )						->						TFBaseModelOutputWithNoAttention:
         snake_case      =					() if output_hidden_states else None

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

             snake_case      =					stage_module(_A				,    training=_A   )

         if output_hidden_states:
             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      lowerCamelCase		(  A_  ):
     UpperCAmelCase__				:							Union[str, Any]           =		ResNetConfig
     UpperCAmelCase__				:							Tuple           =		"resnet"
     UpperCAmelCase__				:							Optional[int]           =		"pixel_values"





     @property
     def 		UpperCAmelCase(self      :    Dict   )						->						int:
         return {"pixel_values": tf.TensorSpec(shape=(None, self.config.num_channels, 2_2_4, 2_2_4)				,    dtype=tf.floataa   )}


_A  					= 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"


_A  					= 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      lowerCamelCase		(  tf.keras.layers.Layer  ):
     UpperCAmelCase__				:							Optional[Any]           =		ResNetConfig





     def __init__(self      :    Dict				,    _A      :    ResNetConfig				,    **_A      :    str   )						->						None:
         super().__init__(**_A   )
         snake_case      =					config
         snake_case      =					TFResNetEmbeddings(_A				,    name="embedder"   )
         snake_case      =					TFResNetEncoder(_A				,    name="encoder"   )
         snake_case      =					tf.keras.layers.GlobalAveragePoolingaD(keepdims=_A   )





     @unpack_inputs
     def 		UpperCAmelCase(self      :    Dict				,    _A      :    tf.Tensor				,    _A      :    Optional[bool] = None				,    _A      :    Optional[bool] = None				,    _A      :    bool = False				,    )						->						Union[Tuple[tf.Tensor], TFBaseModelOutputWithPoolingAndNoAttention]:
         snake_case      =					(
             output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
         )
         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)
         snake_case      =					tf.transpose(_A				,    perm=[0, 2, 3, 1]   )
         snake_case      =					self.embedder(_A				,    training=_A   )

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

         snake_case      =					encoder_outputs[0]

         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)
         snake_case      =					tf.transpose(_A				,    (0, 3, 1, 2)   )
         snake_case      =					tf.transpose(_A				,    (0, 3, 1, 2)   )
         snake_case      =					()
         for hidden_state in encoder_outputs[1:]:
             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

         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      lowerCamelCase		(  A_  ):





     def __init__(self      :    Tuple				,    _A      :    ResNetConfig				,    **_A      :    Union[str, Any]   )						->						None:
         super().__init__(_A				,    **_A   )
         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 		UpperCAmelCase(self      :    Dict				,    _A      :    tf.Tensor				,    _A      :    Optional[bool] = None				,    _A      :    Optional[bool] = None				,    _A      :    bool = False				,    )						->						Union[Tuple[tf.Tensor], TFBaseModelOutputWithPoolingAndNoAttention]:
         snake_case      =					(
             output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
         )
         snake_case      =					return_dict if return_dict is not None else self.config.use_return_dict

         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      lowerCamelCase		(  A_							, A_  ):





     def __init__(self      :    Tuple				,    _A      :    ResNetConfig				,    **_A      :    str   )						->						None:
         super().__init__(_A				,    **_A   )
         snake_case      =					config.num_labels
         snake_case      =					TFResNetMainLayer(_A				,    name="resnet"   )
         # classification head
         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 		UpperCAmelCase(self      :    Tuple				,    _A      :    tf.Tensor   )						->						tf.Tensor:
         snake_case      =					tf.keras.layers.Flatten()(_A   )
         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 		UpperCAmelCase(self      :    Any				,    _A      :    tf.Tensor = None				,    _A      :    tf.Tensor = None				,    _A      :    bool = None				,    _A      :    bool = None				,    _A      :    bool = False				,    )						->						Union[Tuple[tf.Tensor], TFImageClassifierOutputWithNoAttention]:
         snake_case      =					return_dict if return_dict is not None else self.config.use_return_dict

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

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

         snake_case      =					self.classifier(_A   )

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

         if not return_dict:
             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   )



import unittest

import numpy as np
import torch
from torch import nn
from transformers import (
    CLIPImageProcessor,
    CLIPTextConfig,
    CLIPTextModelWithProjection,
    CLIPTokenizer,
    CLIPVisionConfig,
    CLIPVisionModelWithProjection,
)

from diffusers import KandinskyPriorPipeline, PriorTransformer, UnCLIPScheduler
from diffusers.utils import torch_device
from diffusers.utils.testing_utils import enable_full_determinism, skip_mps

from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()







class      lowerCamelCase		(  A_							, unittest.TestCase  ):
     UpperCAmelCase__				:							Tuple           =		KandinskyPriorPipeline
     UpperCAmelCase__				:							List[str]           =		["prompt"]
     UpperCAmelCase__				:							List[str]           =		["prompt", "negative_prompt"]
     UpperCAmelCase__				:							List[str]           =		[
         "num_images_per_prompt",
         "generator",
         "num_inference_steps",
         "latents",
         "negative_prompt",
         "guidance_scale",
         "output_type",
         "return_dict",
     ]
     UpperCAmelCase__				:							str           =		False





     @property
     def 		UpperCAmelCase(self      :    List[str]   )						->						Union[str, Any]:
         return 3_2





     @property
     def 		UpperCAmelCase(self      :    Any   )						->						Any:
         return 3_2





     @property
     def 		UpperCAmelCase(self      :    int   )						->						Dict:
         return self.time_input_dim





     @property
     def 		UpperCAmelCase(self      :    str   )						->						Tuple:
         return self.time_input_dim * 4





     @property
     def 		UpperCAmelCase(self      :    Dict   )						->						Dict:
         return 1_0_0





     @property
     def 		UpperCAmelCase(self      :    Any   )						->						int:
         snake_case      =					CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"   )
         return tokenizer





     @property
     def 		UpperCAmelCase(self      :    Optional[Any]   )						->						Optional[Any]:
         torch.manual_seed(0   )
         snake_case      =					CLIPTextConfig(
             bos_token_id=0				,    eos_token_id=2				,    hidden_size=self.text_embedder_hidden_size				,    projection_dim=self.text_embedder_hidden_size				,    intermediate_size=3_7				,    layer_norm_eps=1E-05				,    num_attention_heads=4				,    num_hidden_layers=5				,    pad_token_id=1				,    vocab_size=1_0_0_0				,    )
         return CLIPTextModelWithProjection(_A   )





     @property
     def 		UpperCAmelCase(self      :    List[Any]   )						->						Tuple:
         torch.manual_seed(0   )

         snake_case      =					{
             "num_attention_heads": 2,
             "attention_head_dim": 1_2,
             "embedding_dim": self.text_embedder_hidden_size,
             "num_layers": 1,
         }

         snake_case      =					PriorTransformer(**_A   )
         # clip_std and clip_mean is initialized to be 0 so PriorTransformer.post_process_latents will always return 0 - set clip_std to be 1 so it won't return 0
         snake_case      =					nn.Parameter(torch.ones(model.clip_std.shape   )   )
         return model





     @property
     def 		UpperCAmelCase(self      :    str   )						->						Union[str, Any]:
         torch.manual_seed(0   )
         snake_case      =					CLIPVisionConfig(
             hidden_size=self.text_embedder_hidden_size				,    image_size=2_2_4				,    projection_dim=self.text_embedder_hidden_size				,    intermediate_size=3_7				,    num_attention_heads=4				,    num_channels=3				,    num_hidden_layers=5				,    patch_size=1_4				,    )

         snake_case      =					CLIPVisionModelWithProjection(_A   )
         return model





     @property
     def 		UpperCAmelCase(self      :    List[Any]   )						->						int:
         snake_case      =					CLIPImageProcessor(
             crop_size=2_2_4				,    do_center_crop=_A				,    do_normalize=_A				,    do_resize=_A				,    image_mean=[0.48_14_54_66, 0.4_57_82_75, 0.40_82_10_73]				,    image_std=[0.26_86_29_54, 0.26_13_02_58, 0.27_57_77_11]				,    resample=3				,    size=2_2_4				,    )

         return image_processor





     def 		UpperCAmelCase(self      :    int   )						->						Union[str, Any]:
         snake_case      =					self.dummy_prior
         snake_case      =					self.dummy_image_encoder
         snake_case      =					self.dummy_text_encoder
         snake_case      =					self.dummy_tokenizer
         snake_case      =					self.dummy_image_processor

         snake_case      =					UnCLIPScheduler(
             variance_type="fixed_small_log"				,    prediction_type="sample"				,    num_train_timesteps=1_0_0_0				,    clip_sample=_A				,    clip_sample_range=10.0				,    )

         snake_case      =					{
             "prior": prior,
             "image_encoder": image_encoder,
             "text_encoder": text_encoder,
             "tokenizer": tokenizer,
             "scheduler": scheduler,
             "image_processor": image_processor,
         }

         return components





     def 		UpperCAmelCase(self      :    Optional[int]				,    _A      :    Tuple				,    _A      :    str=0   )						->						Union[str, Any]:
         if str(_A   ).startswith("mps"   ):
             snake_case      =					torch.manual_seed(_A   )
         else:
             snake_case      =					torch.Generator(device=_A   ).manual_seed(_A   )
         snake_case      =					{
             "prompt": "horse",
             "generator": generator,
             "guidance_scale": 4.0,
             "num_inference_steps": 2,
             "output_type": "np",
         }
         return inputs





     def 		UpperCAmelCase(self      :    List[Any]   )						->						int:
         snake_case      =					"cpu"

         snake_case      =					self.get_dummy_components()

         snake_case      =					self.pipeline_class(**_A   )
         snake_case      =					pipe.to(_A   )

         pipe.set_progress_bar_config(disable=_A   )

         snake_case      =					pipe(**self.get_dummy_inputs(_A   )   )
         snake_case      =					output.image_embeds

         snake_case      =					pipe(
             **self.get_dummy_inputs(_A   )				,    return_dict=_A				,    )[0]

         snake_case      =					image[0, -1_0:]
         snake_case      =					image_from_tuple[0, -1_0:]

         assert image.shape == (1, 3_2)

         snake_case      =					np.array(
             [-0.05_32, 1.71_20, 0.36_56, -1.08_52, -0.89_46, -1.17_56, 0.43_48, 0.24_82, 0.51_46, -0.11_56]   )

         assert np.abs(image_slice.flatten() - expected_slice   ).max() < 1E-2
         assert np.abs(image_from_tuple_slice.flatten() - expected_slice   ).max() < 1E-2





     @skip_mps
     def 		UpperCAmelCase(self      :    List[Any]   )						->						str:
         snake_case      =					torch_device == "cpu"
         snake_case      =					True
         snake_case      =					False

         self._test_inference_batch_single_identical(
             test_max_difference=_A				,    relax_max_difference=_A				,    test_mean_pixel_difference=_A				,    )





     @skip_mps
     def 		UpperCAmelCase(self      :    Optional[int]   )						->						List[str]:
         snake_case      =					torch_device == "cpu"
         snake_case      =					False

         self._test_attention_slicing_forward_pass(
             test_max_difference=_A				,    test_mean_pixel_difference=_A				,    )

