
import json
import os
import tempfile
import unittest

from transformers.modelcard import ModelCard





class 						lowercase       (  unittest.TestCase					):
					def lowercase_			(		self    ):
								"""simple docstring"""







								lowerCAmelCase__ :    List[Any]				      =			{
								    '''model_details''': {
								        '''Organization''': '''testing''',
								        '''Model date''': '''today''',
								        '''Model version''': '''v2.1, Developed by Test Corp in 2019.''',
								        '''Architecture''': '''Convolutional Neural Network.''',
								    },
								    '''metrics''': '''BLEU and ROUGE-1''',
								    '''evaluation_data''': {
								        '''Datasets''': {'''BLEU''': '''My-great-dataset-v1''', '''ROUGE-1''': '''My-short-dataset-v2.1'''},
								        '''Preprocessing''': '''See details on https://arxiv.org/pdf/1810.03993.pdf''',
								    },
								    '''training_data''': {
								        '''Dataset''': '''English Wikipedia dump dated 2018-12-01''',
								        '''Preprocessing''': (
								            '''Using SentencePiece vocabulary of size 52k tokens. See details on'''
								            ''' https://arxiv.org/pdf/1810.03993.pdf'''
								        ),
								    },
								    '''quantitative_analyses''': {'''BLEU''': 55.1, '''ROUGE-1''': 76},
								}
					def lowercase_			(		self    ):
								"""simple docstring"""







								lowerCAmelCase__ :    Optional[Any]				      =			ModelCard.from_dict(self.inputs_dict    )
								self.assertTrue(hasattr(SCREAMING_SNAKE_CASE__ ,	'''model_details'''    )    )
								self.assertTrue(hasattr(SCREAMING_SNAKE_CASE__ ,	'''intended_use'''    )    )
								self.assertTrue(hasattr(SCREAMING_SNAKE_CASE__ ,	'''factors'''    )    )
								self.assertTrue(hasattr(SCREAMING_SNAKE_CASE__ ,	'''metrics'''    )    )
								self.assertTrue(hasattr(SCREAMING_SNAKE_CASE__ ,	'''evaluation_data'''    )    )
								self.assertTrue(hasattr(SCREAMING_SNAKE_CASE__ ,	'''training_data'''    )    )
								self.assertTrue(hasattr(SCREAMING_SNAKE_CASE__ ,	'''quantitative_analyses'''    )    )
								self.assertTrue(hasattr(SCREAMING_SNAKE_CASE__ ,	'''ethical_considerations'''    )    )
								self.assertTrue(hasattr(SCREAMING_SNAKE_CASE__ ,	'''caveats_and_recommendations'''    )    )
					def lowercase_			(		self    ):
								"""simple docstring"""







								lowerCAmelCase__ :    Tuple				      =			ModelCard.from_dict(self.inputs_dict    )
								lowerCAmelCase__ :    List[str]				      =			json.loads(modelcard.to_json_string()    )
								for key, value in self.inputs_dict.items():
											self.assertEqual(obj[key] ,	SCREAMING_SNAKE_CASE__    )
					def lowercase_			(		self    ):
								"""simple docstring"""







								lowerCAmelCase__ :    Optional[Any]				      =			ModelCard.from_dict(self.inputs_dict    )

								with tempfile.TemporaryDirectory() as tmpdirname:
											lowerCAmelCase__ :    Tuple				      =			os.path.join(SCREAMING_SNAKE_CASE__ ,	'''modelcard.json'''    )
											model_card_first.to_json_file(SCREAMING_SNAKE_CASE__    )
											lowerCAmelCase__ :    Tuple				      =			ModelCard.from_json_file(SCREAMING_SNAKE_CASE__    )

								self.assertEqual(model_card_second.to_dict() ,	model_card_first.to_dict()    )
					def lowercase_			(		self    ):
								"""simple docstring"""







								lowerCAmelCase__ :    str				      =			ModelCard.from_dict(self.inputs_dict    )

								with tempfile.TemporaryDirectory() as tmpdirname:
											model_card_first.save_pretrained(SCREAMING_SNAKE_CASE__    )
											lowerCAmelCase__ :    Optional[int]				      =			ModelCard.from_pretrained(SCREAMING_SNAKE_CASE__    )

								self.assertEqual(model_card_second.to_dict() ,	model_card_first.to_dict()    )





import torch

from diffusers import HeunDiscreteScheduler
from diffusers.utils import torch_device

from .test_schedulers import SchedulerCommonTest





class 						lowercase       (  __UpperCamelCase					):
					__a					=    (HeunDiscreteScheduler,)
					__a					=    10
					def lowercase_			(		self ,	**SCREAMING_SNAKE_CASE__    ):
								"""simple docstring"""







								lowerCAmelCase__ :    Any				      =			{
								    '''num_train_timesteps''': 1100,
								    '''beta_start''': 0.0_001,
								    '''beta_end''': 0.02,
								    '''beta_schedule''': '''linear''',
								}

								config.update(**SCREAMING_SNAKE_CASE__    )
								return config
					def lowercase_			(		self    ):
								"""simple docstring"""







								for timesteps in [10, 50, 100, 1000]:
											self.check_over_configs(num_train_timesteps=SCREAMING_SNAKE_CASE__    )
					def lowercase_			(		self    ):
								"""simple docstring"""







								for beta_start, beta_end in zip([0.00_001, 0.0_001, 0.001] ,	[0.0_002, 0.002, 0.02]    ):
											self.check_over_configs(beta_start=SCREAMING_SNAKE_CASE__ ,	beta_end=SCREAMING_SNAKE_CASE__    )
					def lowercase_			(		self    ):
								"""simple docstring"""







								for schedule in ["linear", "scaled_linear", "exp"]:
											self.check_over_configs(beta_schedule=SCREAMING_SNAKE_CASE__    )
					def lowercase_			(		self    ):
								"""simple docstring"""







								for clip_sample_range in [1.0, 2.0, 3.0]:
											self.check_over_configs(clip_sample_range=SCREAMING_SNAKE_CASE__ ,	clip_sample=SCREAMING_SNAKE_CASE__    )
					def lowercase_			(		self    ):
								"""simple docstring"""







								for prediction_type in ["epsilon", "v_prediction", "sample"]:
											self.check_over_configs(prediction_type=SCREAMING_SNAKE_CASE__    )
					def lowercase_			(		self    ):
								"""simple docstring"""







								lowerCAmelCase__ :    List[str]				      =			self.scheduler_classes[0]
								lowerCAmelCase__ :    Optional[Any]				      =			self.get_scheduler_config()
								lowerCAmelCase__ :    Optional[Any]				      =			scheduler_class(**SCREAMING_SNAKE_CASE__    )

								scheduler.set_timesteps(self.num_inference_steps    )

								lowerCAmelCase__ :    str				      =			self.dummy_model()
								lowerCAmelCase__ :    Optional[int]				      =			self.dummy_sample_deter * scheduler.init_noise_sigma
								lowerCAmelCase__ :    Optional[Any]				      =			sample.to(SCREAMING_SNAKE_CASE__    )

								for i, t in enumerate(scheduler.timesteps    ):
											lowerCAmelCase__ :    List[Any]				      =			scheduler.scale_model_input(SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__    )

											lowerCAmelCase__ :    str				      =			model(SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__    )

											lowerCAmelCase__ :    Tuple				      =			scheduler.step(SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__    )
											lowerCAmelCase__ :    Union[str, Any]				      =			output.prev_sample

								lowerCAmelCase__ :    Any				      =			torch.sum(torch.abs(SCREAMING_SNAKE_CASE__    )    )
								lowerCAmelCase__ :    Union[str, Any]				      =			torch.mean(torch.abs(SCREAMING_SNAKE_CASE__    )    )

								if torch_device in ["cpu", "mps"]:
											assert abs(result_sum.item() - 0.1_233    ) < 1E-2
											assert abs(result_mean.item() - 0.0_002    ) < 1E-3
								else:
											# CUDA
											assert abs(result_sum.item() - 0.1_233    ) < 1E-2
											assert abs(result_mean.item() - 0.0_002    ) < 1E-3
					def lowercase_			(		self    ):
								"""simple docstring"""







								lowerCAmelCase__ :    Optional[Any]				      =			self.scheduler_classes[0]
								lowerCAmelCase__ :    str				      =			self.get_scheduler_config(prediction_type='''v_prediction'''    )
								lowerCAmelCase__ :    Any				      =			scheduler_class(**SCREAMING_SNAKE_CASE__    )

								scheduler.set_timesteps(self.num_inference_steps    )

								lowerCAmelCase__ :    int				      =			self.dummy_model()
								lowerCAmelCase__ :    List[str]				      =			self.dummy_sample_deter * scheduler.init_noise_sigma
								lowerCAmelCase__ :    List[Any]				      =			sample.to(SCREAMING_SNAKE_CASE__    )

								for i, t in enumerate(scheduler.timesteps    ):
											lowerCAmelCase__ :    int				      =			scheduler.scale_model_input(SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__    )

											lowerCAmelCase__ :    Optional[Any]				      =			model(SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__    )

											lowerCAmelCase__ :    Optional[int]				      =			scheduler.step(SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__    )
											lowerCAmelCase__ :    Tuple				      =			output.prev_sample

								lowerCAmelCase__ :    List[Any]				      =			torch.sum(torch.abs(SCREAMING_SNAKE_CASE__    )    )
								lowerCAmelCase__ :    List[str]				      =			torch.mean(torch.abs(SCREAMING_SNAKE_CASE__    )    )

								if torch_device in ["cpu", "mps"]:
											assert abs(result_sum.item() - 4.6934E-07    ) < 1E-2
											assert abs(result_mean.item() - 6.1112E-10    ) < 1E-3
								else:
											# CUDA
											assert abs(result_sum.item() - 4.693_4286_5017_0972E-07    ) < 1E-2
											assert abs(result_mean.item() - 0.0_002    ) < 1E-3
					def lowercase_			(		self    ):
								"""simple docstring"""







								lowerCAmelCase__ :    Optional[int]				      =			self.scheduler_classes[0]
								lowerCAmelCase__ :    Optional[Any]				      =			self.get_scheduler_config()
								lowerCAmelCase__ :    Union[str, Any]				      =			scheduler_class(**SCREAMING_SNAKE_CASE__    )

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

								lowerCAmelCase__ :    Optional[Any]				      =			self.dummy_model()
								lowerCAmelCase__ :    Dict				      =			self.dummy_sample_deter.to(SCREAMING_SNAKE_CASE__    ) * scheduler.init_noise_sigma

								for t in scheduler.timesteps:
											lowerCAmelCase__ :    int				      =			scheduler.scale_model_input(SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__    )

											lowerCAmelCase__ :    Dict				      =			model(SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__    )

											lowerCAmelCase__ :    Any				      =			scheduler.step(SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__    )
											lowerCAmelCase__ :    List[Any]				      =			output.prev_sample

								lowerCAmelCase__ :    Dict				      =			torch.sum(torch.abs(SCREAMING_SNAKE_CASE__    )    )
								lowerCAmelCase__ :    List[str]				      =			torch.mean(torch.abs(SCREAMING_SNAKE_CASE__    )    )

								if str(SCREAMING_SNAKE_CASE__    ).startswith('''cpu'''    ):
											# The following sum varies between 148 and 156 on mps. Why?
											assert abs(result_sum.item() - 0.1_233    ) < 1E-2
											assert abs(result_mean.item() - 0.0_002    ) < 1E-3
								elif str(SCREAMING_SNAKE_CASE__    ).startswith('''mps'''    ):
											# Larger tolerance on mps
											assert abs(result_mean.item() - 0.0_002    ) < 1E-2
								else:
											# CUDA
											assert abs(result_sum.item() - 0.1_233    ) < 1E-2
											assert abs(result_mean.item() - 0.0_002    ) < 1E-3
					def lowercase_			(		self    ):
								"""simple docstring"""







								lowerCAmelCase__ :    Any				      =			self.scheduler_classes[0]
								lowerCAmelCase__ :    Optional[Any]				      =			self.get_scheduler_config()
								lowerCAmelCase__ :    str				      =			scheduler_class(**SCREAMING_SNAKE_CASE__ ,	use_karras_sigmas=SCREAMING_SNAKE_CASE__    )

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

								lowerCAmelCase__ :    str				      =			self.dummy_model()
								lowerCAmelCase__ :    Any				      =			self.dummy_sample_deter.to(SCREAMING_SNAKE_CASE__    ) * scheduler.init_noise_sigma
								lowerCAmelCase__ :    List[Any]				      =			sample.to(SCREAMING_SNAKE_CASE__    )

								for t in scheduler.timesteps:
											lowerCAmelCase__ :    Union[str, Any]				      =			scheduler.scale_model_input(SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__    )

											lowerCAmelCase__ :    Any				      =			model(SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__    )

											lowerCAmelCase__ :    str				      =			scheduler.step(SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__ ,	SCREAMING_SNAKE_CASE__    )
											lowerCAmelCase__ :    List[Any]				      =			output.prev_sample

								lowerCAmelCase__ :    int				      =			torch.sum(torch.abs(SCREAMING_SNAKE_CASE__    )    )
								lowerCAmelCase__ :    Dict				      =			torch.mean(torch.abs(SCREAMING_SNAKE_CASE__    )    )

								assert abs(result_sum.item() - 0.00_015    ) < 1E-2
								assert abs(result_mean.item() - 1.9869_5545_3503_4695E-07    ) < 1E-2



