



"""simple docstring"""







# 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


UpperCamelCase     =							{
    '''configuration_efficientnet''': [
        '''EFFICIENTNET_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''EfficientNetConfig''',
        '''EfficientNetOnnxConfig''',
    ]
}

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

try:
			if not is_torch_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			UpperCamelCase     =							[
			    '''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

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










import torch

from diffusers import KDPMaDiscreteScheduler
from diffusers.utils import torch_device

from .test_schedulers import SchedulerCommonTest



class    lowercase_		(SCREAMING_SNAKE_CASE__ ):
						lowerCAmelCase__			      =(KDPMaDiscreteScheduler,)
						lowerCAmelCase__			      =10



						def 	__a					(			self	:   Dict					,							**snake_case__	:   str  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							{
								    'num_train_timesteps': 11_00,
								    'beta_start': 0.00_01,
								    'beta_end': 0.02,
								    'beta_schedule': 'linear',
								}

								config.update(**snake_case__  )
								return config



						def 	__a					(			self	:   str  ):

								"""simple docstring"""

								for timesteps in [10, 50, 1_00, 10_00]:
										self.check_over_configs(num_train_timesteps=snake_case__  )



						def 	__a					(			self	:   List[Any]  ):

								"""simple docstring"""

								for beta_start, beta_end in zip([0.0_00_01, 0.00_01, 0.0_01]					,							[0.00_02, 0.0_02, 0.02]  ):
										self.check_over_configs(beta_start=snake_case__					,							beta_end=snake_case__  )



						def 	__a					(			self	:   Optional[int]  ):

								"""simple docstring"""

								for schedule in ["linear", "scaled_linear"]:
										self.check_over_configs(beta_schedule=snake_case__  )



						def 	__a					(			self	:   Optional[Any]  ):

								"""simple docstring"""

								for prediction_type in ["epsilon", "v_prediction"]:
										self.check_over_configs(prediction_type=snake_case__  )



						def 	__a					(			self	:   Optional[Any]  ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_					      =							self.scheduler_classes[0]
								SCREAMING_SNAKE_CASE_					      =							self.get_scheduler_config(prediction_type='v_prediction'  )
								SCREAMING_SNAKE_CASE_					      =							scheduler_class(**snake_case__  )

								scheduler.set_timesteps(self.num_inference_steps  )

								SCREAMING_SNAKE_CASE_					      =							self.dummy_model()
								SCREAMING_SNAKE_CASE_					      =							self.dummy_sample_deter * scheduler.init_noise_sigma
								SCREAMING_SNAKE_CASE_					      =							sample.to(snake_case__  )

								for i, t in enumerate(scheduler.timesteps  ):
										SCREAMING_SNAKE_CASE_					      =							scheduler.scale_model_input(snake_case__					,							snake_case__  )

										SCREAMING_SNAKE_CASE_					      =							model(snake_case__					,							snake_case__  )

										SCREAMING_SNAKE_CASE_					      =							scheduler.step(snake_case__					,							snake_case__					,							snake_case__  )
										SCREAMING_SNAKE_CASE_					      =							output.prev_sample

								SCREAMING_SNAKE_CASE_					      =							torch.sum(torch.abs(snake_case__  )  )
								SCREAMING_SNAKE_CASE_					      =							torch.mean(torch.abs(snake_case__  )  )

								if torch_device in ["cpu", "mps"]:
										assert abs(result_sum.item() - 4.69_34e-07  ) < 1e-2
										assert abs(result_mean.item() - 6.11_12e-10  ) < 1e-3
								else:
										# CUDA
										assert abs(result_sum.item() - 4.6_93_42_86_50_17_09_72e-07  ) < 1e-2
										assert abs(result_mean.item() - 0.00_02  ) < 1e-3



						def 	__a					(			self	:   Union[str, Any]  ):

								"""simple docstring"""

								if torch_device == "mps":
										return
								SCREAMING_SNAKE_CASE_					      =							self.scheduler_classes[0]
								SCREAMING_SNAKE_CASE_					      =							self.get_scheduler_config()
								SCREAMING_SNAKE_CASE_					      =							scheduler_class(**snake_case__  )

								scheduler.set_timesteps(self.num_inference_steps  )

								SCREAMING_SNAKE_CASE_					      =							self.dummy_model()
								SCREAMING_SNAKE_CASE_					      =							self.dummy_sample_deter * scheduler.init_noise_sigma
								SCREAMING_SNAKE_CASE_					      =							sample.to(snake_case__  )

								for i, t in enumerate(scheduler.timesteps  ):
										SCREAMING_SNAKE_CASE_					      =							scheduler.scale_model_input(snake_case__					,							snake_case__  )

										SCREAMING_SNAKE_CASE_					      =							model(snake_case__					,							snake_case__  )

										SCREAMING_SNAKE_CASE_					      =							scheduler.step(snake_case__					,							snake_case__					,							snake_case__  )
										SCREAMING_SNAKE_CASE_					      =							output.prev_sample

								SCREAMING_SNAKE_CASE_					      =							torch.sum(torch.abs(snake_case__  )  )
								SCREAMING_SNAKE_CASE_					      =							torch.mean(torch.abs(snake_case__  )  )

								if torch_device in ["cpu", "mps"]:
										assert abs(result_sum.item() - 20.41_25  ) < 1e-2
										assert abs(result_mean.item() - 0.02_66  ) < 1e-3
								else:
										# CUDA
										assert abs(result_sum.item() - 20.41_25  ) < 1e-2
										assert abs(result_mean.item() - 0.02_66  ) < 1e-3






						def 	__a					(			self	:   Optional[int]  ):

								"""simple docstring"""

								if torch_device == "mps":
										return
								SCREAMING_SNAKE_CASE_					      =							self.scheduler_classes[0]
								SCREAMING_SNAKE_CASE_					      =							self.get_scheduler_config()
								SCREAMING_SNAKE_CASE_					      =							scheduler_class(**snake_case__  )

								scheduler.set_timesteps(self.num_inference_steps					,							device=snake_case__  )

								SCREAMING_SNAKE_CASE_					      =							self.dummy_model()
								SCREAMING_SNAKE_CASE_					      =							self.dummy_sample_deter.to(snake_case__  ) * scheduler.init_noise_sigma

								for t in scheduler.timesteps:
										SCREAMING_SNAKE_CASE_					      =							scheduler.scale_model_input(snake_case__					,							snake_case__  )

										SCREAMING_SNAKE_CASE_					      =							model(snake_case__					,							snake_case__  )

										SCREAMING_SNAKE_CASE_					      =							scheduler.step(snake_case__					,							snake_case__					,							snake_case__  )
										SCREAMING_SNAKE_CASE_					      =							output.prev_sample

								SCREAMING_SNAKE_CASE_					      =							torch.sum(torch.abs(snake_case__  )  )
								SCREAMING_SNAKE_CASE_					      =							torch.mean(torch.abs(snake_case__  )  )

								if str(snake_case__  ).startswith('cpu'  ):
										# The following sum varies between 148 and 156 on mps. Why?
										assert abs(result_sum.item() - 20.41_25  ) < 1e-2
										assert abs(result_mean.item() - 0.02_66  ) < 1e-3
								else:
										# CUDA
										assert abs(result_sum.item() - 20.41_25  ) < 1e-2
										assert abs(result_mean.item() - 0.02_66  ) < 1e-3