code: 
  
  
  """simple docstring"""
  
  
  
  
  
  
  
  import argparse
  import logging
  
  import datasets
  from tokenizers import Tokenizer, decoders, normalizers, pre_tokenizers, processors
  from tokenizers.models import Unigram
  from tokenizers.trainers import UnigramTrainer
  
  from transformers import AlbertTokenizerFast
  
  
  lowerCamelCase_     :     int  		=						logging.getLogger(__name__)
  def _A		(		):
  
  
  
  
  
  
  
      """simple docstring"""
      a					=argparse.ArgumentParser(description='''Train a unigram tokenizer on the wikitext dataset.'''	)
      parser.add_argument(
          '''--dataset_name''' ,					type=lowercase ,					default='''wikitext''' ,					help='''Name of the training. Explore datasets at: hf.co/datasets.''' ,					)
      parser.add_argument(
          '''--dataset_config''' ,					type=lowercase ,					default='''wikitext-103-raw-v1''' ,					help='''Configuration name of the dataset.'''	)
      parser.add_argument(
          '''--batch_size''' ,					type=lowercase ,					default=10_00 ,					help='''Batch size during training.''' ,					)
      parser.add_argument(
          '''--vocab_size''' ,					type=lowercase ,					default=1_00_48 ,					help='''Size of the desired vocabulary.''' ,					)
      parser.add_argument(
          '''--limit''' ,					default=lowercase ,					type=lowercase ,					help='''Limit the number of shards (used for debugging).''' ,					)
      parser.add_argument(
          '''--export_to_hub''' ,					action='''store_true''' ,					)
  
      a					=parser.parse_args()
      return args
  def _A		(		lowercase	):
  
  
  
  
  
  
  
      """simple docstring"""
      a					=datasets.load_dataset(args.dataset_name ,					args.dataset_config ,					split='''train'''	)
  
      if args.limit is not None:
          a					=min(len(lowercase	) ,					args.limit	)
          a					=dataset.select(range(lowercase	)	)
          logger.info(f'''Limiting the dataset to {args.limit} entries.'''	)
  
      def batch_iterator():
          for i in range(0 ,					len(lowercase	) ,					args.batch_size	):
              yield dataset[i : i + args.batch_size]["text"]
  
      # Prepare the tokenizer.
      a					=Tokenizer(Unigram()	)
      a					=normalizers.Sequence([normalizers.Replace('''``''' ,					'''\"'''	), normalizers.Replace('''\'\'''' ,					'''\"'''	)]	)
      a					=pre_tokenizers.Metaspace()
  
      # Prepare the trainer.
      a					=UnigramTrainer(
          unk_token='''<unk>''' ,					special_tokens=['''[CLS]''', '''[SEP]''', '''<unk>''', '''<pad>''', '''[MASK]'''] ,					vocab_size=args.vocab_size ,					)
  
      logger.info('''Training the tokenizer.'''	)
      tokenizer.train_from_iterator(batch_iterator() ,					trainer=lowercase	)
      logger.info('''Tokenizer training complete!'''	)
  
      a					=tokenizer.token_to_id('''[CLS]'''	)
      a					=tokenizer.token_to_id('''[SEP]'''	)
      a					=processors.TemplateProcessing(
          single='''[CLS]:0 $A:0 [SEP]:0''' ,					pair='''[CLS]:0 $A:0 [SEP]:0 $B:1 [SEP]:1''' ,					special_tokens=[
              ('''[CLS]''', cls_token_id),
              ('''[SEP]''', sep_token_id),
          ] ,					)
      a					=decoders.Metaspace()
  
      if args.export_to_hub:
          logger.info('''Exporting the trained tokenzier to Hub.'''	)
          a					=AlbertTokenizerFast(tokenizer_object=lowercase	)
          new_tokenizer.push_to_hub('''unigram-tokenizer-dataset'''	)
  
  
  if __name__ == "__main__":
         lowerCamelCase_     :     Any  		=						parse_args()
         main(args)
style_context: 
  
  
  """simple docstring"""
  
  
  
  
  
  
  
  import copy
  
  from transformers.configuration_utils import PretrainedConfig
  from transformers.utils import logging
  
  
  lowerCamelCase_     :     int    		=						logging.get_logger(__name__)
  
  
  
  
  
  
  class    __A       ( _SCREAMING_SNAKE_CASE    ):
  
  
  
  
  
  
   """simple docstring"""
  
  
  
  
   __lowerCAmelCase				      =						"hybrid-clip"
   __lowerCAmelCase				      =						True
  
  
   def __init__(	self				,					__A=512				,					**__A		)      ->  Any:
       super().__init__(**__A		)
  
       if "text_config" not in kwargs:
           raise ValueError('''`text_config` can not be `None`.'''		)
  
       if "vision_config" not in kwargs:
           raise ValueError('''`vision_config` can not be `None`.'''		)
  
       a					=kwargs.pop('''text_config'''		)
       a					=kwargs.pop('''vision_config'''		)
  
       a					=text_config.pop('''model_type'''		)
       a					=vision_config.pop('''model_type'''		)
  
       from transformers import AutoConfig
  
       a					=AutoConfig.for_model(__A				,					**__A		)
  
       if vision_model_type == "clip":
           a					=AutoConfig.for_model(__A				,					**__A		).vision_config
       elif vision_model_type == "clip_vision_model":
           from transformers import CLIPVisionConfig
  
           a					=CLIPVisionConfig(**__A		)
       else:
           a					=AutoConfig.for_model(__A				,					**__A		)
  
       a					=projection_dim
       a					=1.0
  
  
   @classmethod
   def    SCREAMING_SNAKE_CASE							(	cls				,					__A				,					__A				,					**__A		)      ->  Tuple:
       return cls(text_config=text_config.to_dict()				,					vision_config=vision_config.to_dict()				,					**__A		)
  
  
  
  
  
   def    SCREAMING_SNAKE_CASE							(	self		)      ->  Optional[int]:
       a					=copy.deepcopy(self.__dict__		)
       a					=self.text_config.to_dict()
       a					=self.vision_config.to_dict()
       a					=self.__class__.model_type
       return output