





'''simple docstring'''


import re
import string

import numpy as np

import datasets


_SCREAMING_SNAKE_CASE									=				"\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"

_SCREAMING_SNAKE_CASE									=				"\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"

_SCREAMING_SNAKE_CASE									=				"\n"

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




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

     if ignore_case:
         _lowerCAmelCase						      =   np.char.lower(_lowerCAmelCase		)
         _lowerCAmelCase						      =   np.char.lower(_lowerCAmelCase		)

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

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

     _lowerCAmelCase						      =   predictions == references

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









'''simple docstring'''


import tempfile

import torch

from diffusers import (
    DEISMultistepScheduler,
    DPMSolverMultistepScheduler,
    DPMSolverSinglestepScheduler,
    UniPCMultistepScheduler,
)

from .test_schedulers import SchedulerCommonTest

class  lowerCAmelCase_		(		__magic_name__		):
 __lowerCamelCase    :				List[str]								=       (DPMSolverSinglestepScheduler,)
 __lowerCamelCase    :				int								=       (("num_inference_steps", 25),)




 def 				_snake_case (						self      ,  **_lowerCAmelCase		)     ->				Any:
     _lowerCAmelCase						      =   {
         "num_train_timesteps": 1000,
         "beta_start": 0.0001,
         "beta_end": 0.02,
         "beta_schedule": "linear",
         "solver_order": 2,
         "prediction_type": "epsilon",
         "thresholding": False,
         "sample_max_value": 1.0,
         "algorithm_type": "dpmsolver++",
         "solver_type": "midpoint",
         "lambda_min_clipped": -float("inf"		),
         "variance_type": None,
     }

     config.update(**_lowerCAmelCase		)
     return config




 def 				_snake_case (						self      ,  _lowerCAmelCase=0      ,  **_lowerCAmelCase		)     ->				List[Any]:
     _lowerCAmelCase						      =   dict(self.forward_default_kwargs		)
     _lowerCAmelCase						      =   kwargs.pop("num_inference_steps"      ,  _lowerCAmelCase		)
     _lowerCAmelCase						      =   self.dummy_sample
     _lowerCAmelCase						      =   0.1 * sample
     _lowerCAmelCase						      =   [residual + 0.2, residual + 0.15, residual + 0.10]

     for scheduler_class in self.scheduler_classes:
         _lowerCAmelCase						      =   self.get_scheduler_config(**_lowerCAmelCase		)
         _lowerCAmelCase						      =   scheduler_class(**_lowerCAmelCase		)
         scheduler.set_timesteps(_lowerCAmelCase		)
         # copy over dummy past residuals
         _lowerCAmelCase						      =   dummy_past_residuals[: scheduler.config.solver_order]

         with tempfile.TemporaryDirectory() as tmpdirname:
             scheduler.save_config(_lowerCAmelCase		)
             _lowerCAmelCase						      =   scheduler_class.from_pretrained(_lowerCAmelCase		)
             new_scheduler.set_timesteps(_lowerCAmelCase		)
             # copy over dummy past residuals
             _lowerCAmelCase						      =   dummy_past_residuals[: new_scheduler.config.solver_order]

         _lowerCAmelCase      ,      _lowerCAmelCase						      =   sample, sample
         for t in range(_lowerCAmelCase      ,  time_step + scheduler.config.solver_order + 1		):
             _lowerCAmelCase						      =   scheduler.step(_lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  **_lowerCAmelCase		).prev_sample
             _lowerCAmelCase						      =   new_scheduler.step(_lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  **_lowerCAmelCase		).prev_sample

             assert torch.sum(torch.abs(output - new_output		)		) < 1E-5, "Scheduler outputs are not identical"




 def 				_snake_case (						self		)     ->				int:
     pass




 def 				_snake_case (						self      ,  _lowerCAmelCase=0      ,  **_lowerCAmelCase		)     ->				Optional[int]:
     _lowerCAmelCase						      =   dict(self.forward_default_kwargs		)
     _lowerCAmelCase						      =   kwargs.pop("num_inference_steps"      ,  _lowerCAmelCase		)
     _lowerCAmelCase						      =   self.dummy_sample
     _lowerCAmelCase						      =   0.1 * sample
     _lowerCAmelCase						      =   [residual + 0.2, residual + 0.15, residual + 0.10]

     for scheduler_class in self.scheduler_classes:
         _lowerCAmelCase						      =   self.get_scheduler_config()
         _lowerCAmelCase						      =   scheduler_class(**_lowerCAmelCase		)
         scheduler.set_timesteps(_lowerCAmelCase		)

         # copy over dummy past residuals (must be after setting timesteps)
         _lowerCAmelCase						      =   dummy_past_residuals[: scheduler.config.solver_order]

         with tempfile.TemporaryDirectory() as tmpdirname:
             scheduler.save_config(_lowerCAmelCase		)
             _lowerCAmelCase						      =   scheduler_class.from_pretrained(_lowerCAmelCase		)
             # copy over dummy past residuals
             new_scheduler.set_timesteps(_lowerCAmelCase		)

             # copy over dummy past residual (must be after setting timesteps)
             _lowerCAmelCase						      =   dummy_past_residuals[: new_scheduler.config.solver_order]

         _lowerCAmelCase						      =   scheduler.step(_lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  **_lowerCAmelCase		).prev_sample
         _lowerCAmelCase						      =   new_scheduler.step(_lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  **_lowerCAmelCase		).prev_sample

         assert torch.sum(torch.abs(output - new_output		)		) < 1E-5, "Scheduler outputs are not identical"




 def 				_snake_case (						self      ,  _lowerCAmelCase=None      ,  **_lowerCAmelCase		)     ->				Tuple:
     if scheduler is None:
         _lowerCAmelCase						      =   self.scheduler_classes[0]
         _lowerCAmelCase						      =   self.get_scheduler_config(**_lowerCAmelCase		)
         _lowerCAmelCase						      =   scheduler_class(**_lowerCAmelCase		)

     _lowerCAmelCase						      =   self.scheduler_classes[0]
     _lowerCAmelCase						      =   self.get_scheduler_config(**_lowerCAmelCase		)
     _lowerCAmelCase						      =   scheduler_class(**_lowerCAmelCase		)

     _lowerCAmelCase						      =   10
     _lowerCAmelCase						      =   self.dummy_model()
     _lowerCAmelCase						      =   self.dummy_sample_deter
     scheduler.set_timesteps(_lowerCAmelCase		)

     for i, t in enumerate(scheduler.timesteps		):
         _lowerCAmelCase						      =   model(_lowerCAmelCase      ,  _lowerCAmelCase		)
         _lowerCAmelCase						      =   scheduler.step(_lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase		).prev_sample

     return sample




 def 				_snake_case (						self		)     ->				Union[str, Any]:
     _lowerCAmelCase						      =   DPMSolverSinglestepScheduler(**self.get_scheduler_config()		)
     _lowerCAmelCase						      =   50
     _lowerCAmelCase						      =   self.dummy_model()
     _lowerCAmelCase						      =   self.dummy_sample_deter
     scheduler.set_timesteps(_lowerCAmelCase		)

     # make sure that the first t is uneven
     for i, t in enumerate(scheduler.timesteps[3:]		):
         _lowerCAmelCase						      =   model(_lowerCAmelCase      ,  _lowerCAmelCase		)
         _lowerCAmelCase						      =   scheduler.step(_lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase		).prev_sample

     _lowerCAmelCase						      =   torch.mean(torch.abs(_lowerCAmelCase		)		)

     assert abs(result_mean.item() - 0.2574		) < 1E-3




 def 				_snake_case (						self		)     ->				Optional[Any]:
     for timesteps in [25, 50, 100, 999, 1000]:
         self.check_over_configs(num_train_timesteps=_lowerCAmelCase		)




 def 				_snake_case (						self		)     ->				List[Any]:
     # make sure that iterating over schedulers with same config names gives same results
     # for defaults
     _lowerCAmelCase						      =   DPMSolverSinglestepScheduler(**self.get_scheduler_config()		)
     _lowerCAmelCase						      =   self.full_loop(scheduler=_lowerCAmelCase		)
     _lowerCAmelCase						      =   torch.mean(torch.abs(_lowerCAmelCase		)		)

     assert abs(result_mean.item() - 0.2791		) < 1E-3

     _lowerCAmelCase						      =   DEISMultistepScheduler.from_config(scheduler.config		)
     _lowerCAmelCase						      =   DPMSolverMultistepScheduler.from_config(scheduler.config		)
     _lowerCAmelCase						      =   UniPCMultistepScheduler.from_config(scheduler.config		)
     _lowerCAmelCase						      =   DPMSolverSinglestepScheduler.from_config(scheduler.config		)

     _lowerCAmelCase						      =   self.full_loop(scheduler=_lowerCAmelCase		)
     _lowerCAmelCase						      =   torch.mean(torch.abs(_lowerCAmelCase		)		)

     assert abs(result_mean.item() - 0.2791		) < 1E-3




 def 				_snake_case (						self		)     ->				str:
     self.check_over_configs(thresholding=_lowerCAmelCase		)
     for order in [1, 2, 3]:
         for solver_type in ["midpoint", "heun"]:
             for threshold in [0.5, 1.0, 2.0]:
                 for prediction_type in ["epsilon", "sample"]:
                     self.check_over_configs(
                         thresholding=_lowerCAmelCase      ,  prediction_type=_lowerCAmelCase      ,  sample_max_value=_lowerCAmelCase      ,  algorithm_type="dpmsolver++"      ,  solver_order=_lowerCAmelCase      ,  solver_type=_lowerCAmelCase      ,  )




 def 				_snake_case (						self		)     ->				Dict:
     for prediction_type in ["epsilon", "v_prediction"]:
         self.check_over_configs(prediction_type=_lowerCAmelCase		)




 def 				_snake_case (						self		)     ->				Union[str, Any]:
     for algorithm_type in ["dpmsolver", "dpmsolver++"]:
         for solver_type in ["midpoint", "heun"]:
             for order in [1, 2, 3]:
                 for prediction_type in ["epsilon", "sample"]:
                     self.check_over_configs(
                         solver_order=_lowerCAmelCase      ,  solver_type=_lowerCAmelCase      ,  prediction_type=_lowerCAmelCase      ,  algorithm_type=_lowerCAmelCase      ,  )
                     _lowerCAmelCase						      =   self.full_loop(
                         solver_order=_lowerCAmelCase      ,  solver_type=_lowerCAmelCase      ,  prediction_type=_lowerCAmelCase      ,  algorithm_type=_lowerCAmelCase      ,  )
                     assert not torch.isnan(_lowerCAmelCase		).any(), "Samples have nan numbers"




 def 				_snake_case (						self		)     ->				Optional[Any]:
     self.check_over_configs(lower_order_final=_lowerCAmelCase		)
     self.check_over_configs(lower_order_final=_lowerCAmelCase		)




 def 				_snake_case (						self		)     ->				Optional[Any]:
     self.check_over_configs(lambda_min_clipped=-float("inf"		)		)
     self.check_over_configs(lambda_min_clipped=-5.1		)




 def 				_snake_case (						self		)     ->				str:
     self.check_over_configs(variance_type=_lowerCAmelCase		)
     self.check_over_configs(variance_type="learned_range"		)




 def 				_snake_case (						self		)     ->				int:
     for num_inference_steps in [1, 2, 3, 5, 10, 50, 100, 999, 1000]:
         self.check_over_forward(num_inference_steps=_lowerCAmelCase      ,  time_step=0		)




 def 				_snake_case (						self		)     ->				Any:
     _lowerCAmelCase						      =   self.full_loop()
     _lowerCAmelCase						      =   torch.mean(torch.abs(_lowerCAmelCase		)		)

     assert abs(result_mean.item() - 0.2791		) < 1E-3




 def 				_snake_case (						self		)     ->				List[str]:
     _lowerCAmelCase						      =   self.full_loop(use_karras_sigmas=_lowerCAmelCase		)
     _lowerCAmelCase						      =   torch.mean(torch.abs(_lowerCAmelCase		)		)

     assert abs(result_mean.item() - 0.2248		) < 1E-3




 def 				_snake_case (						self		)     ->				Union[str, Any]:
     _lowerCAmelCase						      =   self.full_loop(prediction_type="v_prediction"		)
     _lowerCAmelCase						      =   torch.mean(torch.abs(_lowerCAmelCase		)		)

     assert abs(result_mean.item() - 0.1453		) < 1E-3




 def 				_snake_case (						self		)     ->				Any:
     _lowerCAmelCase						      =   self.full_loop(prediction_type="v_prediction"      ,  use_karras_sigmas=_lowerCAmelCase		)
     _lowerCAmelCase						      =   torch.mean(torch.abs(_lowerCAmelCase		)		)

     assert abs(result_mean.item() - 0.0649		) < 1E-3





 def 				_snake_case (						self		)     ->				List[Any]:
     _lowerCAmelCase						      =   self.scheduler_classes[0]
     _lowerCAmelCase						      =   self.get_scheduler_config(thresholding=_lowerCAmelCase      ,  dynamic_thresholding_ratio=0		)
     _lowerCAmelCase						      =   scheduler_class(**_lowerCAmelCase		)

     _lowerCAmelCase						      =   10
     _lowerCAmelCase						      =   self.dummy_model()
     _lowerCAmelCase						      =   self.dummy_sample_deter.half()
     scheduler.set_timesteps(_lowerCAmelCase		)

     for i, t in enumerate(scheduler.timesteps		):
         _lowerCAmelCase						      =   model(_lowerCAmelCase      ,  _lowerCAmelCase		)
         _lowerCAmelCase						      =   scheduler.step(_lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase		).prev_sample

     assert sample.dtype == torch.floataa


