code: 
  
  import os
  from typing import List, Union
  
  import tensorflow as tf
  from tensorflow_text import BertTokenizer as BertTokenizerLayer
  from tensorflow_text import FastBertTokenizer, ShrinkLongestTrimmer, case_fold_utfa, combine_segments, pad_model_inputs
  
  from .tokenization_bert import BertTokenizer
  
  
  
  
  
  
  class    __A				(							tf.keras.layers.Layer ):
  
  
  
  
  
  
  				def __init__(	self			:    List[Any]    ,				UpperCAmelCase_			:    List    ,				UpperCAmelCase_			:    bool    ,				UpperCAmelCase_			:    int = None    ,				UpperCAmelCase_			:    int = None    ,				UpperCAmelCase_			:    int = None    ,				UpperCAmelCase_			:    str = "longest"    ,				UpperCAmelCase_			:    bool = True    ,				UpperCAmelCase_			:    int = 512    ,				UpperCAmelCase_			:    int = None    ,				UpperCAmelCase_			:    bool = True    ,				UpperCAmelCase_			:    bool = True    ,				UpperCAmelCase_			:    bool = True    ,				**UpperCAmelCase_			:    Dict    ,				):
  								super().__init__()
  								if use_fast_bert_tokenizer:
  												lowerCAmelCase				:			Any    			=      FastBertTokenizer(
  												    UpperCAmelCase_    ,				token_out_type=tf.intaa    ,				lower_case_nfd_strip_accents=UpperCAmelCase_    ,				**UpperCAmelCase_    )
  								else:
  												lowerCAmelCase				:			Union[str, Any]    			=      tf.lookup.StaticVocabularyTable(
  												    tf.lookup.KeyValueTensorInitializer(
  												        keys=UpperCAmelCase_    ,				key_dtype=tf.string    ,				values=tf.range(tf.size(UpperCAmelCase_    ,				out_type=tf.intaa    )    ,				dtype=tf.intaa    )    ,				value_dtype=tf.intaa    ,				)    ,				num_oov_buckets=1    ,				)
  												lowerCAmelCase				:			List[Any]    			=      BertTokenizerLayer(
  												    UpperCAmelCase_    ,				token_out_type=tf.intaa    ,				lower_case=UpperCAmelCase_    ,				**UpperCAmelCase_    )
  
  								lowerCAmelCase				:			Any    			=      vocab_list
  								lowerCAmelCase				:			str    			=      do_lower_case
  								lowerCAmelCase				:			int    			=      cls_token_id or vocab_list.index('[CLS]'    )
  								lowerCAmelCase				:			Any    			=      sep_token_id or vocab_list.index('[SEP]'    )
  								lowerCAmelCase				:			Optional[int]    			=      pad_token_id or vocab_list.index('[PAD]'    )
  								lowerCAmelCase				:			Union[str, Any]    			=      ShrinkLongestTrimmer(max_length - 3    ,				axis=1    )  # Allow room for special tokens
  								lowerCAmelCase				:			Optional[Any]    			=      max_length
  								lowerCAmelCase				:			Optional[int]    			=      padding
  								lowerCAmelCase				:			int    			=      truncation
  								lowerCAmelCase				:			int    			=      pad_to_multiple_of
  								lowerCAmelCase				:			List[Any]    			=      return_token_type_ids
  								lowerCAmelCase				:			str    			=      return_attention_mask
  
  
  
  
  
  
  				@classmethod
  				def 	lowercase__ (	cls			:    Union[str, Any]    ,				UpperCAmelCase_			:    "PreTrainedTokenizerBase"    ,				**UpperCAmelCase_			:    Tuple    ):  # noqa: F821
  								lowerCAmelCase				:			Optional[Any]    			=      kwargs.pop('do_lower_case'    ,				UpperCAmelCase_    )
  								lowerCAmelCase				:			Tuple    			=      tokenizer.do_lower_case if do_lower_case is None else do_lower_case
  								lowerCAmelCase				:			Any    			=      kwargs.pop('cls_token_id'    ,				UpperCAmelCase_    )
  								lowerCAmelCase				:			Optional[Any]    			=      tokenizer.cls_token_id if cls_token_id is None else cls_token_id
  								lowerCAmelCase				:			Dict    			=      kwargs.pop('sep_token_id'    ,				UpperCAmelCase_    )
  								lowerCAmelCase				:			Optional[Any]    			=      tokenizer.sep_token_id if sep_token_id is None else sep_token_id
  								lowerCAmelCase				:			Union[str, Any]    			=      kwargs.pop('pad_token_id'    ,				UpperCAmelCase_    )
  								lowerCAmelCase				:			Optional[int]    			=      tokenizer.pad_token_id if pad_token_id is None else pad_token_id
  
  								lowerCAmelCase				:			int    			=      tokenizer.get_vocab()
  								lowerCAmelCase				:			List[str]    			=      sorted([(wordpiece, idx) for wordpiece, idx in vocab.items()]    ,				key=lambda UpperCAmelCase_    : x[1]    )
  								lowerCAmelCase				:			int    			=      [entry[0] for entry in vocab]
  								return cls(
  								    vocab_list=UpperCAmelCase_    ,				do_lower_case=UpperCAmelCase_    ,				cls_token_id=UpperCAmelCase_    ,				sep_token_id=UpperCAmelCase_    ,				pad_token_id=UpperCAmelCase_    ,				**UpperCAmelCase_    ,				)
  
  
  
  
  
  
  				@classmethod
  				def 	lowercase__ (	cls			:    Any    ,				UpperCAmelCase_			:    Union[str, os.PathLike]    ,				*UpperCAmelCase_			:    Union[str, Any]    ,				**UpperCAmelCase_			:    Union[str, Any]    ):
  								try:
  												lowerCAmelCase				:			Optional[int]    			=      BertTokenizer.from_pretrained(UpperCAmelCase_    ,				*UpperCAmelCase_    ,				**UpperCAmelCase_    )
  								except:  # noqa: E722
  												from .tokenization_bert_fast import BertTokenizerFast
  
  												lowerCAmelCase				:			int    			=      BertTokenizerFast.from_pretrained(UpperCAmelCase_    ,				*UpperCAmelCase_    ,				**UpperCAmelCase_    )
  								return cls.from_tokenizer(UpperCAmelCase_    ,				**UpperCAmelCase_    )
  
  
  
  
  
  
  				def 	lowercase__ (	self			:    Optional[Any]    ,				UpperCAmelCase_			:    Union[str, Any]    ):
  								if self.do_lower_case:
  												lowerCAmelCase				:			Union[str, Any]    			=      case_fold_utfa(UpperCAmelCase_    )
  								lowerCAmelCase				:			Dict    			=      self.tf_tokenizer.tokenize(UpperCAmelCase_    )
  								return tokens.merge_dims(1    ,				-1    )
  
  
  
  
  
  
  				def 	lowercase__ (	self			:    int    ,				UpperCAmelCase_			:    str    ,				UpperCAmelCase_			:    Optional[Any]=None    ,				UpperCAmelCase_			:    Union[str, Any]=None    ,				UpperCAmelCase_			:    Optional[int]=None    ,				UpperCAmelCase_			:    Optional[int]=None    ,				UpperCAmelCase_			:    int=None    ,				UpperCAmelCase_			:    Dict=None    ,				UpperCAmelCase_			:    List[str]=None    ,				):
  								if padding is None:
  												lowerCAmelCase				:			str    			=      self.padding
  								if padding not in ("longest", "max_length"):
  												raise ValueError('Padding must be either \'longest\' or \'max_length\'!'    )
  								if max_length is not None and text_pair is not None:
  												# Because we have to instantiate a Trimmer to do it properly
  												raise ValueError('max_length cannot be overridden at call time when truncating paired texts!'    )
  								if max_length is None:
  												lowerCAmelCase				:			Optional[int]    			=      self.max_length
  								if truncation is None:
  												lowerCAmelCase				:			List[Any]    			=      self.truncation
  								if pad_to_multiple_of is None:
  												lowerCAmelCase				:			int    			=      self.pad_to_multiple_of
  								if return_token_type_ids is None:
  												lowerCAmelCase				:			Dict    			=      self.return_token_type_ids
  								if return_attention_mask is None:
  												lowerCAmelCase				:			Any    			=      self.return_attention_mask
  								if not isinstance(UpperCAmelCase_    ,				tf.Tensor    ):
  												lowerCAmelCase				:			Dict    			=      tf.convert_to_tensor(UpperCAmelCase_    )
  								if text_pair is not None and not isinstance(UpperCAmelCase_    ,				tf.Tensor    ):
  												lowerCAmelCase				:			Union[str, Any]    			=      tf.convert_to_tensor(UpperCAmelCase_    )
  								if text_pair is not None:
  												if text.shape.rank > 1:
  																raise ValueError('text argument should not be multidimensional when a text pair is supplied!'    )
  												if text_pair.shape.rank > 1:
  																raise ValueError('text_pair should not be multidimensional!'    )
  								if text.shape.rank == 2:
  												lowerCAmelCase				:			Optional[Any]    			=      text[:, 0], text[:, 1]
  								lowerCAmelCase				:			Tuple    			=      self.unpaired_tokenize(UpperCAmelCase_    )
  								if text_pair is None:  # Unpaired text
  												if truncation:
  																lowerCAmelCase				:			Optional[Any]    			=      text[:, : max_length - 2]  # Allow room for special tokens
  												lowerCAmelCase				:			Dict    			=      combine_segments(
  												    (text,)    ,				start_of_sequence_id=self.cls_token_id    ,				end_of_segment_id=self.sep_token_id    )
  								else:  # Paired text
  												lowerCAmelCase				:			Dict    			=      self.unpaired_tokenize(UpperCAmelCase_    )
  												if truncation:
  																lowerCAmelCase				:			List[str]    			=      self.paired_trimmer.trim([text, text_pair]    )
  												lowerCAmelCase				:			Dict    			=      combine_segments(
  												    (text, text_pair)    ,				start_of_sequence_id=self.cls_token_id    ,				end_of_segment_id=self.sep_token_id    )
  								if padding == "longest":
  												lowerCAmelCase				:			Dict    			=      input_ids.bounding_shape(axis=1    )
  												if pad_to_multiple_of is not None:
  																# No ceiling division in tensorflow, so we negate floordiv instead
  																lowerCAmelCase				:			Dict    			=      pad_to_multiple_of * (-tf.math.floordiv(-pad_length    ,				UpperCAmelCase_    ))
  								else:
  												lowerCAmelCase				:			Tuple    			=      max_length
  
  								lowerCAmelCase				:			Optional[int]    			=      pad_model_inputs(UpperCAmelCase_    ,				max_seq_length=UpperCAmelCase_    ,				pad_value=self.pad_token_id    )
  								lowerCAmelCase				:			Dict    			=      {'input_ids': input_ids}
  								if return_attention_mask:
  												lowerCAmelCase				:			Optional[Any]    			=      attention_mask
  								if return_token_type_ids:
  												lowerCAmelCase				:			Any    			=      pad_model_inputs(
  												    UpperCAmelCase_    ,				max_seq_length=UpperCAmelCase_    ,				pad_value=self.pad_token_id    )
  												lowerCAmelCase				:			List[Any]    			=      token_type_ids
  								return output
  
  
  
  
  
  
  				def 	lowercase__ (	self			:    Dict    ):
  								return {
  								    "vocab_list": self.vocab_list,
  								    "do_lower_case": self.do_lower_case,
  								    "cls_token_id": self.cls_token_id,
  								    "sep_token_id": self.sep_token_id,
  								    "pad_token_id": self.pad_token_id,
  								}
  
  
  
  
  
  
style_context: 
  
  import torch
  
  from diffusers import KDPMaAncestralDiscreteScheduler
  from diffusers.utils import torch_device
  
  from .test_schedulers import SchedulerCommonTest
  
  
  
  
  
  
  class    __A				(							lowerCAmelCase ):
      lowerCAmelCase_							:		List[str]						=							(KDPMaAncestralDiscreteScheduler,)
      lowerCAmelCase_							:		Dict						=							10
  
  
  
  
  
  
      def 	lowercase__ (	self			:    Any    ,				**UpperCAmelCase_			:    List[Any]    ):
          lowerCAmelCase				:			int    			=      {
              'num_train_timesteps': 1100,
              'beta_start': 0.00_01,
              'beta_end': 0.02,
              'beta_schedule': 'linear',
          }
  
          config.update(**UpperCAmelCase_    )
          return config
  
  
  
  
  
  
      def 	lowercase__ (	self			:    Optional[Any]    ):
          for timesteps in [10, 50, 100, 1000]:
              self.check_over_configs(num_train_timesteps=UpperCAmelCase_    )
  
  
  
  
  
  
      def 	lowercase__ (	self			:    List[str]    ):
          for beta_start, beta_end in zip([0.0_00_01, 0.00_01, 0.0_01]    ,				[0.00_02, 0.0_02, 0.02]    ):
              self.check_over_configs(beta_start=UpperCAmelCase_    ,				beta_end=UpperCAmelCase_    )
  
  
  
  
  
  
      def 	lowercase__ (	self			:    Optional[int]    ):
          for schedule in ["linear", "scaled_linear"]:
              self.check_over_configs(beta_schedule=UpperCAmelCase_    )
  
  
  
  
  
  
      def 	lowercase__ (	self			:    int    ):
          if torch_device == "mps":
              return
          lowerCAmelCase				:			Any    			=      self.scheduler_classes[0]
          lowerCAmelCase				:			Optional[int]    			=      self.get_scheduler_config()
          lowerCAmelCase				:			List[str]    			=      scheduler_class(**UpperCAmelCase_    )
  
          scheduler.set_timesteps(self.num_inference_steps    )
  
          lowerCAmelCase				:			Any    			=      torch.manual_seed(0    )
  
          lowerCAmelCase				:			List[Any]    			=      self.dummy_model()
          lowerCAmelCase				:			List[Any]    			=      self.dummy_sample_deter * scheduler.init_noise_sigma
          lowerCAmelCase				:			Optional[int]    			=      sample.to(UpperCAmelCase_    )
  
          for i, t in enumerate(scheduler.timesteps    ):
              lowerCAmelCase				:			str    			=      scheduler.scale_model_input(UpperCAmelCase_    ,				UpperCAmelCase_    )
  
              lowerCAmelCase				:			Any    			=      model(UpperCAmelCase_    ,				UpperCAmelCase_    )
  
              lowerCAmelCase				:			Optional[Any]    			=      scheduler.step(UpperCAmelCase_    ,				UpperCAmelCase_    ,				UpperCAmelCase_    ,				generator=UpperCAmelCase_    )
              lowerCAmelCase				:			Union[str, Any]    			=      output.prev_sample
  
          lowerCAmelCase				:			List[Any]    			=      torch.sum(torch.abs(UpperCAmelCase_    )    )
          lowerCAmelCase				:			Any    			=      torch.mean(torch.abs(UpperCAmelCase_    )    )
  
          assert abs(result_sum.item() - 1_38_49.38_77    ) < 1E-2
          assert abs(result_mean.item() - 18.03_31    ) < 5E-3
  
  
  
  
  
  
      def 	lowercase__ (	self			:    Tuple    ):
          for prediction_type in ["epsilon", "v_prediction"]:
              self.check_over_configs(prediction_type=UpperCAmelCase_    )
  
  
  
  
  
  
      def 	lowercase__ (	self			:    List[str]    ):
          if torch_device == "mps":
              return
          lowerCAmelCase				:			Optional[Any]    			=      self.scheduler_classes[0]
          lowerCAmelCase				:			List[Any]    			=      self.get_scheduler_config(prediction_type='v_prediction'    )
          lowerCAmelCase				:			Any    			=      scheduler_class(**UpperCAmelCase_    )
  
          scheduler.set_timesteps(self.num_inference_steps    )
  
          lowerCAmelCase				:			Optional[int]    			=      self.dummy_model()
          lowerCAmelCase				:			Any    			=      self.dummy_sample_deter * scheduler.init_noise_sigma
          lowerCAmelCase				:			Optional[int]    			=      sample.to(UpperCAmelCase_    )
  
          lowerCAmelCase				:			Optional[int]    			=      torch.manual_seed(0    )
  
          for i, t in enumerate(scheduler.timesteps    ):
              lowerCAmelCase				:			Dict    			=      scheduler.scale_model_input(UpperCAmelCase_    ,				UpperCAmelCase_    )
  
              lowerCAmelCase				:			Optional[int]    			=      model(UpperCAmelCase_    ,				UpperCAmelCase_    )
  
              lowerCAmelCase				:			Optional[int]    			=      scheduler.step(UpperCAmelCase_    ,				UpperCAmelCase_    ,				UpperCAmelCase_    ,				generator=UpperCAmelCase_    )
              lowerCAmelCase				:			str    			=      output.prev_sample
  
          lowerCAmelCase				:			str    			=      torch.sum(torch.abs(UpperCAmelCase_    )    )
          lowerCAmelCase				:			Tuple    			=      torch.mean(torch.abs(UpperCAmelCase_    )    )
  
          assert abs(result_sum.item() - 3_28.99_70    ) < 1E-2
          assert abs(result_mean.item() - 0.42_84    ) < 1E-3
  
  
  
  
  
  
      def 	lowercase__ (	self			:    Tuple    ):
          if torch_device == "mps":
              return
          lowerCAmelCase				:			str    			=      self.scheduler_classes[0]
          lowerCAmelCase				:			Dict    			=      self.get_scheduler_config()
          lowerCAmelCase				:			List[str]    			=      scheduler_class(**UpperCAmelCase_    )
  
          scheduler.set_timesteps(self.num_inference_steps    ,				device=UpperCAmelCase_    )
          lowerCAmelCase				:			int    			=      torch.manual_seed(0    )
  
          lowerCAmelCase				:			Tuple    			=      self.dummy_model()
          lowerCAmelCase				:			Optional[Any]    			=      self.dummy_sample_deter.to(UpperCAmelCase_    ) * scheduler.init_noise_sigma
  
          for t in scheduler.timesteps:
              lowerCAmelCase				:			str    			=      scheduler.scale_model_input(UpperCAmelCase_    ,				UpperCAmelCase_    )
  
              lowerCAmelCase				:			List[Any]    			=      model(UpperCAmelCase_    ,				UpperCAmelCase_    )
  
              lowerCAmelCase				:			Dict    			=      scheduler.step(UpperCAmelCase_    ,				UpperCAmelCase_    ,				UpperCAmelCase_    ,				generator=UpperCAmelCase_    )
              lowerCAmelCase				:			Dict    			=      output.prev_sample
  
          lowerCAmelCase				:			Union[str, Any]    			=      torch.sum(torch.abs(UpperCAmelCase_    )    )
          lowerCAmelCase				:			str    			=      torch.mean(torch.abs(UpperCAmelCase_    )    )
  
          assert abs(result_sum.item() - 1_38_49.38_18    ) < 1E-1
          assert abs(result_mean.item() - 18.03_31    ) < 1E-3
  
  
  
  
  
  