






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


_UpperCAmelCase				:	int    						=    logging.get_logger(__name__)

# General docstring
_UpperCAmelCase				:	int    						=    'ResNetConfig'

# Base docstring
_UpperCAmelCase				:	Optional[int]    						=    'microsoft/resnet-50'
_UpperCAmelCase				:	Union[str, Any]    						=    [1, 2048, 7, 7]

# Image classification docstring
_UpperCAmelCase				:	Optional[int]    						=    'microsoft/resnet-50'
_UpperCAmelCase				:	Optional[Any]    						=    'tiger cat'

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


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





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





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





					def 	lowerCamelCase       (  self       ,   _UpperCAmelCase       ,   _UpperCAmelCase = False     )		->							tf.Tensor:
								lowerCamelCase											=self.convolution(_UpperCAmelCase     )
								lowerCamelCase											=self.normalization(_UpperCAmelCase       ,   training=_UpperCAmelCase     )
								lowerCamelCase											=self.activation(_UpperCAmelCase     )
								return hidden_state




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





					def __init__(  self       ,   _UpperCAmelCase       ,   **_UpperCAmelCase     )		->							None:
								super().__init__(**_UpperCAmelCase     )
								lowerCamelCase											=TFResNetConvLayer(
								    config.embedding_size       ,   kernel_size=7       ,   stride=2       ,   activation=config.hidden_act       ,   name="""embedder"""       ,   )
								lowerCamelCase											=tf.keras.layers.MaxPoolaD(pool_size=3       ,   strides=2       ,   padding="""valid"""       ,   name="""pooler"""     )
								lowerCamelCase											=config.num_channels





					def 	lowerCamelCase       (  self       ,   _UpperCAmelCase       ,   _UpperCAmelCase = False     )		->							tf.Tensor:
								lowerCamelCase							,					lowerCamelCase							,					lowerCamelCase							,					lowerCamelCase											=shape_list(_UpperCAmelCase     )
								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."""     )
								lowerCamelCase											=pixel_values
								lowerCamelCase											=self.embedder(_UpperCAmelCase     )
								lowerCamelCase											=tf.pad(_UpperCAmelCase       ,   [[0, 0], [1, 1], [1, 1], [0, 0]]     )
								lowerCamelCase											=self.pooler(_UpperCAmelCase     )
								return hidden_state




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





					def __init__(  self       ,   _UpperCAmelCase       ,   _UpperCAmelCase = 2       ,   **_UpperCAmelCase     )		->							None:
								super().__init__(**_UpperCAmelCase     )
								lowerCamelCase											=tf.keras.layers.ConvaD(
								    _UpperCAmelCase       ,   kernel_size=1       ,   strides=_UpperCAmelCase       ,   use_bias=_UpperCAmelCase       ,   name="""convolution"""     )
								# Use same default momentum and epsilon as PyTorch equivalent
								lowerCamelCase											=tf.keras.layers.BatchNormalization(epsilon=1E-5       ,   momentum=0.9       ,   name="""normalization"""     )





					def 	lowerCamelCase       (  self       ,   _UpperCAmelCase       ,   _UpperCAmelCase = False     )		->							tf.Tensor:
								lowerCamelCase											=x
								lowerCamelCase											=self.convolution(_UpperCAmelCase     )
								lowerCamelCase											=self.normalization(_UpperCAmelCase       ,   training=_UpperCAmelCase     )
								return hidden_state




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





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





					def 	lowerCamelCase       (  self       ,   _UpperCAmelCase       ,   _UpperCAmelCase = False     )		->							tf.Tensor:
								lowerCamelCase											=hidden_state
								lowerCamelCase											=self.conva(_UpperCAmelCase       ,   training=_UpperCAmelCase     )
								lowerCamelCase											=self.conva(_UpperCAmelCase       ,   training=_UpperCAmelCase     )
								lowerCamelCase											=self.shortcut(_UpperCAmelCase       ,   training=_UpperCAmelCase     )
								hidden_state += residual
								lowerCamelCase											=self.activation(_UpperCAmelCase     )
								return hidden_state




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





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





					def 	lowerCamelCase       (  self       ,   _UpperCAmelCase       ,   _UpperCAmelCase = False     )		->							tf.Tensor:
								lowerCamelCase											=hidden_state
								lowerCamelCase											=self.conva(_UpperCAmelCase       ,   training=_UpperCAmelCase     )
								lowerCamelCase											=self.conva(_UpperCAmelCase       ,   training=_UpperCAmelCase     )
								lowerCamelCase											=self.conva(_UpperCAmelCase       ,   training=_UpperCAmelCase     )
								lowerCamelCase											=self.shortcut(_UpperCAmelCase       ,   training=_UpperCAmelCase     )
								hidden_state += residual
								lowerCamelCase											=self.activation(_UpperCAmelCase     )
								return hidden_state




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





					def __init__(  self       ,   _UpperCAmelCase       ,   _UpperCAmelCase       ,   _UpperCAmelCase       ,   _UpperCAmelCase = 2       ,   _UpperCAmelCase = 2       ,   **_UpperCAmelCase     )		->							None:
								super().__init__(**_UpperCAmelCase     )

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

								lowerCamelCase											=[layer(_UpperCAmelCase       ,   _UpperCAmelCase       ,   stride=_UpperCAmelCase       ,   activation=config.hidden_act       ,   name="""layers.0"""     )]
								layers += [
								    layer(_UpperCAmelCase       ,   _UpperCAmelCase       ,   activation=config.hidden_act       ,   name=F'''layers.{i + 1}'''     )
								    for i in range(depth - 1     )
								]
								lowerCamelCase											=layers





					def 	lowerCamelCase       (  self       ,   _UpperCAmelCase       ,   _UpperCAmelCase = False     )		->							tf.Tensor:
								for layer in self.stage_layers:
											lowerCamelCase											=layer(_UpperCAmelCase       ,   training=_UpperCAmelCase     )
								return hidden_state




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





					def __init__(  self       ,   _UpperCAmelCase       ,   **_UpperCAmelCase     )		->							None:
								super().__init__(**_UpperCAmelCase     )
								# based on `downsample_in_first_stage` the first layer of the first stage may or may not downsample the input
								lowerCamelCase											=[
								    TFResNetStage(
								        _UpperCAmelCase       ,   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(_UpperCAmelCase       ,   _UpperCAmelCase       ,   _UpperCAmelCase       ,   depth=_UpperCAmelCase       ,   name=F'''stages.{i + 1}'''     )     )





					def 	lowerCamelCase       (  self       ,   _UpperCAmelCase       ,   _UpperCAmelCase = False       ,   _UpperCAmelCase = True       ,   _UpperCAmelCase = False       ,   )		->							TFBaseModelOutputWithNoAttention:
								lowerCamelCase											=() if output_hidden_states else None

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

											lowerCamelCase											=stage_module(_UpperCAmelCase       ,   training=_UpperCAmelCase     )

								if output_hidden_states:
											lowerCamelCase											=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=_UpperCAmelCase       ,   hidden_states=_UpperCAmelCase     )




class 		lowerCAmelCase_							(     UpperCamelCase   ):
					__lowerCamelCase					:						Optional[Any]     =    ResNetConfig
					__lowerCamelCase					:						Tuple     =    '''resnet'''
					__lowerCamelCase					:						Tuple     =    '''pixel_values'''





					@property
					def 	lowerCamelCase       (  self     )		->							str:
								return {"pixel_values": tf.TensorSpec(shape=(None, self.config.num_channels, 224, 224)       ,   dtype=tf.floataa     )}




_UpperCAmelCase				:	Dict    						=    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'


_UpperCAmelCase				:	Tuple    						=    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   ):
					__lowerCamelCase					:						List[Any]     =    ResNetConfig





					def __init__(  self       ,   _UpperCAmelCase       ,   **_UpperCAmelCase     )		->							None:
								super().__init__(**_UpperCAmelCase     )
								lowerCamelCase											=config
								lowerCamelCase											=TFResNetEmbeddings(_UpperCAmelCase       ,   name="""embedder"""     )
								lowerCamelCase											=TFResNetEncoder(_UpperCAmelCase       ,   name="""encoder"""     )
								lowerCamelCase											=tf.keras.layers.GlobalAveragePoolingaD(keepdims=_UpperCAmelCase     )





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

								lowerCamelCase											=self.encoder(
								    _UpperCAmelCase       ,   output_hidden_states=_UpperCAmelCase       ,   return_dict=_UpperCAmelCase       ,   training=_UpperCAmelCase     )

								lowerCamelCase											=encoder_outputs[0]

								lowerCamelCase											=self.pooler(_UpperCAmelCase     )

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

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

								lowerCamelCase											=hidden_states if output_hidden_states else None

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




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





					def __init__(  self       ,   _UpperCAmelCase       ,   **_UpperCAmelCase     )		->							None:
								super().__init__(_UpperCAmelCase       ,   **_UpperCAmelCase     )
								lowerCamelCase											=TFResNetMainLayer(config=_UpperCAmelCase       ,   name="""resnet"""     )





					@add_start_docstrings_to_model_forward(_UpperCAmelCase     )
					@add_code_sample_docstrings(
					    checkpoint=_CHECKPOINT_FOR_DOC       ,   output_type=_UpperCAmelCase       ,   config_class=_CONFIG_FOR_DOC       ,   modality="""vision"""       ,   expected_output=_EXPECTED_OUTPUT_SHAPE       ,   )
					@unpack_inputs
					def 	lowerCamelCase       (  self       ,   _UpperCAmelCase       ,   _UpperCAmelCase = None       ,   _UpperCAmelCase = None       ,   _UpperCAmelCase = False       ,   )		->							Union[Tuple[tf.Tensor], TFBaseModelOutputWithPoolingAndNoAttention]:
								lowerCamelCase											=(
								    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
								)
								lowerCamelCase											=return_dict if return_dict is not None else self.config.use_return_dict

								lowerCamelCase											=self.resnet(
								    pixel_values=_UpperCAmelCase       ,   output_hidden_states=_UpperCAmelCase       ,   return_dict=_UpperCAmelCase       ,   training=_UpperCAmelCase       ,   )
								return resnet_outputs




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





					def __init__(  self       ,   _UpperCAmelCase       ,   **_UpperCAmelCase     )		->							None:
								super().__init__(_UpperCAmelCase       ,   **_UpperCAmelCase     )
								lowerCamelCase											=config.num_labels
								lowerCamelCase											=TFResNetMainLayer(_UpperCAmelCase       ,   name="""resnet"""     )
								# classification head
								lowerCamelCase											=(
								    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 	lowerCamelCase       (  self       ,   _UpperCAmelCase     )		->							tf.Tensor:
								lowerCamelCase											=tf.keras.layers.Flatten()(_UpperCAmelCase     )
								lowerCamelCase											=self.classifier_layer(_UpperCAmelCase     )
								return logits





					@add_start_docstrings_to_model_forward(_UpperCAmelCase     )
					@add_code_sample_docstrings(
					    checkpoint=_IMAGE_CLASS_CHECKPOINT       ,   output_type=_UpperCAmelCase       ,   config_class=_CONFIG_FOR_DOC       ,   expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT       ,   )
					@unpack_inputs
					def 	lowerCamelCase       (  self       ,   _UpperCAmelCase = None       ,   _UpperCAmelCase = None       ,   _UpperCAmelCase = None       ,   _UpperCAmelCase = None       ,   _UpperCAmelCase = False       ,   )		->							Union[Tuple[tf.Tensor], TFImageClassifierOutputWithNoAttention]:
								lowerCamelCase											=return_dict if return_dict is not None else self.config.use_return_dict

								lowerCamelCase											=self.resnet(
								    _UpperCAmelCase       ,   output_hidden_states=_UpperCAmelCase       ,   return_dict=_UpperCAmelCase       ,   training=_UpperCAmelCase     )

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

								lowerCamelCase											=self.classifier(_UpperCAmelCase     )

								lowerCamelCase											=None if labels is None else self.hf_compute_loss(_UpperCAmelCase       ,   _UpperCAmelCase     )

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

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







import random
import unittest

import numpy as np
import torch

from diffusers import DDIMScheduler, LDMSuperResolutionPipeline, UNetaDModel, VQModel
from diffusers.utils import PIL_INTERPOLATION, floats_tensor, load_image, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch


enable_full_determinism()


class 		lowerCAmelCase_							(     unittest.TestCase   ):





     @property
     def 	lowerCamelCase       (  self     )		->							Tuple:
        lowerCamelCase											=1
        lowerCamelCase											=3
        lowerCamelCase											=(32, 32)

        lowerCamelCase											=floats_tensor((batch_size, num_channels) + sizes       ,   rng=random.Random(0     )     ).to(_UpperCAmelCase     )
        return image





     @property
     def 	lowerCamelCase       (  self     )		->							Optional[int]:
        torch.manual_seed(0     )
        lowerCamelCase											=UNetaDModel(
            block_out_channels=(32, 64)       ,   layers_per_block=2       ,   sample_size=32       ,   in_channels=6       ,   out_channels=3       ,   down_block_types=("""DownBlock2D""", """AttnDownBlock2D""")       ,   up_block_types=("""AttnUpBlock2D""", """UpBlock2D""")       ,   )
        return model





     @property
     def 	lowerCamelCase       (  self     )		->							int:
        torch.manual_seed(0     )
        lowerCamelCase											=VQModel(
            block_out_channels=[32, 64]       ,   in_channels=3       ,   out_channels=3       ,   down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]       ,   up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]       ,   latent_channels=3       ,   )
        return model





     def 	lowerCamelCase       (  self     )		->							Any:
        lowerCamelCase											="""cpu"""
        lowerCamelCase											=self.dummy_uncond_unet
        lowerCamelCase											=DDIMScheduler()
        lowerCamelCase											=self.dummy_vq_model

        lowerCamelCase											=LDMSuperResolutionPipeline(unet=_UpperCAmelCase       ,   vqvae=_UpperCAmelCase       ,   scheduler=_UpperCAmelCase     )
        ldm.to(_UpperCAmelCase     )
        ldm.set_progress_bar_config(disable=_UpperCAmelCase     )

        lowerCamelCase											=self.dummy_image.to(_UpperCAmelCase     )

        lowerCamelCase											=torch.Generator(device=_UpperCAmelCase     ).manual_seed(0     )
        lowerCamelCase											=ldm(image=_UpperCAmelCase       ,   generator=_UpperCAmelCase       ,   num_inference_steps=2       ,   output_type="""numpy"""     ).images

        lowerCamelCase											=image[0, -3:, -3:, -1]

        assert image.shape == (1, 64, 64, 3)
        lowerCamelCase											=np.array([0.8678, 0.8245, 0.6381, 0.6830, 0.4385, 0.5599, 0.4641, 0.6201, 0.5150]     )

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





     @unittest.skipIf(torch_device != """cuda"""       ,   """This test requires a GPU"""     )
     def 	lowerCamelCase       (  self     )		->							int:
        lowerCamelCase											=self.dummy_uncond_unet
        lowerCamelCase											=DDIMScheduler()
        lowerCamelCase											=self.dummy_vq_model

        # put models in fp16
        lowerCamelCase											=unet.half()
        lowerCamelCase											=vqvae.half()

        lowerCamelCase											=LDMSuperResolutionPipeline(unet=_UpperCAmelCase       ,   vqvae=_UpperCAmelCase       ,   scheduler=_UpperCAmelCase     )
        ldm.to(_UpperCAmelCase     )
        ldm.set_progress_bar_config(disable=_UpperCAmelCase     )

        lowerCamelCase											=self.dummy_image.to(_UpperCAmelCase     )

        lowerCamelCase											=ldm(_UpperCAmelCase       ,   num_inference_steps=2       ,   output_type="""numpy"""     ).images

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




@slow
@require_torch
class 		lowerCAmelCase_							(     unittest.TestCase   ):





     def 	lowerCamelCase       (  self     )		->							Optional[int]:
        lowerCamelCase											=load_image(
            """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
            """/vq_diffusion/teddy_bear_pool.png"""     )
        lowerCamelCase											=init_image.resize((64, 64)       ,   resample=PIL_INTERPOLATION["""lanczos"""]     )

        lowerCamelCase											=LDMSuperResolutionPipeline.from_pretrained("""duongna/ldm-super-resolution"""       ,   device_map="""auto"""     )
        ldm.set_progress_bar_config(disable=_UpperCAmelCase     )

        lowerCamelCase											=torch.manual_seed(0     )
        lowerCamelCase											=ldm(image=_UpperCAmelCase       ,   generator=_UpperCAmelCase       ,   num_inference_steps=20       ,   output_type="""numpy"""     ).images

        lowerCamelCase											=image[0, -3:, -3:, -1]

        assert image.shape == (1, 256, 256, 3)
        lowerCamelCase											=np.array([0.7644, 0.7679, 0.7642, 0.7633, 0.7666, 0.7560, 0.7425, 0.7257, 0.6907]     )

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