

import torch

from diffusers import KDPMaAncestralDiscreteScheduler
from diffusers.utils import torch_device

from .test_schedulers import SchedulerCommonTest


class 					A		(				_UpperCAmelCase					):







    """simple docstring"""





    lowerCamelCase						      =				(KDPMaAncestralDiscreteScheduler,)
    lowerCamelCase						      =				10


    def 		snake_case__	( self					:			int,**lowercase_					:			Any						)->       List[str]:





        '''simple docstring'''







        A__        =  {
            'num_train_timesteps': 1_1_0_0,
            'beta_start': 0.0_001,
            'beta_end': 0.02,
            'beta_schedule': 'linear',
        }

        config.update(**lowercase_						)
        return config


    def 		snake_case__	( self					:			Dict						)->       str:





        '''simple docstring'''







        for timesteps in [1_0, 5_0, 1_0_0, 1_0_0_0]:
            self.check_over_configs(num_train_timesteps=lowercase_						)


    def 		snake_case__	( self					:			Optional[Any]						)->       int:





        '''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=lowercase_,beta_end=lowercase_						)


    def 		snake_case__	( self					:			Union[str, Any]						)->       Optional[Any]:





        '''simple docstring'''







        for schedule in ["linear", "scaled_linear"]:
            self.check_over_configs(beta_schedule=lowercase_						)


    def 		snake_case__	( self					:			Union[str, Any]						)->       Any:





        '''simple docstring'''







        if torch_device == "mps":
            return
        A__        =  self.scheduler_classes[0]
        A__        =  self.get_scheduler_config()
        A__        =  scheduler_class(**lowercase_						)

        scheduler.set_timesteps(self.num_inference_steps						)

        A__        =  torch.manual_seed(0						)

        A__        =  self.dummy_model()
        A__        =  self.dummy_sample_deter * scheduler.init_noise_sigma
        A__        =  sample.to(lowercase_						)

        for i, t in enumerate(scheduler.timesteps						):
            A__        =  scheduler.scale_model_input(lowercase_,lowercase_						)

            A__        =  model(lowercase_,lowercase_						)

            A__        =  scheduler.step(lowercase_,lowercase_,lowercase_,generator=lowercase_						)
            A__        =  output.prev_sample

        A__        =  torch.sum(torch.abs(lowercase_						)						)
        A__        =  torch.mean(torch.abs(lowercase_						)						)

        assert abs(result_sum.item() - 13_849.3_877						) < 1E-2
        assert abs(result_mean.item() - 18.0_331						) < 5E-3


    def 		snake_case__	( self					:			Union[str, Any]						)->       Dict:





        '''simple docstring'''







        for prediction_type in ["epsilon", "v_prediction"]:
            self.check_over_configs(prediction_type=lowercase_						)


    def 		snake_case__	( self					:			List[Any]						)->       str:





        '''simple docstring'''







        if torch_device == "mps":
            return
        A__        =  self.scheduler_classes[0]
        A__        =  self.get_scheduler_config(prediction_type='v_prediction'						)
        A__        =  scheduler_class(**lowercase_						)

        scheduler.set_timesteps(self.num_inference_steps						)

        A__        =  self.dummy_model()
        A__        =  self.dummy_sample_deter * scheduler.init_noise_sigma
        A__        =  sample.to(lowercase_						)

        A__        =  torch.manual_seed(0						)

        for i, t in enumerate(scheduler.timesteps						):
            A__        =  scheduler.scale_model_input(lowercase_,lowercase_						)

            A__        =  model(lowercase_,lowercase_						)

            A__        =  scheduler.step(lowercase_,lowercase_,lowercase_,generator=lowercase_						)
            A__        =  output.prev_sample

        A__        =  torch.sum(torch.abs(lowercase_						)						)
        A__        =  torch.mean(torch.abs(lowercase_						)						)

        assert abs(result_sum.item() - 328.9_970						) < 1E-2
        assert abs(result_mean.item() - 0.4_284						) < 1E-3


    def 		snake_case__	( self					:			str						)->       List[str]:





        '''simple docstring'''







        if torch_device == "mps":
            return
        A__        =  self.scheduler_classes[0]
        A__        =  self.get_scheduler_config()
        A__        =  scheduler_class(**lowercase_						)

        scheduler.set_timesteps(self.num_inference_steps,device=lowercase_						)
        A__        =  torch.manual_seed(0						)

        A__        =  self.dummy_model()
        A__        =  self.dummy_sample_deter.to(lowercase_						) * scheduler.init_noise_sigma

        for t in scheduler.timesteps:
            A__        =  scheduler.scale_model_input(lowercase_,lowercase_						)

            A__        =  model(lowercase_,lowercase_						)

            A__        =  scheduler.step(lowercase_,lowercase_,lowercase_,generator=lowercase_						)
            A__        =  output.prev_sample

        A__        =  torch.sum(torch.abs(lowercase_						)						)
        A__        =  torch.mean(torch.abs(lowercase_						)						)

        assert abs(result_sum.item() - 13_849.3_818						) < 1E-1
        assert abs(result_mean.item() - 18.0_331						) < 1E-3




import unittest

from cer import CER


lowercase_									=    CER()


class 					A		(				unittest.TestCase					):







    """simple docstring"""





    def 		snake_case__	( self					:			str						)->       Dict:





        '''simple docstring'''







        A__        =  ['White House']
        A__        =  ['white house']
        # S = 2, D = 0, I = 0, N = 11, CER = 2 / 11
        A__        =  cer.compute(predictions=lowercase_,references=lowercase_						)
        self.assertTrue(abs(char_error_rate - 0.1_818_181_818						) < 1E-6						)


    def 		snake_case__	( self					:			str						)->       Dict:





        '''simple docstring'''







        A__        =  ['were wolf']
        A__        =  ['werewolf']
        # S = 0, D = 0, I = 1, N = 9, CER = 1 / 9
        A__        =  cer.compute(predictions=lowercase_,references=lowercase_						)
        self.assertTrue(abs(char_error_rate - 0.1_111_111						) < 1E-6						)

        A__        =  ['werewolf']
        A__        =  ['weae     wolf']
        # S = 1, D = 1, I = 0, N = 8, CER = 0.25
        A__        =  cer.compute(predictions=lowercase_,references=lowercase_						)
        self.assertTrue(abs(char_error_rate - 0.25						) < 1E-6						)

        # consecutive whitespaces case 1
        A__        =  ['were wolf']
        A__        =  ['were               wolf']
        # S = 0, D = 0, I = 0, N = 9, CER = 0
        A__        =  cer.compute(predictions=lowercase_,references=lowercase_						)
        self.assertTrue(abs(char_error_rate - 0.0						) < 1E-6						)

        # consecutive whitespaces case 2
        A__        =  ['were   wolf']
        A__        =  ['were               wolf']
        # S = 0, D = 0, I = 0, N = 9, CER = 0
        A__        =  cer.compute(predictions=lowercase_,references=lowercase_						)
        self.assertTrue(abs(char_error_rate - 0.0						) < 1E-6						)


    def 		snake_case__	( self					:			int						)->       str:





        '''simple docstring'''







        A__        =  ['werewolf']
        A__        =  ['weaewolf']
        # S = 1, D = 0, I = 0, N = 8, CER = 0.125
        A__        =  cer.compute(predictions=lowercase_,references=lowercase_						)
        self.assertTrue(abs(char_error_rate - 0.125						) < 1E-6						)


    def 		snake_case__	( self					:			Optional[int]						)->       Optional[int]:





        '''simple docstring'''







        A__        =  ['werewolf']
        A__        =  ['wereawolf']
        # S = 0, D = 1, I = 0, N = 8, CER = 0.125
        A__        =  cer.compute(predictions=lowercase_,references=lowercase_						)
        self.assertTrue(abs(char_error_rate - 0.125						) < 1E-6						)


    def 		snake_case__	( self					:			List[Any]						)->       Optional[Any]:





        '''simple docstring'''







        A__        =  ['werewolf']
        A__        =  ['wereolf']
        # S = 0, D = 0, I = 1, N = 8, CER = 0.125
        A__        =  cer.compute(predictions=lowercase_,references=lowercase_						)
        self.assertTrue(abs(char_error_rate - 0.125						) < 1E-6						)


    def 		snake_case__	( self					:			str						)->       Tuple:





        '''simple docstring'''







        A__        =  ['werewolf']
        A__        =  cer.compute(predictions=lowercase_,references=lowercase_						)
        self.assertEqual(lowercase_,0.0						)


    def 		snake_case__	( self					:			Optional[int]						)->       Union[str, Any]:





        '''simple docstring'''







        A__        =  ['werewolf', 'I am your father']
        A__        =  cer.compute(predictions=lowercase_,references=lowercase_						)
        self.assertEqual(lowercase_,0.0						)

        A__        =  ['werewolf', 'I am your father', 'doge']
        A__        =  ['werxwolf', 'I       am your father', 'doge']
        # S = 1, D = 0, I = 0, N = 28, CER = 1 / 28
        A__        =  cer.compute(predictions=lowercase_,references=lowercase_						)
        self.assertTrue(abs(char_error_rate - 0.03_571_428						) < 1E-6						)


    def 		snake_case__	( self					:			List[str]						)->       Union[str, Any]:





        '''simple docstring'''







        A__        =  ['My hovercraft', 'is full of eels']
        A__        =  ['My hovercraft is full', ' of eels']
        # S = 0, D = 0, I = 2, N = 28, CER = 2 / 28
        # whitespace at the front of " of eels" will be strip during preporcessing
        # so need to insert 2 whitespaces
        A__        =  cer.compute(predictions=lowercase_,references=lowercase_,concatenate_texts=lowercase_						)
        self.assertTrue(abs(char_error_rate - 0.071_428						) < 1E-6						)


    def 		snake_case__	( self					:			Dict						)->       List[str]:





        '''simple docstring'''







        A__        =  ['我能吞下玻璃而不伤身体']
        A__        =  [' 能吞虾玻璃而 不霜身体啦']
        # S = 3, D = 2, I = 0, N = 11, CER = 5 / 11
        A__        =  cer.compute(predictions=lowercase_,references=lowercase_						)
        self.assertTrue(abs(char_error_rate - 0.4_545_454_545						) < 1E-6						)

        A__        =  ['我能吞下玻璃', '而不伤身体']
        A__        =  ['我    能 吞 下 玻 璃', '而不伤身体']
        # S = 0, D = 5, I = 0, N = 11, CER = 5 / 11
        A__        =  cer.compute(predictions=lowercase_,references=lowercase_						)
        self.assertTrue(abs(char_error_rate - 0.454_545_454_545						) < 1E-6						)

        A__        =  ['我能吞下玻璃而不伤身体']
        A__        =  cer.compute(predictions=lowercase_,references=lowercase_						)
        self.assertFalse(lowercase_,0.0						)


    def 		snake_case__	( self					:			Any						)->       List[str]:





        '''simple docstring'''







        A__        =  ['']
        A__        =  ['Hypothesis']
        with self.assertRaises(lowercase_						):
            cer.compute(predictions=lowercase_,references=lowercase_						)


if __name__ == "__main__":
     unittest.main()

