


'''simple docstring'''




import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from .tokenization_lxmert import LxmertTokenizer


_a   :   Dict												=   {"vocab_file": "vocab.txt", "tokenizer_file": "tokenizer.json"}

_a   :   Optional[Any]												=   {
    "vocab_file": {
        "unc-nlp/lxmert-base-uncased": "https://huggingface.co/unc-nlp/lxmert-base-uncased/resolve/main/vocab.txt",
    },
    "tokenizer_file": {
        "unc-nlp/lxmert-base-uncased": (
            "https://huggingface.co/unc-nlp/lxmert-base-uncased/resolve/main/tokenizer.json"
        ),
    },
}

_a   :   List[str]												=   {
    "unc-nlp/lxmert-base-uncased": 512,
}

_a   :   Tuple												=   {
    "unc-nlp/lxmert-base-uncased": {"do_lower_case": True},
}




class 			_lowercase (	__lowercase							):
   _SCREAMING_SNAKE_CASE  :  List[Any]          =	VOCAB_FILES_NAMES
   _SCREAMING_SNAKE_CASE  :  Optional[int]          =	PRETRAINED_VOCAB_FILES_MAP
   _SCREAMING_SNAKE_CASE  :  List[Any]          =	PRETRAINED_INIT_CONFIGURATION
   _SCREAMING_SNAKE_CASE  :  Optional[int]          =	PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
   _SCREAMING_SNAKE_CASE  :  Any          =	LxmertTokenizer
   def __init__(						self       :      List[str]       ,   SCREAMING_SNAKE_CASE_       :      int=None       ,   SCREAMING_SNAKE_CASE_       :      Tuple=None       ,   SCREAMING_SNAKE_CASE_       :      Optional[int]=True       ,   SCREAMING_SNAKE_CASE_       :      List[str]="[UNK]"       ,   SCREAMING_SNAKE_CASE_       :      Dict="[SEP]"       ,   SCREAMING_SNAKE_CASE_       :      Any="[PAD]"       ,   SCREAMING_SNAKE_CASE_       :      Union[str, Any]="[CLS]"       ,   SCREAMING_SNAKE_CASE_       :      Union[str, Any]="[MASK]"       ,   SCREAMING_SNAKE_CASE_       :      Any=True       ,   SCREAMING_SNAKE_CASE_       :      int=None       ,   **SCREAMING_SNAKE_CASE_       :      List[Any]       ,   ) ->							List[Any]:
        super().__init__(
            SCREAMING_SNAKE_CASE_       ,   tokenizer_file=SCREAMING_SNAKE_CASE_       ,   do_lower_case=SCREAMING_SNAKE_CASE_       ,   unk_token=SCREAMING_SNAKE_CASE_       ,   sep_token=SCREAMING_SNAKE_CASE_       ,   pad_token=SCREAMING_SNAKE_CASE_       ,   cls_token=SCREAMING_SNAKE_CASE_       ,   mask_token=SCREAMING_SNAKE_CASE_       ,   tokenize_chinese_chars=SCREAMING_SNAKE_CASE_       ,   strip_accents=SCREAMING_SNAKE_CASE_       ,   **SCREAMING_SNAKE_CASE_       ,   )

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

        __snake_case           =						do_lower_case
   def a  (						self       :      List[str]       ,   SCREAMING_SNAKE_CASE_       :      Tuple       ,   SCREAMING_SNAKE_CASE_       :      List[Any]=None      ) ->							List[str]:
        __snake_case           =						[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 a  (						self       :      Optional[Any]       ,   SCREAMING_SNAKE_CASE_       :      List[int]       ,   SCREAMING_SNAKE_CASE_       :      Optional[List[int]] = None      ) ->							List[int]:
        __snake_case           =						[self.sep_token_id]
        __snake_case           =						[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 a  (						self       :      Tuple       ,   SCREAMING_SNAKE_CASE_       :      str       ,   SCREAMING_SNAKE_CASE_       :      Optional[str] = None      ) ->							Tuple[str]:
        __snake_case           =						self._tokenizer.model.save(SCREAMING_SNAKE_CASE_       ,   name=SCREAMING_SNAKE_CASE_      )
        return tuple(SCREAMING_SNAKE_CASE_      )







import torch

from diffusers import KDPMaDiscreteScheduler
from diffusers.utils import torch_device

from .test_schedulers import SchedulerCommonTest






class 						__magic_name__					(							snake_case				):
     UpperCamelCase_	:Dict										=      (KDPMaDiscreteScheduler,)
     UpperCamelCase_	:str										=      1_0






     def 	UpperCAmelCase_				(				self		,						**_lowercase	)->     str:
         UpperCamelCase_			  =						{
             "num_train_timesteps": 1_100,
             "beta_start": 0.0_001,
             "beta_end": 0.02,
             "beta_schedule": "linear",
         }

         config.update(**_lowercase	)
         return config






     def 	UpperCAmelCase_				(				self	)->     Union[str, Any]:
         for timesteps in [10, 50, 100, 1_000]:
             self.check_over_configs(num_train_timesteps=_lowercase	)






     def 	UpperCAmelCase_				(				self	)->     int:
         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 	UpperCAmelCase_				(				self	)->     str:
         for schedule in ["linear", "scaled_linear"]:
             self.check_over_configs(beta_schedule=_lowercase	)






     def 	UpperCAmelCase_				(				self	)->     Any:
         for prediction_type in ["epsilon", "v_prediction"]:
             self.check_over_configs(prediction_type=_lowercase	)






     def 	UpperCAmelCase_				(				self	)->     Optional[int]:
         UpperCamelCase_			  =						self.scheduler_classes[0]
         UpperCamelCase_			  =						self.get_scheduler_config(prediction_type="v_prediction"	)
         UpperCamelCase_			  =						scheduler_class(**_lowercase	)

         scheduler.set_timesteps(self.num_inference_steps	)

         UpperCamelCase_			  =						self.dummy_model()
         UpperCamelCase_			  =						self.dummy_sample_deter * scheduler.init_noise_sigma
         UpperCamelCase_			  =						sample.to(_lowercase	)

         for i, t in enumerate(scheduler.timesteps	):
             UpperCamelCase_			  =						scheduler.scale_model_input(_lowercase		,						_lowercase	)

             UpperCamelCase_			  =						model(_lowercase		,						_lowercase	)

             UpperCamelCase_			  =						scheduler.step(_lowercase		,						_lowercase		,						_lowercase	)
             UpperCamelCase_			  =						output.prev_sample

         UpperCamelCase_			  =						torch.sum(torch.abs(_lowercase	)	)
         UpperCamelCase_			  =						torch.mean(torch.abs(_lowercase	)	)

         if torch_device in ["cpu", "mps"]:
             assert abs(result_sum.item() - 4.6_9_3_4e-0_7	) < 1e-2
             assert abs(result_mean.item() - 6.1_1_1_2e-1_0	) < 1e-3
         else:
             # CUDA
             assert abs(result_sum.item() - 4.6_9_3_4_2_8_6_5_0_1_7_0_9_7_2e-0_7	) < 1e-2
             assert abs(result_mean.item() - 0.0_002	) < 1e-3






     def 	UpperCAmelCase_				(				self	)->     Dict:
         if torch_device == "mps":
             return
         UpperCamelCase_			  =						self.scheduler_classes[0]
         UpperCamelCase_			  =						self.get_scheduler_config()
         UpperCamelCase_			  =						scheduler_class(**_lowercase	)

         scheduler.set_timesteps(self.num_inference_steps	)

         UpperCamelCase_			  =						self.dummy_model()
         UpperCamelCase_			  =						self.dummy_sample_deter * scheduler.init_noise_sigma
         UpperCamelCase_			  =						sample.to(_lowercase	)

         for i, t in enumerate(scheduler.timesteps	):
             UpperCamelCase_			  =						scheduler.scale_model_input(_lowercase		,						_lowercase	)

             UpperCamelCase_			  =						model(_lowercase		,						_lowercase	)

             UpperCamelCase_			  =						scheduler.step(_lowercase		,						_lowercase		,						_lowercase	)
             UpperCamelCase_			  =						output.prev_sample

         UpperCamelCase_			  =						torch.sum(torch.abs(_lowercase	)	)
         UpperCamelCase_			  =						torch.mean(torch.abs(_lowercase	)	)

         if torch_device in ["cpu", "mps"]:
             assert abs(result_sum.item() - 20.4_125	) < 1e-2
             assert abs(result_mean.item() - 0.0_266	) < 1e-3
         else:
             # CUDA
             assert abs(result_sum.item() - 20.4_125	) < 1e-2
             assert abs(result_mean.item() - 0.0_266	) < 1e-3






     def 	UpperCAmelCase_				(				self	)->     Optional[int]:
         if torch_device == "mps":
             return
         UpperCamelCase_			  =						self.scheduler_classes[0]
         UpperCamelCase_			  =						self.get_scheduler_config()
         UpperCamelCase_			  =						scheduler_class(**_lowercase	)

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

         UpperCamelCase_			  =						self.dummy_model()
         UpperCamelCase_			  =						self.dummy_sample_deter.to(_lowercase	) * scheduler.init_noise_sigma

         for t in scheduler.timesteps:
             UpperCamelCase_			  =						scheduler.scale_model_input(_lowercase		,						_lowercase	)

             UpperCamelCase_			  =						model(_lowercase		,						_lowercase	)

             UpperCamelCase_			  =						scheduler.step(_lowercase		,						_lowercase		,						_lowercase	)
             UpperCamelCase_			  =						output.prev_sample

         UpperCamelCase_			  =						torch.sum(torch.abs(_lowercase	)	)
         UpperCamelCase_			  =						torch.mean(torch.abs(_lowercase	)	)

         if str(_lowercase	).startswith("cpu"	):
             # The following sum varies between 148 and 156 on mps. Why?
             assert abs(result_sum.item() - 20.4_125	) < 1e-2
             assert abs(result_mean.item() - 0.0_266	) < 1e-3
         else:
             # CUDA
             assert abs(result_sum.item() - 20.4_125	) < 1e-2
             assert abs(result_mean.item() - 0.0_266	) < 1e-3
