



# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


lowerCamelCase		       =      {
    """configuration_efficientnet""": [
        """EFFICIENTNET_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """EfficientNetConfig""",
        """EfficientNetOnnxConfig""",
    ]
}

try:
						if not is_vision_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						lowerCamelCase		       =      ["""EfficientNetImageProcessor"""]

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						lowerCamelCase		       =      [
						    """EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST""",
						    """EfficientNetForImageClassification""",
						    """EfficientNetModel""",
						    """EfficientNetPreTrainedModel""",
						]

if TYPE_CHECKING:
						from .configuration_efficientnet import (
						    EFFICIENTNET_PRETRAINED_CONFIG_ARCHIVE_MAP,
						    EfficientNetConfig,
						    EfficientNetOnnxConfig,
						)

						try:
												if not is_vision_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .image_processing_efficientnet import EfficientNetImageProcessor

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_efficientnet import (
												    EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST,
												    EfficientNetForImageClassification,
												    EfficientNetModel,
												    EfficientNetPreTrainedModel,
												)

else:
						import sys

						lowerCamelCase		       =      _LazyModule(__name__, globals()["""__file__"""], _import_structure)







import unittest

import numpy as np
import torch

from diffusers import PNDMPipeline, PNDMScheduler, UNetaDModel
from diffusers.utils.testing_utils import enable_full_determinism, require_torch, slow, torch_device


enable_full_determinism()


class 				_a						(       unittest.TestCase			):





							'''simple docstring'''

							@property
							def 		_A	(							self				):







											"""simple docstring"""



											torch.manual_seed(0				)
											a__	:							str      						= UNetaDModel(
											    block_out_channels=(32, 64) ,					layers_per_block=2 ,					sample_size=32 ,					in_channels=3 ,					out_channels=3 ,					down_block_types=("DownBlock2D", "AttnDownBlock2D") ,					up_block_types=("AttnUpBlock2D", "UpBlock2D") ,					)
											return model




							def 		_A	(							self				):







											"""simple docstring"""



											a__	:							Dict      						= self.dummy_uncond_unet
											a__	:							Optional[Any]      						= PNDMScheduler()

											a__	:							Union[str, Any]      						= PNDMPipeline(unet=__UpperCAmelCase ,					scheduler=__UpperCAmelCase				)
											pndm.to(__UpperCAmelCase				)
											pndm.set_progress_bar_config(disable=__UpperCAmelCase				)

											a__	:							Tuple      						= torch.manual_seed(0				)
											a__	:							Tuple      						= pndm(generator=__UpperCAmelCase ,					num_inference_steps=20 ,					output_type="numpy"				).images

											a__	:							Optional[int]      						= torch.manual_seed(0				)
											a__	:							Tuple      						= pndm(generator=__UpperCAmelCase ,					num_inference_steps=20 ,					output_type="numpy" ,					return_dict=__UpperCAmelCase				)[0]

											a__	:							str      						= image[0, -3:, -3:, -1]
											a__	:							int      						= image_from_tuple[0, -3:, -3:, -1]

											assert image.shape == (1, 32, 32, 3)
											a__	:							int      						= np.array([1.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0]				)

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





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





							'''simple docstring'''

							def 		_A	(							self				):







											"""simple docstring"""



											a__	:							Dict      						= "google/ddpm-cifar10-32"

											a__	:							List[Any]      						= UNetaDModel.from_pretrained(__UpperCAmelCase				)
											a__	:							Optional[Any]      						= PNDMScheduler()

											a__	:							int      						= PNDMPipeline(unet=__UpperCAmelCase ,					scheduler=__UpperCAmelCase				)
											pndm.to(__UpperCAmelCase				)
											pndm.set_progress_bar_config(disable=__UpperCAmelCase				)
											a__	:							Union[str, Any]      						= torch.manual_seed(0				)
											a__	:							Union[str, Any]      						= pndm(generator=__UpperCAmelCase ,					output_type="numpy"				).images

											a__	:							List[Any]      						= image[0, -3:, -3:, -1]

											assert image.shape == (1, 32, 32, 3)
											a__	:							Dict      						= np.array([0.1_5_6_4, 0.1_4_6_4_5, 0.1_4_0_6, 0.1_4_7_1_5, 0.1_2_4_2_5, 0.1_4_0_4_5, 0.1_3_1_1_5, 0.1_2_1_7_5, 0.1_2_5]				)

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


