





"""simple docstring"""





import re
import string

import numpy as np

import datasets


_UpperCamelCase							=      '\nReturns the rate at which the input predicted strings exactly match their references, ignoring any strings input as part of the regexes_to_ignore list.\n'

_UpperCamelCase							=      '\nArgs:\n    predictions: List of predicted texts.\n    references: List of reference texts.\n    regexes_to_ignore: List, defaults to None. Regex expressions of characters to\n        ignore when calculating the exact matches. Note: these regexes are removed\n        from the input data before the changes based on the options below (e.g. ignore_case,\n        ignore_punctuation, ignore_numbers) are applied.\n    ignore_case: Boolean, defaults to False. If true, turns everything\n        to lowercase so that capitalization differences are ignored.\n    ignore_punctuation: Boolean, defaults to False. If true, removes all punctuation before\n        comparing predictions and references.\n    ignore_numbers: Boolean, defaults to False. If true, removes all punctuation before\n        comparing predictions and references.\nReturns:\n    exact_match: Dictionary containing exact_match rate. Possible values are between 0.0 and 100.0, inclusive.\nExamples:\n    >>> exact_match = datasets.load_metric("exact_match")\n    >>> refs = ["the cat", "theater", "YELLING", "agent007"]\n    >>> preds = ["cat?", "theater", "yelling", "agent"]\n    >>> results = exact_match.compute(references=refs, predictions=preds)\n    >>> print(round(results["exact_match"], 1))\n    25.0\n\n    >>> exact_match = datasets.load_metric("exact_match")\n    >>> refs = ["the cat", "theater", "YELLING", "agent007"]\n    >>> preds = ["cat?", "theater", "yelling", "agent"]\n    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell"], ignore_case=True, ignore_punctuation=True)\n    >>> print(round(results["exact_match"], 1))\n    50.0\n\n\n    >>> exact_match = datasets.load_metric("exact_match")\n    >>> refs = ["the cat", "theater", "YELLING", "agent007"]\n    >>> preds = ["cat?", "theater", "yelling", "agent"]\n    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell", "YELL"], ignore_case=True, ignore_punctuation=True)\n    >>> print(round(results["exact_match"], 1))\n    75.0\n\n    >>> exact_match = datasets.load_metric("exact_match")\n    >>> refs = ["the cat", "theater", "YELLING", "agent007"]\n    >>> preds = ["cat?", "theater", "yelling", "agent"]\n    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell", "YELL"], ignore_case=True, ignore_punctuation=True, ignore_numbers=True)\n    >>> print(round(results["exact_match"], 1))\n    100.0\n\n    >>> exact_match = datasets.load_metric("exact_match")\n    >>> refs = ["The cat sat on the mat.", "Theaters are great.", "It\'s like comparing oranges and apples."]\n    >>> preds = ["The cat sat on the mat?", "Theaters are great.", "It\'s like comparing apples and oranges."]\n    >>> results = exact_match.compute(references=refs, predictions=preds)\n    >>> print(round(results["exact_match"], 1))\n    33.3\n\n'

_UpperCamelCase							=      '\n'
@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION       ,  _KWARGS_DESCRIPTION   )
class 		SCREAMING_SNAKE_CASE_							(    datasets.Metric   ):
				"""simple docstring"""




				def 					__lowercase  (     self  :List[Any]			):
											return datasets.MetricInfo(
											    description=_DESCRIPTION						,    citation=_CITATION						,    inputs_description=_KWARGS_DESCRIPTION						,    features=datasets.Features(
											        {
											            '''predictions''': datasets.Value('''string'''						,    id='''sequence'''			),
											            '''references''': datasets.Value('''string'''						,    id='''sequence'''			),
											        }			)						,    reference_urls=[]						,    )




				def 					__lowercase  (     self  :Tuple						,    __lowercase  :int						,    __lowercase  :int						,    __lowercase  :Optional[Any]=None						,    __lowercase  :int=False						,    __lowercase  :List[str]=False						,    __lowercase  :Union[str, Any]=False						,    ):
											if regexes_to_ignore is not None:
																		for s in regexes_to_ignore:
																									__lowerCamelCase      :      List[Any]         =np.array([re.sub(__lowercase						,    ''''''						,    __lowercase			) for x in predictions]			)
																									__lowerCamelCase      :      Union[str, Any]         =np.array([re.sub(__lowercase						,    ''''''						,    __lowercase			) for x in references]			)
											else:
																		__lowerCamelCase      :      List[str]         =np.asarray(__lowercase			)
																		__lowerCamelCase      :      int         =np.asarray(__lowercase			)

											if ignore_case:
																		__lowerCamelCase      :      List[Any]         =np.char.lower(__lowercase			)
																		__lowerCamelCase      :      Optional[Any]         =np.char.lower(__lowercase			)

											if ignore_punctuation:
																		__lowerCamelCase      :      List[Any]         =string.punctuation.maketrans(''''''						,    ''''''						,    string.punctuation			)
																		__lowerCamelCase      :      Optional[Any]         =np.char.translate(__lowercase						,    table=__lowercase			)
																		__lowerCamelCase      :      List[str]         =np.char.translate(__lowercase						,    table=__lowercase			)

											if ignore_numbers:
																		__lowerCamelCase      :      int         =string.digits.maketrans(''''''						,    ''''''						,    string.digits			)
																		__lowerCamelCase      :      Union[str, Any]         =np.char.translate(__lowercase						,    table=__lowercase			)
																		__lowerCamelCase      :      Optional[Any]         =np.char.translate(__lowercase						,    table=__lowercase			)

											__lowerCamelCase      :      Dict         =predictions == references

											return {"exact_match": np.mean(__lowercase			) * 100}











"""simple docstring"""





import torch

from diffusers import UnCLIPScheduler

from .test_schedulers import SchedulerCommonTest
class 		SCREAMING_SNAKE_CASE_							(    snake_case__   ):
				"""simple docstring"""
				__snake_case   :       Optional[Any]	 =		(UnCLIPScheduler,)




				def 					__lowercase  (     self  :Any						,    **__lowercase  :str			):
											__lowerCamelCase      :      Optional[int]         ={
											    '''num_train_timesteps''': 1000,
											    '''variance_type''': '''fixed_small_log''',
											    '''clip_sample''': True,
											    '''clip_sample_range''': 1.0,
											    '''prediction_type''': '''epsilon''',
											}

											config.update(**__lowercase			)
											return config




				def 					__lowercase  (     self  :Tuple			):
											for timesteps in [1, 5, 100, 1000]:
																		self.check_over_configs(num_train_timesteps=__lowercase			)




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




				def 					__lowercase  (     self  :List[str]			):
											for clip_sample in [True, False]:
																		self.check_over_configs(clip_sample=__lowercase			)




				def 					__lowercase  (     self  :List[Any]			):
											for clip_sample_range in [1, 5, 10, 20]:
																		self.check_over_configs(clip_sample_range=__lowercase			)




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




				def 					__lowercase  (     self  :Union[str, Any]			):
											for time_step in [0, 500, 999]:
																		for prev_timestep in [None, 5, 100, 250, 500, 750]:
																									if prev_timestep is not None and prev_timestep >= time_step:
																																continue

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




				def 					__lowercase  (     self  :Union[str, Any]			):
											__lowerCamelCase      :      List[Any]         =self.scheduler_classes[0]
											__lowerCamelCase      :      str         =self.get_scheduler_config(variance_type='''fixed_small_log'''			)
											__lowerCamelCase      :      Tuple         =scheduler_class(**__lowercase			)

											assert torch.sum(torch.abs(scheduler._get_variance(0			) - 1.0_0_0_0e-1_0			)			) < 1e-5
											assert torch.sum(torch.abs(scheduler._get_variance(487			) - 0.0549625			)			) < 1e-5
											assert torch.sum(torch.abs(scheduler._get_variance(999			) - 0.9994987			)			) < 1e-5




				def 					__lowercase  (     self  :Optional[Any]			):
											__lowerCamelCase      :      Tuple         =self.scheduler_classes[0]
											__lowerCamelCase      :      Optional[Any]         =self.get_scheduler_config(variance_type='''learned_range'''			)
											__lowerCamelCase      :      Optional[Any]         =scheduler_class(**__lowercase			)

											__lowerCamelCase      :      Optional[int]         =0.5

											assert scheduler._get_variance(1						,    predicted_variance=__lowercase			) - -10.1712790 < 1e-5
											assert scheduler._get_variance(487						,    predicted_variance=__lowercase			) - -5.7998052 < 1e-5
											assert scheduler._get_variance(999						,    predicted_variance=__lowercase			) - -0.0010011 < 1e-5




				def 					__lowercase  (     self  :Optional[Any]			):
											__lowerCamelCase      :      Any         =self.scheduler_classes[0]
											__lowerCamelCase      :      Optional[int]         =self.get_scheduler_config()
											__lowerCamelCase      :      str         =scheduler_class(**__lowercase			)

											__lowerCamelCase      :      Tuple         =scheduler.timesteps

											__lowerCamelCase      :      Any         =self.dummy_model()
											__lowerCamelCase      :      Any         =self.dummy_sample_deter
											__lowerCamelCase      :      List[Any]         =torch.manual_seed(0			)

											for i, t in enumerate(__lowercase			):
																		# 1. predict noise residual
																		__lowerCamelCase      :      Tuple         =model(__lowercase						,    __lowercase			)

																		# 2. predict previous mean of sample x_t-1
																		__lowerCamelCase      :      List[Any]         =scheduler.step(__lowercase						,    __lowercase						,    __lowercase						,    generator=__lowercase			).prev_sample

																		__lowerCamelCase      :      List[Any]         =pred_prev_sample

											__lowerCamelCase      :      Optional[Any]         =torch.sum(torch.abs(__lowercase			)			)
											__lowerCamelCase      :      Optional[int]         =torch.mean(torch.abs(__lowercase			)			)

											assert abs(result_sum.item() - 252.2682495			) < 1e-2
											assert abs(result_mean.item() - 0.3284743			) < 1e-3




				def 					__lowercase  (     self  :int			):
											__lowerCamelCase      :      Optional[Any]         =self.scheduler_classes[0]
											__lowerCamelCase      :      Any         =self.get_scheduler_config()
											__lowerCamelCase      :      Optional[Any]         =scheduler_class(**__lowercase			)

											scheduler.set_timesteps(25			)

											__lowerCamelCase      :      Dict         =scheduler.timesteps

											__lowerCamelCase      :      List[str]         =self.dummy_model()
											__lowerCamelCase      :      List[str]         =self.dummy_sample_deter
											__lowerCamelCase      :      Any         =torch.manual_seed(0			)

											for i, t in enumerate(__lowercase			):
																		# 1. predict noise residual
																		__lowerCamelCase      :      Optional[Any]         =model(__lowercase						,    __lowercase			)

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

																		# 2. predict previous mean of sample x_t-1
																		__lowerCamelCase      :      List[str]         =scheduler.step(
																		    __lowercase						,    __lowercase						,    __lowercase						,    prev_timestep=__lowercase						,    generator=__lowercase			).prev_sample

																		__lowerCamelCase      :      int         =pred_prev_sample

											__lowerCamelCase      :      List[Any]         =torch.sum(torch.abs(__lowercase			)			)
											__lowerCamelCase      :      List[str]         =torch.mean(torch.abs(__lowercase			)			)

											assert abs(result_sum.item() - 258.2044983			) < 1e-2
											assert abs(result_mean.item() - 0.3362038			) < 1e-3




				def 					__lowercase  (     self  :List[str]			):
											pass




				def 					__lowercase  (     self  :Tuple			):
											pass




