





'''simple docstring'''






import unittest

from diffusers.models.unet_ad_blocks import *  # noqa F403
from diffusers.utils import torch_device

from .test_unet_blocks_common import UNetBlockTesterMixin
class 					__snake_case  (					__SCREAMING_SNAKE_CASE		,				unittest.TestCase							):






   '''simple docstring'''





   lowerCamelCase__    							=      DownBlockaD  # noqa F405
   lowerCamelCase__    							=      '''down'''

   def 		__UpperCamelCase						(							self       ):
    snake_case__     :					List[Any]    =  [-0.0232, -0.9869, 0.8054, -0.0637, -0.1688, -1.4264, 0.4470, -1.3394, 0.0904]
    super().test_output(__SCREAMING_SNAKE_CASE       )



class 					__snake_case  (					__SCREAMING_SNAKE_CASE		,				unittest.TestCase							):






   '''simple docstring'''





   lowerCamelCase__    							=      ResnetDownsampleBlockaD  # noqa F405
   lowerCamelCase__    							=      '''down'''

   def 		__UpperCamelCase						(							self       ):
    snake_case__     :					int    =  [0.0710, 0.2410, -0.7320, -1.0757, -1.1343, 0.3540, -0.0133, -0.2576, 0.0948]
    super().test_output(__SCREAMING_SNAKE_CASE       )



class 					__snake_case  (					__SCREAMING_SNAKE_CASE		,				unittest.TestCase							):






   '''simple docstring'''





   lowerCamelCase__    							=      AttnDownBlockaD  # noqa F405
   lowerCamelCase__    							=      '''down'''

   def 		__UpperCamelCase						(							self       ):
    snake_case__     :					str    =  [0.0636, 0.8964, -0.6234, -1.0131, 0.0844, 0.4935, 0.3437, 0.0911, -0.2957]
    super().test_output(__SCREAMING_SNAKE_CASE       )



class 					__snake_case  (					__SCREAMING_SNAKE_CASE		,				unittest.TestCase							):






   '''simple docstring'''





   lowerCamelCase__    							=      CrossAttnDownBlockaD  # noqa F405
   lowerCamelCase__    							=      '''down'''

   def 		__UpperCamelCase						(							self       ):
    snake_case__  ,							snake_case__     :					Optional[int]    =  super().prepare_init_args_and_inputs_for_common()
    snake_case__     :					List[str]    =  3_2
    return init_dict, inputs_dict


   def 		__UpperCamelCase						(							self       ):
    snake_case__     :					int    =  [0.2238, -0.7396, -0.2255, -0.3829, 0.1925, 1.1665, 0.0603, -0.7295, 0.1983]
    super().test_output(__SCREAMING_SNAKE_CASE       )



class 					__snake_case  (					__SCREAMING_SNAKE_CASE		,				unittest.TestCase							):






   '''simple docstring'''





   lowerCamelCase__    							=      SimpleCrossAttnDownBlockaD  # noqa F405
   lowerCamelCase__    							=      '''down'''

   @property
   def 		__UpperCamelCase						(							self       ):
    return super().get_dummy_input(include_encoder_hidden_states=__SCREAMING_SNAKE_CASE       )

   def 		__UpperCamelCase						(							self       ):
    snake_case__  ,							snake_case__     :					Optional[Any]    =  super().prepare_init_args_and_inputs_for_common()
    snake_case__     :					List[str]    =  3_2
    return init_dict, inputs_dict


   @unittest.skipIf(torch_device == """mps"""	,		"""MPS result is not consistent"""       )
   def 		__UpperCamelCase						(							self       ):
    snake_case__     :					List[Any]    =  [0.7921, -0.0992, -0.1962, -0.7695, -0.4242, 0.7804, 0.4737, 0.2765, 0.3338]
    super().test_output(__SCREAMING_SNAKE_CASE       )



class 					__snake_case  (					__SCREAMING_SNAKE_CASE		,				unittest.TestCase							):






   '''simple docstring'''





   lowerCamelCase__    							=      SkipDownBlockaD  # noqa F405
   lowerCamelCase__    							=      '''down'''

   @property
   def 		__UpperCamelCase						(							self       ):
    return super().get_dummy_input(include_skip_sample=__SCREAMING_SNAKE_CASE       )


   def 		__UpperCamelCase						(							self       ):
    snake_case__     :					Optional[Any]    =  [-0.0845, -0.2087, -0.2465, 0.0971, 0.1900, -0.0484, 0.2664, 0.4179, 0.5069]
    super().test_output(__SCREAMING_SNAKE_CASE       )



class 					__snake_case  (					__SCREAMING_SNAKE_CASE		,				unittest.TestCase							):






   '''simple docstring'''





   lowerCamelCase__    							=      AttnSkipDownBlockaD  # noqa F405
   lowerCamelCase__    							=      '''down'''

   @property
   def 		__UpperCamelCase						(							self       ):
    return super().get_dummy_input(include_skip_sample=__SCREAMING_SNAKE_CASE       )


   def 		__UpperCamelCase						(							self       ):
    snake_case__     :					int    =  [0.5539, 0.1609, 0.4924, 0.0537, -0.1995, 0.4050, 0.0979, -0.2721, -0.0642]
    super().test_output(__SCREAMING_SNAKE_CASE       )



class 					__snake_case  (					__SCREAMING_SNAKE_CASE		,				unittest.TestCase							):






   '''simple docstring'''





   lowerCamelCase__    							=      DownEncoderBlockaD  # noqa F405
   lowerCamelCase__    							=      '''down'''

   @property
   def 		__UpperCamelCase						(							self       ):
    return super().get_dummy_input(include_temb=__SCREAMING_SNAKE_CASE       )

   def 		__UpperCamelCase						(							self       ):
    snake_case__     :					int    =  {
        """in_channels""": 3_2,
        """out_channels""": 3_2,
    }
    snake_case__     :					Tuple    =  self.dummy_input
    return init_dict, inputs_dict


   def 		__UpperCamelCase						(							self       ):
    snake_case__     :					Dict    =  [1.1102, 0.5302, 0.4872, -0.0023, -0.8042, 0.0483, -0.3489, -0.5632, 0.7626]
    super().test_output(__SCREAMING_SNAKE_CASE       )



class 					__snake_case  (					__SCREAMING_SNAKE_CASE		,				unittest.TestCase							):






   '''simple docstring'''





   lowerCamelCase__    							=      AttnDownEncoderBlockaD  # noqa F405
   lowerCamelCase__    							=      '''down'''

   @property
   def 		__UpperCamelCase						(							self       ):
    return super().get_dummy_input(include_temb=__SCREAMING_SNAKE_CASE       )

   def 		__UpperCamelCase						(							self       ):
    snake_case__     :					Optional[Any]    =  {
        """in_channels""": 3_2,
        """out_channels""": 3_2,
    }
    snake_case__     :					Optional[int]    =  self.dummy_input
    return init_dict, inputs_dict


   def 		__UpperCamelCase						(							self       ):
    snake_case__     :					Dict    =  [0.8966, -0.1486, 0.8568, 0.8141, -0.9046, -0.1342, -0.0972, -0.7417, 0.1538]
    super().test_output(__SCREAMING_SNAKE_CASE       )



class 					__snake_case  (					__SCREAMING_SNAKE_CASE		,				unittest.TestCase							):






   '''simple docstring'''





   lowerCamelCase__    							=      UNetMidBlockaD  # noqa F405
   lowerCamelCase__    							=      '''mid'''

   def 		__UpperCamelCase						(							self       ):
    snake_case__     :					Dict    =  {
        """in_channels""": 3_2,
        """temb_channels""": 1_2_8,
    }
    snake_case__     :					Optional[Any]    =  self.dummy_input
    return init_dict, inputs_dict


   def 		__UpperCamelCase						(							self       ):
    snake_case__     :					Optional[int]    =  [-0.1062, 1.7248, 0.3494, 1.4569, -0.0910, -1.2421, -0.9984, 0.6736, 1.0028]
    super().test_output(__SCREAMING_SNAKE_CASE       )



class 					__snake_case  (					__SCREAMING_SNAKE_CASE		,				unittest.TestCase							):






   '''simple docstring'''





   lowerCamelCase__    							=      UNetMidBlockaDCrossAttn  # noqa F405
   lowerCamelCase__    							=      '''mid'''

   def 		__UpperCamelCase						(							self       ):
    snake_case__  ,							snake_case__     :					int    =  super().prepare_init_args_and_inputs_for_common()
    snake_case__     :					Any    =  3_2
    return init_dict, inputs_dict


   def 		__UpperCamelCase						(							self       ):
    snake_case__     :					List[str]    =  [0.0187, 2.4220, 0.4484, 1.1203, -0.6121, -1.5122, -0.8270, 0.7851, 1.8335]
    super().test_output(__SCREAMING_SNAKE_CASE       )



class 					__snake_case  (					__SCREAMING_SNAKE_CASE		,				unittest.TestCase							):






   '''simple docstring'''





   lowerCamelCase__    							=      UNetMidBlockaDSimpleCrossAttn  # noqa F405
   lowerCamelCase__    							=      '''mid'''

   @property
   def 		__UpperCamelCase						(							self       ):
    return super().get_dummy_input(include_encoder_hidden_states=__SCREAMING_SNAKE_CASE       )

   def 		__UpperCamelCase						(							self       ):
    snake_case__  ,							snake_case__     :					Optional[int]    =  super().prepare_init_args_and_inputs_for_common()
    snake_case__     :					Tuple    =  3_2
    return init_dict, inputs_dict


   def 		__UpperCamelCase						(							self       ):
    snake_case__     :					str    =  [0.7143, 1.9974, 0.5448, 1.3977, 0.1282, -1.1237, -1.4238, 0.5530, 0.8880]
    super().test_output(__SCREAMING_SNAKE_CASE       )



class 					__snake_case  (					__SCREAMING_SNAKE_CASE		,				unittest.TestCase							):






   '''simple docstring'''





   lowerCamelCase__    							=      UpBlockaD  # noqa F405
   lowerCamelCase__    							=      '''up'''

   @property
   def 		__UpperCamelCase						(							self       ):
    return super().get_dummy_input(include_res_hidden_states_tuple=__SCREAMING_SNAKE_CASE       )


   def 		__UpperCamelCase						(							self       ):
    snake_case__     :					Any    =  [-0.2041, -0.4165, -0.3022, 0.0041, -0.6628, -0.7053, 0.1928, -0.0325, 0.0523]
    super().test_output(__SCREAMING_SNAKE_CASE       )



class 					__snake_case  (					__SCREAMING_SNAKE_CASE		,				unittest.TestCase							):






   '''simple docstring'''





   lowerCamelCase__    							=      ResnetUpsampleBlockaD  # noqa F405
   lowerCamelCase__    							=      '''up'''

   @property
   def 		__UpperCamelCase						(							self       ):
    return super().get_dummy_input(include_res_hidden_states_tuple=__SCREAMING_SNAKE_CASE       )


   def 		__UpperCamelCase						(							self       ):
    snake_case__     :					Tuple    =  [0.2287, 0.3549, -0.1346, 0.4797, -0.1715, -0.9649, 0.7305, -0.5864, -0.6244]
    super().test_output(__SCREAMING_SNAKE_CASE       )



class 					__snake_case  (					__SCREAMING_SNAKE_CASE		,				unittest.TestCase							):






   '''simple docstring'''





   lowerCamelCase__    							=      CrossAttnUpBlockaD  # noqa F405
   lowerCamelCase__    							=      '''up'''

   @property
   def 		__UpperCamelCase						(							self       ):
    return super().get_dummy_input(include_res_hidden_states_tuple=__SCREAMING_SNAKE_CASE       )

   def 		__UpperCamelCase						(							self       ):
    snake_case__  ,							snake_case__     :					Optional[int]    =  super().prepare_init_args_and_inputs_for_common()
    snake_case__     :					Dict    =  3_2
    return init_dict, inputs_dict


   def 		__UpperCamelCase						(							self       ):
    snake_case__     :					Dict    =  [-0.1403, -0.3515, -0.0420, -0.1425, 0.3167, 0.5094, -0.2181, 0.5931, 0.5582]
    super().test_output(__SCREAMING_SNAKE_CASE       )



class 					__snake_case  (					__SCREAMING_SNAKE_CASE		,				unittest.TestCase							):






   '''simple docstring'''





   lowerCamelCase__    							=      SimpleCrossAttnUpBlockaD  # noqa F405
   lowerCamelCase__    							=      '''up'''

   @property
   def 		__UpperCamelCase						(							self       ):
    return super().get_dummy_input(include_res_hidden_states_tuple=__SCREAMING_SNAKE_CASE	,		include_encoder_hidden_states=__SCREAMING_SNAKE_CASE       )

   def 		__UpperCamelCase						(							self       ):
    snake_case__  ,							snake_case__     :					Union[str, Any]    =  super().prepare_init_args_and_inputs_for_common()
    snake_case__     :					str    =  3_2
    return init_dict, inputs_dict


   def 		__UpperCamelCase						(							self       ):
    snake_case__     :					Optional[int]    =  [0.2645, 0.1480, 0.0909, 0.8044, -0.9758, -0.9083, 0.0994, -1.1453, -0.7402]
    super().test_output(__SCREAMING_SNAKE_CASE       )



class 					__snake_case  (					__SCREAMING_SNAKE_CASE		,				unittest.TestCase							):






   '''simple docstring'''





   lowerCamelCase__    							=      AttnUpBlockaD  # noqa F405
   lowerCamelCase__    							=      '''up'''

   @property
   def 		__UpperCamelCase						(							self       ):
    return super().get_dummy_input(include_res_hidden_states_tuple=__SCREAMING_SNAKE_CASE       )


   @unittest.skipIf(torch_device == """mps"""	,		"""MPS result is not consistent"""       )
   def 		__UpperCamelCase						(							self       ):
    snake_case__     :					int    =  [0.0979, 0.1326, 0.0021, 0.0659, 0.2249, 0.0059, 0.1132, 0.5952, 0.1033]
    super().test_output(__SCREAMING_SNAKE_CASE       )



class 					__snake_case  (					__SCREAMING_SNAKE_CASE		,				unittest.TestCase							):






   '''simple docstring'''





   lowerCamelCase__    							=      SkipUpBlockaD  # noqa F405
   lowerCamelCase__    							=      '''up'''

   @property
   def 		__UpperCamelCase						(							self       ):
    return super().get_dummy_input(include_res_hidden_states_tuple=__SCREAMING_SNAKE_CASE       )


   def 		__UpperCamelCase						(							self       ):
    snake_case__     :					List[Any]    =  [-0.0893, -0.1234, -0.1506, -0.0332, 0.0123, -0.0211, 0.0566, 0.0143, 0.0362]
    super().test_output(__SCREAMING_SNAKE_CASE       )



class 					__snake_case  (					__SCREAMING_SNAKE_CASE		,				unittest.TestCase							):






   '''simple docstring'''





   lowerCamelCase__    							=      AttnSkipUpBlockaD  # noqa F405
   lowerCamelCase__    							=      '''up'''

   @property
   def 		__UpperCamelCase						(							self       ):
    return super().get_dummy_input(include_res_hidden_states_tuple=__SCREAMING_SNAKE_CASE       )


   def 		__UpperCamelCase						(							self       ):
    snake_case__     :					Optional[int]    =  [0.0361, 0.0617, 0.2787, -0.0350, 0.0342, 0.3421, -0.0843, 0.0913, 0.3015]
    super().test_output(__SCREAMING_SNAKE_CASE       )



class 					__snake_case  (					__SCREAMING_SNAKE_CASE		,				unittest.TestCase							):






   '''simple docstring'''





   lowerCamelCase__    							=      UpDecoderBlockaD  # noqa F405
   lowerCamelCase__    							=      '''up'''

   @property
   def 		__UpperCamelCase						(							self       ):
    return super().get_dummy_input(include_temb=__SCREAMING_SNAKE_CASE       )

   def 		__UpperCamelCase						(							self       ):
    snake_case__     :					List[str]    =  {"""in_channels""": 3_2, """out_channels""": 3_2}

    snake_case__     :					Tuple    =  self.dummy_input
    return init_dict, inputs_dict


   def 		__UpperCamelCase						(							self       ):
    snake_case__     :					List[str]    =  [0.4404, 0.1998, -0.9886, -0.3320, -0.3128, -0.7034, -0.6955, -0.2338, -0.3137]
    super().test_output(__SCREAMING_SNAKE_CASE       )



class 					__snake_case  (					__SCREAMING_SNAKE_CASE		,				unittest.TestCase							):






   '''simple docstring'''





   lowerCamelCase__    							=      AttnUpDecoderBlockaD  # noqa F405
   lowerCamelCase__    							=      '''up'''

   @property
   def 		__UpperCamelCase						(							self       ):
    return super().get_dummy_input(include_temb=__SCREAMING_SNAKE_CASE       )

   def 		__UpperCamelCase						(							self       ):
    snake_case__     :					Optional[int]    =  {"""in_channels""": 3_2, """out_channels""": 3_2}

    snake_case__     :					int    =  self.dummy_input
    return init_dict, inputs_dict


   def 		__UpperCamelCase						(							self       ):
    snake_case__     :					int    =  [0.6738, 0.4491, 0.1055, 1.0710, 0.7316, 0.3339, 0.3352, 0.1023, 0.3568]
    super().test_output(__SCREAMING_SNAKE_CASE       )











'''simple docstring'''




import torch

from diffusers import UnCLIPScheduler

from .test_schedulers import SchedulerCommonTest




class      UpperCamelCase__					(					lowercase_			):




					"""simple docstring"""
					SCREAMING_SNAKE_CASE__				=	(UnCLIPScheduler,)


					def lowerCamelCase_			(						self				:			List[str]      ,						**lowerCamelCase_				:			List[Any]						):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE :				List[Any]		=			{
							    """num_train_timesteps""": 10_00,
							    """variance_type""": """fixed_small_log""",
							    """clip_sample""": True,
							    """clip_sample_range""": 1.0,
							    """prediction_type""": """epsilon""",
							}

							config.update(**lowerCamelCase_						)
							return config


					def lowerCamelCase_			(						self				:			List[Any]						):

							'''simple docstring'''



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


					def lowerCamelCase_			(						self				:			str						):

							'''simple docstring'''



							for variance in ["fixed_small_log", "learned_range"]:
									self.check_over_configs(variance_type=lowerCamelCase_						)


					def lowerCamelCase_			(						self				:			List[Any]						):

							'''simple docstring'''



							for clip_sample in [True, False]:
									self.check_over_configs(clip_sample=lowerCamelCase_						)


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

							'''simple docstring'''



							for clip_sample_range in [1, 5, 10, 20]:
									self.check_over_configs(clip_sample_range=lowerCamelCase_						)


					def lowerCamelCase_			(						self				:			List[Any]						):

							'''simple docstring'''



							for prediction_type in ["epsilon", "sample"]:
									self.check_over_configs(prediction_type=lowerCamelCase_						)


					def lowerCamelCase_			(						self				:			List[Any]						):

							'''simple docstring'''



							for time_step in [0, 5_00, 9_99]:
									for prev_timestep in [None, 5, 1_00, 2_50, 5_00, 7_50]:
											if prev_timestep is not None and prev_timestep >= time_step:
													continue

											self.check_over_forward(time_step=lowerCamelCase_      ,						prev_timestep=lowerCamelCase_						)


					def lowerCamelCase_			(						self				:			List[str]						):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE :				int		=			self.scheduler_classes[0]
							SCREAMING_SNAKE_CASE :				Dict		=			self.get_scheduler_config(variance_type="""fixed_small_log"""						)
							SCREAMING_SNAKE_CASE :				Optional[Any]		=			scheduler_class(**lowerCamelCase_						)

							assert torch.sum(torch.abs(scheduler._get_variance(0						) - 1.0000e-10						)						) < 1e-5
							assert torch.sum(torch.abs(scheduler._get_variance(4_87						) - 0.0_549_625						)						) < 1e-5
							assert torch.sum(torch.abs(scheduler._get_variance(9_99						) - 0.9_994_987						)						) < 1e-5


					def lowerCamelCase_			(						self				:			Optional[Any]						):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE :				Tuple		=			self.scheduler_classes[0]
							SCREAMING_SNAKE_CASE :				Optional[int]		=			self.get_scheduler_config(variance_type="""learned_range"""						)
							SCREAMING_SNAKE_CASE :				List[str]		=			scheduler_class(**lowerCamelCase_						)

							SCREAMING_SNAKE_CASE :				List[str]		=			0.5

							assert scheduler._get_variance(1      ,						predicted_variance=lowerCamelCase_						) - -10.1_712_790 < 1e-5
							assert scheduler._get_variance(4_87      ,						predicted_variance=lowerCamelCase_						) - -5.7_998_052 < 1e-5
							assert scheduler._get_variance(9_99      ,						predicted_variance=lowerCamelCase_						) - -0.0_010_011 < 1e-5


					def lowerCamelCase_			(						self				:			str						):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE :				Tuple		=			self.scheduler_classes[0]
							SCREAMING_SNAKE_CASE :				int		=			self.get_scheduler_config()
							SCREAMING_SNAKE_CASE :				List[Any]		=			scheduler_class(**lowerCamelCase_						)

							SCREAMING_SNAKE_CASE :				Optional[Any]		=			scheduler.timesteps

							SCREAMING_SNAKE_CASE :				Optional[int]		=			self.dummy_model()
							SCREAMING_SNAKE_CASE :				Optional[int]		=			self.dummy_sample_deter
							SCREAMING_SNAKE_CASE :				str		=			torch.manual_seed(0						)

							for i, t in enumerate(lowerCamelCase_						):
									# 1. predict noise residual
									SCREAMING_SNAKE_CASE :				List[str]		=			model(lowerCamelCase_      ,						lowerCamelCase_						)

									# 2. predict previous mean of sample x_t-1
									SCREAMING_SNAKE_CASE :				Optional[int]		=			scheduler.step(lowerCamelCase_      ,						lowerCamelCase_      ,						lowerCamelCase_      ,						generator=lowerCamelCase_						).prev_sample

									SCREAMING_SNAKE_CASE :				Union[str, Any]		=			pred_prev_sample

							SCREAMING_SNAKE_CASE :				Optional[int]		=			torch.sum(torch.abs(lowerCamelCase_						)						)
							SCREAMING_SNAKE_CASE :				int		=			torch.mean(torch.abs(lowerCamelCase_						)						)

							assert abs(result_sum.item() - 252.2_682_495						) < 1e-2
							assert abs(result_mean.item() - 0.3_284_743						) < 1e-3


					def lowerCamelCase_			(						self				:			Optional[Any]						):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE :				Optional[Any]		=			self.scheduler_classes[0]
							SCREAMING_SNAKE_CASE :				Dict		=			self.get_scheduler_config()
							SCREAMING_SNAKE_CASE :				List[str]		=			scheduler_class(**lowerCamelCase_						)

							scheduler.set_timesteps(25						)

							SCREAMING_SNAKE_CASE :				List[str]		=			scheduler.timesteps

							SCREAMING_SNAKE_CASE :				Optional[int]		=			self.dummy_model()
							SCREAMING_SNAKE_CASE :				Tuple		=			self.dummy_sample_deter
							SCREAMING_SNAKE_CASE :				Any		=			torch.manual_seed(0						)

							for i, t in enumerate(lowerCamelCase_						):
									# 1. predict noise residual
									SCREAMING_SNAKE_CASE :				int		=			model(lowerCamelCase_      ,						lowerCamelCase_						)

									if i + 1 == timesteps.shape[0]:
											SCREAMING_SNAKE_CASE :				Union[str, Any]		=			None
									else:
											SCREAMING_SNAKE_CASE :				int		=			timesteps[i + 1]

									# 2. predict previous mean of sample x_t-1
									SCREAMING_SNAKE_CASE :				int		=			scheduler.step(
									    lowerCamelCase_      ,						lowerCamelCase_      ,						lowerCamelCase_      ,						prev_timestep=lowerCamelCase_      ,						generator=lowerCamelCase_						).prev_sample

									SCREAMING_SNAKE_CASE :				Union[str, Any]		=			pred_prev_sample

							SCREAMING_SNAKE_CASE :				Union[str, Any]		=			torch.sum(torch.abs(lowerCamelCase_						)						)
							SCREAMING_SNAKE_CASE :				Union[str, Any]		=			torch.mean(torch.abs(lowerCamelCase_						)						)

							assert abs(result_sum.item() - 258.2_044_983						) < 1e-2
							assert abs(result_mean.item() - 0.3_362_038						) < 1e-3


					def lowerCamelCase_			(						self				:			Dict						):

							'''simple docstring'''



							pass



					def lowerCamelCase_			(						self				:			int						):

							'''simple docstring'''



							pass



