



"""simple docstring"""
import torch

from diffusers import KDPMaDiscreteScheduler
from diffusers.utils import torch_device

from .test_schedulers import SchedulerCommonTest



class       SCREAMING_SNAKE_CASE__  (					__lowerCAmelCase ):
   __lowerCAmelCase  :   Dict						=						(KDPMaDiscreteScheduler,)
   __lowerCAmelCase  :   Any						=						10

   def 	SCREAMING_SNAKE_CASE     (   self      ,     **_SCREAMING_SNAKE_CASE						)  ->      Optional[Any]:





    '''simple docstring'''




    UpperCAmelCase	:					Any	=	{
        """num_train_timesteps""": 1100,
        """beta_start""": 0.0001,
        """beta_end""": 0.02,
        """beta_schedule""": """linear""",
    }

    config.update(**lowerCAmelCase_						)
    return config

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      List[Any]:





    '''simple docstring'''




    for timesteps in [10, 50, 100, 1000]:
     self.check_over_configs(num_train_timesteps=lowerCAmelCase_						)

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





    '''simple docstring'''




    for beta_start, beta_end in zip([0.0_0001, 0.0001, 0.001]      ,     [0.0002, 0.002, 0.02]						):
     self.check_over_configs(beta_start=lowerCAmelCase_      ,     beta_end=lowerCAmelCase_						)

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





    '''simple docstring'''




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

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





    '''simple docstring'''




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

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





    '''simple docstring'''




    UpperCAmelCase	:					Optional[Any]	=	self.scheduler_classes[0]
    UpperCAmelCase	:					List[Any]	=	self.get_scheduler_config(prediction_type="""v_prediction"""						)
    UpperCAmelCase	:					List[Any]	=	scheduler_class(**lowerCAmelCase_						)

    scheduler.set_timesteps(self.num_inference_steps						)

    UpperCAmelCase	:					int	=	self.dummy_model()
    UpperCAmelCase	:					Optional[int]	=	self.dummy_sample_deter * scheduler.init_noise_sigma
    UpperCAmelCase	:					Optional[Any]	=	sample.to(lowerCAmelCase_						)

    for i, t in enumerate(scheduler.timesteps						):
     UpperCAmelCase	:					Any	=	scheduler.scale_model_input(lowerCAmelCase_      ,     lowerCAmelCase_						)

     UpperCAmelCase	:					int	=	model(lowerCAmelCase_      ,     lowerCAmelCase_						)

     UpperCAmelCase	:					Any	=	scheduler.step(lowerCAmelCase_      ,     lowerCAmelCase_      ,     lowerCAmelCase_						)
     UpperCAmelCase	:					Dict	=	output.prev_sample

    UpperCAmelCase	:					int	=	torch.sum(torch.abs(lowerCAmelCase_						)						)
    UpperCAmelCase	:					Optional[int]	=	torch.mean(torch.abs(lowerCAmelCase_						)						)

    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.693428650170972E-07						) < 1E-2
     assert abs(result_mean.item() - 0.0002						) < 1E-3

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Tuple:





    '''simple docstring'''




    if torch_device == "mps":
     return
    UpperCAmelCase	:					Any	=	self.scheduler_classes[0]
    UpperCAmelCase	:					str	=	self.get_scheduler_config()
    UpperCAmelCase	:					Union[str, Any]	=	scheduler_class(**lowerCAmelCase_						)

    scheduler.set_timesteps(self.num_inference_steps						)

    UpperCAmelCase	:					Union[str, Any]	=	self.dummy_model()
    UpperCAmelCase	:					List[str]	=	self.dummy_sample_deter * scheduler.init_noise_sigma
    UpperCAmelCase	:					Dict	=	sample.to(lowerCAmelCase_						)

    for i, t in enumerate(scheduler.timesteps						):
     UpperCAmelCase	:					List[str]	=	scheduler.scale_model_input(lowerCAmelCase_      ,     lowerCAmelCase_						)

     UpperCAmelCase	:					Any	=	model(lowerCAmelCase_      ,     lowerCAmelCase_						)

     UpperCAmelCase	:					List[str]	=	scheduler.step(lowerCAmelCase_      ,     lowerCAmelCase_      ,     lowerCAmelCase_						)
     UpperCAmelCase	:					Dict	=	output.prev_sample

    UpperCAmelCase	:					Dict	=	torch.sum(torch.abs(lowerCAmelCase_						)						)
    UpperCAmelCase	:					Dict	=	torch.mean(torch.abs(lowerCAmelCase_						)						)

    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 	SCREAMING_SNAKE_CASE     (   self						)  ->      Union[str, Any]:





    '''simple docstring'''




    if torch_device == "mps":
     return
    UpperCAmelCase	:					Union[str, Any]	=	self.scheduler_classes[0]
    UpperCAmelCase	:					Optional[Any]	=	self.get_scheduler_config()
    UpperCAmelCase	:					Any	=	scheduler_class(**lowerCAmelCase_						)

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

    UpperCAmelCase	:					Union[str, Any]	=	self.dummy_model()
    UpperCAmelCase	:					Any	=	self.dummy_sample_deter.to(lowerCAmelCase_						) * scheduler.init_noise_sigma

    for t in scheduler.timesteps:
     UpperCAmelCase	:					List[str]	=	scheduler.scale_model_input(lowerCAmelCase_      ,     lowerCAmelCase_						)

     UpperCAmelCase	:					Any	=	model(lowerCAmelCase_      ,     lowerCAmelCase_						)

     UpperCAmelCase	:					str	=	scheduler.step(lowerCAmelCase_      ,     lowerCAmelCase_      ,     lowerCAmelCase_						)
     UpperCAmelCase	:					int	=	output.prev_sample

    UpperCAmelCase	:					Tuple	=	torch.sum(torch.abs(lowerCAmelCase_						)						)
    UpperCAmelCase	:					List[str]	=	torch.mean(torch.abs(lowerCAmelCase_						)						)

    if str(lowerCAmelCase_						).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

import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_bert import BertTokenizer


_SCREAMING_SNAKE_CASE										=						logging.get_logger(__name__)

_SCREAMING_SNAKE_CASE										=						{'vocab_file': 'vocab.txt', 'tokenizer_file': 'tokenizer.json'}

_SCREAMING_SNAKE_CASE										=						{
    'vocab_file': {
        'bert-base-uncased': 'https://huggingface.co/bert-base-uncased/resolve/main/vocab.txt',
        'bert-large-uncased': 'https://huggingface.co/bert-large-uncased/resolve/main/vocab.txt',
        'bert-base-cased': 'https://huggingface.co/bert-base-cased/resolve/main/vocab.txt',
        'bert-large-cased': 'https://huggingface.co/bert-large-cased/resolve/main/vocab.txt',
        'bert-base-multilingual-uncased': (
            'https://huggingface.co/bert-base-multilingual-uncased/resolve/main/vocab.txt'
        ),
        'bert-base-multilingual-cased': 'https://huggingface.co/bert-base-multilingual-cased/resolve/main/vocab.txt',
        'bert-base-chinese': 'https://huggingface.co/bert-base-chinese/resolve/main/vocab.txt',
        'bert-base-german-cased': 'https://huggingface.co/bert-base-german-cased/resolve/main/vocab.txt',
        'bert-large-uncased-whole-word-masking': (
            'https://huggingface.co/bert-large-uncased-whole-word-masking/resolve/main/vocab.txt'
        ),
        'bert-large-cased-whole-word-masking': (
            'https://huggingface.co/bert-large-cased-whole-word-masking/resolve/main/vocab.txt'
        ),
        'bert-large-uncased-whole-word-masking-finetuned-squad': (
            'https://huggingface.co/bert-large-uncased-whole-word-masking-finetuned-squad/resolve/main/vocab.txt'
        ),
        'bert-large-cased-whole-word-masking-finetuned-squad': (
            'https://huggingface.co/bert-large-cased-whole-word-masking-finetuned-squad/resolve/main/vocab.txt'
        ),
        'bert-base-cased-finetuned-mrpc': (
            'https://huggingface.co/bert-base-cased-finetuned-mrpc/resolve/main/vocab.txt'
        ),
        'bert-base-german-dbmdz-cased': 'https://huggingface.co/bert-base-german-dbmdz-cased/resolve/main/vocab.txt',
        'bert-base-german-dbmdz-uncased': (
            'https://huggingface.co/bert-base-german-dbmdz-uncased/resolve/main/vocab.txt'
        ),
        'TurkuNLP/bert-base-finnish-cased-v1': (
            'https://huggingface.co/TurkuNLP/bert-base-finnish-cased-v1/resolve/main/vocab.txt'
        ),
        'TurkuNLP/bert-base-finnish-uncased-v1': (
            'https://huggingface.co/TurkuNLP/bert-base-finnish-uncased-v1/resolve/main/vocab.txt'
        ),
        'wietsedv/bert-base-dutch-cased': (
            'https://huggingface.co/wietsedv/bert-base-dutch-cased/resolve/main/vocab.txt'
        ),
    },
    'tokenizer_file': {
        'bert-base-uncased': 'https://huggingface.co/bert-base-uncased/resolve/main/tokenizer.json',
        'bert-large-uncased': 'https://huggingface.co/bert-large-uncased/resolve/main/tokenizer.json',
        'bert-base-cased': 'https://huggingface.co/bert-base-cased/resolve/main/tokenizer.json',
        'bert-large-cased': 'https://huggingface.co/bert-large-cased/resolve/main/tokenizer.json',
        'bert-base-multilingual-uncased': (
            'https://huggingface.co/bert-base-multilingual-uncased/resolve/main/tokenizer.json'
        ),
        'bert-base-multilingual-cased': (
            'https://huggingface.co/bert-base-multilingual-cased/resolve/main/tokenizer.json'
        ),
        'bert-base-chinese': 'https://huggingface.co/bert-base-chinese/resolve/main/tokenizer.json',
        'bert-base-german-cased': 'https://huggingface.co/bert-base-german-cased/resolve/main/tokenizer.json',
        'bert-large-uncased-whole-word-masking': (
            'https://huggingface.co/bert-large-uncased-whole-word-masking/resolve/main/tokenizer.json'
        ),
        'bert-large-cased-whole-word-masking': (
            'https://huggingface.co/bert-large-cased-whole-word-masking/resolve/main/tokenizer.json'
        ),
        'bert-large-uncased-whole-word-masking-finetuned-squad': (
            'https://huggingface.co/bert-large-uncased-whole-word-masking-finetuned-squad/resolve/main/tokenizer.json'
        ),
        'bert-large-cased-whole-word-masking-finetuned-squad': (
            'https://huggingface.co/bert-large-cased-whole-word-masking-finetuned-squad/resolve/main/tokenizer.json'
        ),
        'bert-base-cased-finetuned-mrpc': (
            'https://huggingface.co/bert-base-cased-finetuned-mrpc/resolve/main/tokenizer.json'
        ),
        'bert-base-german-dbmdz-cased': (
            'https://huggingface.co/bert-base-german-dbmdz-cased/resolve/main/tokenizer.json'
        ),
        'bert-base-german-dbmdz-uncased': (
            'https://huggingface.co/bert-base-german-dbmdz-uncased/resolve/main/tokenizer.json'
        ),
        'TurkuNLP/bert-base-finnish-cased-v1': (
            'https://huggingface.co/TurkuNLP/bert-base-finnish-cased-v1/resolve/main/tokenizer.json'
        ),
        'TurkuNLP/bert-base-finnish-uncased-v1': (
            'https://huggingface.co/TurkuNLP/bert-base-finnish-uncased-v1/resolve/main/tokenizer.json'
        ),
        'wietsedv/bert-base-dutch-cased': (
            'https://huggingface.co/wietsedv/bert-base-dutch-cased/resolve/main/tokenizer.json'
        ),
    },
}

_SCREAMING_SNAKE_CASE										=						{
    'bert-base-uncased': 512,
    'bert-large-uncased': 512,
    'bert-base-cased': 512,
    'bert-large-cased': 512,
    'bert-base-multilingual-uncased': 512,
    'bert-base-multilingual-cased': 512,
    'bert-base-chinese': 512,
    'bert-base-german-cased': 512,
    'bert-large-uncased-whole-word-masking': 512,
    'bert-large-cased-whole-word-masking': 512,
    'bert-large-uncased-whole-word-masking-finetuned-squad': 512,
    'bert-large-cased-whole-word-masking-finetuned-squad': 512,
    'bert-base-cased-finetuned-mrpc': 512,
    'bert-base-german-dbmdz-cased': 512,
    'bert-base-german-dbmdz-uncased': 512,
    'TurkuNLP/bert-base-finnish-cased-v1': 512,
    'TurkuNLP/bert-base-finnish-uncased-v1': 512,
    'wietsedv/bert-base-dutch-cased': 512,
}

_SCREAMING_SNAKE_CASE										=						{
    'bert-base-uncased': {'do_lower_case': True},
    'bert-large-uncased': {'do_lower_case': True},
    'bert-base-cased': {'do_lower_case': False},
    'bert-large-cased': {'do_lower_case': False},
    'bert-base-multilingual-uncased': {'do_lower_case': True},
    'bert-base-multilingual-cased': {'do_lower_case': False},
    'bert-base-chinese': {'do_lower_case': False},
    'bert-base-german-cased': {'do_lower_case': False},
    'bert-large-uncased-whole-word-masking': {'do_lower_case': True},
    'bert-large-cased-whole-word-masking': {'do_lower_case': False},
    'bert-large-uncased-whole-word-masking-finetuned-squad': {'do_lower_case': True},
    'bert-large-cased-whole-word-masking-finetuned-squad': {'do_lower_case': False},
    'bert-base-cased-finetuned-mrpc': {'do_lower_case': False},
    'bert-base-german-dbmdz-cased': {'do_lower_case': False},
    'bert-base-german-dbmdz-uncased': {'do_lower_case': True},
    'TurkuNLP/bert-base-finnish-cased-v1': {'do_lower_case': False},
    'TurkuNLP/bert-base-finnish-uncased-v1': {'do_lower_case': True},
    'wietsedv/bert-base-dutch-cased': {'do_lower_case': False},
}



class 				a							(			__lowerCAmelCase       ):







 """simple docstring"""






 lowerCamelCase	:Tuple    			=		VOCAB_FILES_NAMES
 lowerCamelCase	:Union[str, Any]    			=		PRETRAINED_VOCAB_FILES_MAP
 lowerCamelCase	:Dict    			=		PRETRAINED_INIT_CONFIGURATION
 lowerCamelCase	:Optional[Any]    			=		PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
 lowerCamelCase	:Optional[Any]    			=		BertTokenizer



 def __init__(					self		,				lowerCAmelCase_=None		,				lowerCAmelCase_=None		,				lowerCAmelCase_=True		,				lowerCAmelCase_="[UNK]"		,				lowerCAmelCase_="[SEP]"		,				lowerCAmelCase_="[PAD]"		,				lowerCAmelCase_="[CLS]"		,				lowerCAmelCase_="[MASK]"		,				lowerCAmelCase_=True		,				lowerCAmelCase_=None		,				**lowerCAmelCase_		,				)  ->					List[str]:
        super().__init__(
            lowerCAmelCase_		,				tokenizer_file=lowerCAmelCase_		,				do_lower_case=lowerCAmelCase_		,				unk_token=lowerCAmelCase_		,				sep_token=lowerCAmelCase_		,				pad_token=lowerCAmelCase_		,				cls_token=lowerCAmelCase_		,				mask_token=lowerCAmelCase_		,				tokenize_chinese_chars=lowerCAmelCase_		,				strip_accents=lowerCAmelCase_		,				**lowerCAmelCase_		,				)

        _A        =  json.loads(self.backend_tokenizer.normalizer.__getstate__()							)
        if (
            normalizer_state.get("""lowercase"""		,				lowerCAmelCase_							) != do_lower_case
            or normalizer_state.get("""strip_accents"""		,				lowerCAmelCase_							) != strip_accents
            or normalizer_state.get("""handle_chinese_chars"""		,				lowerCAmelCase_							) != tokenize_chinese_chars
        ):
               _A        =  getattr(lowerCAmelCase_		,				normalizer_state.pop("""type"""							)							)
               _A        =  do_lower_case
               _A        =  strip_accents
               _A        =  tokenize_chinese_chars
               _A        =  normalizer_class(**lowerCAmelCase_							)

        _A        =  do_lower_case



 def      UpperCAmelCase							(					self		,				lowerCAmelCase_		,				lowerCAmelCase_=None							)  ->					List[str]:
        _A        =  [self.cls_token_id] + token_ids_a + [self.sep_token_id]

        if token_ids_a:
               output += token_ids_a + [self.sep_token_id]

        return output



 def      UpperCAmelCase							(					self		,				lowerCAmelCase_		,				lowerCAmelCase_ = None							)  ->					List[int]:
        _A        =  [self.sep_token_id]
        _A        =  [self.cls_token_id]
        if token_ids_a is None:
               return len(cls + token_ids_a + sep							) * [0]
        return len(cls + token_ids_a + sep							) * [0] + len(token_ids_a + sep							) * [1]



 def      UpperCAmelCase							(					self		,				lowerCAmelCase_		,				lowerCAmelCase_ = None							)  ->					Tuple[str]:
        _A        =  self._tokenizer.model.save(lowerCAmelCase_		,				name=lowerCAmelCase_							)
        return tuple(lowerCAmelCase_							)




