
import re
import string

import numpy as np

import datasets


lowercase   =	'''
Returns the rate at which the input predicted strings exactly match their references, ignoring any strings input as part of the regexes_to_ignore list.
'''

lowercase   =	'''
Args:
    predictions: List of predicted texts.
    references: List of reference texts.
    regexes_to_ignore: List, defaults to None. Regex expressions of characters to
        ignore when calculating the exact matches. Note: these regexes are removed
        from the input data before the changes based on the options below (e.g. ignore_case,
        ignore_punctuation, ignore_numbers) are applied.
    ignore_case: Boolean, defaults to False. If true, turns everything
        to lowercase so that capitalization differences are ignored.
    ignore_punctuation: Boolean, defaults to False. If true, removes all punctuation before
        comparing predictions and references.
    ignore_numbers: Boolean, defaults to False. If true, removes all punctuation before
        comparing predictions and references.
Returns:
    exact_match: Dictionary containing exact_match rate. Possible values are between 0.0 and 100.0, inclusive.
Examples:
    >>> exact_match = datasets.load_metric("exact_match")
    >>> refs = ["the cat", "theater", "YELLING", "agent007"]
    >>> preds = ["cat?", "theater", "yelling", "agent"]
    >>> results = exact_match.compute(references=refs, predictions=preds)
    >>> print(round(results["exact_match"], 1))
    25.0

    >>> exact_match = datasets.load_metric("exact_match")
    >>> refs = ["the cat", "theater", "YELLING", "agent007"]
    >>> preds = ["cat?", "theater", "yelling", "agent"]
    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell"], ignore_case=True, ignore_punctuation=True)
    >>> print(round(results["exact_match"], 1))
    50.0


    >>> exact_match = datasets.load_metric("exact_match")
    >>> refs = ["the cat", "theater", "YELLING", "agent007"]
    >>> preds = ["cat?", "theater", "yelling", "agent"]
    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell", "YELL"], ignore_case=True, ignore_punctuation=True)
    >>> print(round(results["exact_match"], 1))
    75.0

    >>> exact_match = datasets.load_metric("exact_match")
    >>> refs = ["the cat", "theater", "YELLING", "agent007"]
    >>> preds = ["cat?", "theater", "yelling", "agent"]
    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell", "YELL"], ignore_case=True, ignore_punctuation=True, ignore_numbers=True)
    >>> print(round(results["exact_match"], 1))
    100.0

    >>> exact_match = datasets.load_metric("exact_match")
    >>> refs = ["The cat sat on the mat.", "Theaters are great.", "It\'s like comparing oranges and apples."]
    >>> preds = ["The cat sat on the mat?", "Theaters are great.", "It\'s like comparing apples and oranges."]
    >>> results = exact_match.compute(references=refs, predictions=preds)
    >>> print(round(results["exact_match"], 1))
    33.3

'''

lowercase   =	'''
'''





@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION  ,		_KWARGS_DESCRIPTION							)
class    __A(					datasets.Metric							):

					def  lowercase__   (						self       :  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       :  Any ,       __UpperCamelCase       :  Dict ,       __UpperCamelCase       :  List[str] ,       __UpperCamelCase       :  Dict=None ,       __UpperCamelCase       :  Union[str, Any]=False ,       __UpperCamelCase       :  Optional[Any]=False ,       __UpperCamelCase       :  Optional[Any]=False ,       ):
												if regexes_to_ignore is not None:
																			for s in regexes_to_ignore:
																										lowerCamelCase_					=       np.array([re.sub(__UpperCamelCase ,       """""" ,       __UpperCamelCase ) for x in predictions] )
																										lowerCamelCase_					=       np.array([re.sub(__UpperCamelCase ,       """""" ,       __UpperCamelCase ) for x in references] )
												else:
																			lowerCamelCase_					=       np.asarray(__UpperCamelCase )
																			lowerCamelCase_					=       np.asarray(__UpperCamelCase )

												if ignore_case:
																			lowerCamelCase_					=       np.char.lower(__UpperCamelCase )
																			lowerCamelCase_					=       np.char.lower(__UpperCamelCase )

												if ignore_punctuation:
																			lowerCamelCase_					=       string.punctuation.maketrans("""""" ,       """""" ,       string.punctuation )
																			lowerCamelCase_					=       np.char.translate(__UpperCamelCase ,       table=__UpperCamelCase )
																			lowerCamelCase_					=       np.char.translate(__UpperCamelCase ,       table=__UpperCamelCase )

												if ignore_numbers:
																			lowerCamelCase_					=       string.digits.maketrans("""""" ,       """""" ,       string.digits )
																			lowerCamelCase_					=       np.char.translate(__UpperCamelCase ,       table=__UpperCamelCase )
																			lowerCamelCase_					=       np.char.translate(__UpperCamelCase ,       table=__UpperCamelCase )

												lowerCamelCase_					=       predictions == references

												return {"exact_match": np.mean(__UpperCamelCase ) * 1_0_0}







import torch

from diffusers import KDPMaDiscreteScheduler
from diffusers.utils import torch_device

from .test_schedulers import SchedulerCommonTest





class    __A(					UpperCAmelCase							):
					SCREAMING_SNAKE_CASE           =     (KDPMaDiscreteScheduler,)
					SCREAMING_SNAKE_CASE           =     1_0

					def  lowercase__   (						self       :  str ,       **__UpperCamelCase       :  Optional[int] ):
												lowerCamelCase_					=       {
												    """num_train_timesteps""": 1_1_0_0,
												    """beta_start""": 0.0001,
												    """beta_end""": 0.02,
												    """beta_schedule""": """linear""",
												}

												config.update(**__UpperCamelCase )
												return config

					def  lowercase__   (						self       :  Optional[Any] ):
												for timesteps in [1_0, 5_0, 1_0_0, 1_0_0_0]:
																			self.check_over_configs(num_train_timesteps=__UpperCamelCase )

					def  lowercase__   (						self       :  Dict ):
												for beta_start, beta_end in zip([0.00001, 0.0001, 0.001] ,       [0.0002, 0.002, 0.02] ):
																			self.check_over_configs(beta_start=__UpperCamelCase ,       beta_end=__UpperCamelCase )

					def  lowercase__   (						self       :  Union[str, Any] ):
												for schedule in ["linear", "scaled_linear"]:
																			self.check_over_configs(beta_schedule=__UpperCamelCase )

					def  lowercase__   (						self       :  List[str] ):
												for prediction_type in ["epsilon", "v_prediction"]:
																			self.check_over_configs(prediction_type=__UpperCamelCase )

					def  lowercase__   (						self       :  Optional[int] ):
												lowerCamelCase_					=       self.scheduler_classes[0]
												lowerCamelCase_					=       self.get_scheduler_config(prediction_type="""v_prediction""" )
												lowerCamelCase_					=       scheduler_class(**__UpperCamelCase )

												scheduler.set_timesteps(self.num_inference_steps )

												lowerCamelCase_					=       self.dummy_model()
												lowerCamelCase_					=       self.dummy_sample_deter * scheduler.init_noise_sigma
												lowerCamelCase_					=       sample.to(__UpperCamelCase )

												for i, t in enumerate(scheduler.timesteps ):
																			lowerCamelCase_					=       scheduler.scale_model_input(__UpperCamelCase ,       __UpperCamelCase )

																			lowerCamelCase_					=       model(__UpperCamelCase ,       __UpperCamelCase )

																			lowerCamelCase_					=       scheduler.step(__UpperCamelCase ,       __UpperCamelCase ,       __UpperCamelCase )
																			lowerCamelCase_					=       output.prev_sample

												lowerCamelCase_					=       torch.sum(torch.abs(__UpperCamelCase ) )
												lowerCamelCase_					=       torch.mean(torch.abs(__UpperCamelCase ) )

												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.0002 ) < 1E-3

					def  lowercase__   (						self       :  List[Any] ):
												if torch_device == "mps":
																			return
												lowerCamelCase_					=       self.scheduler_classes[0]
												lowerCamelCase_					=       self.get_scheduler_config()
												lowerCamelCase_					=       scheduler_class(**__UpperCamelCase )

												scheduler.set_timesteps(self.num_inference_steps )

												lowerCamelCase_					=       self.dummy_model()
												lowerCamelCase_					=       self.dummy_sample_deter * scheduler.init_noise_sigma
												lowerCamelCase_					=       sample.to(__UpperCamelCase )

												for i, t in enumerate(scheduler.timesteps ):
																			lowerCamelCase_					=       scheduler.scale_model_input(__UpperCamelCase ,       __UpperCamelCase )

																			lowerCamelCase_					=       model(__UpperCamelCase ,       __UpperCamelCase )

																			lowerCamelCase_					=       scheduler.step(__UpperCamelCase ,       __UpperCamelCase ,       __UpperCamelCase )
																			lowerCamelCase_					=       output.prev_sample

												lowerCamelCase_					=       torch.sum(torch.abs(__UpperCamelCase ) )
												lowerCamelCase_					=       torch.mean(torch.abs(__UpperCamelCase ) )

												if torch_device in ["cpu", "mps"]:
																			assert abs(result_sum.item() - 20.4125 ) < 1E-2
																			assert abs(result_mean.item() - 0.0266 ) < 1E-3
												else:
																			# CUDA
																			assert abs(result_sum.item() - 20.4125 ) < 1E-2
																			assert abs(result_mean.item() - 0.0266 ) < 1E-3



					def  lowercase__   (						self       :  Optional[int] ):
												if torch_device == "mps":
																			return
												lowerCamelCase_					=       self.scheduler_classes[0]
												lowerCamelCase_					=       self.get_scheduler_config()
												lowerCamelCase_					=       scheduler_class(**__UpperCamelCase )

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

												lowerCamelCase_					=       self.dummy_model()
												lowerCamelCase_					=       self.dummy_sample_deter.to(__UpperCamelCase ) * scheduler.init_noise_sigma

												for t in scheduler.timesteps:
																			lowerCamelCase_					=       scheduler.scale_model_input(__UpperCamelCase ,       __UpperCamelCase )

																			lowerCamelCase_					=       model(__UpperCamelCase ,       __UpperCamelCase )

																			lowerCamelCase_					=       scheduler.step(__UpperCamelCase ,       __UpperCamelCase ,       __UpperCamelCase )
																			lowerCamelCase_					=       output.prev_sample

												lowerCamelCase_					=       torch.sum(torch.abs(__UpperCamelCase ) )
												lowerCamelCase_					=       torch.mean(torch.abs(__UpperCamelCase ) )

												if str(__UpperCamelCase ).startswith("""cpu""" ):
																			# The following sum varies between 148 and 156 on mps. Why?
																			assert abs(result_sum.item() - 20.4125 ) < 1E-2
																			assert abs(result_mean.item() - 0.0266 ) < 1E-3
												else:
																			# CUDA
																			assert abs(result_sum.item() - 20.4125 ) < 1E-2
																			assert abs(result_mean.item() - 0.0266 ) < 1E-3





