code: 
  
  
  
  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  				=					logging.getLogger(__name__)
  
  
  
  
  def     UpperCAmelCase__ (							)   -> Any:
    _A           =    argparse.ArgumentParser(description='''Train a unigram tokenizer on the wikitext dataset.'''							)
    parser.add_argument(
        '''--dataset_name'''						,				type=_SCREAMING_SNAKE_CASE						,				default='''wikitext'''						,				help='''Name of the training. Explore datasets at: hf.co/datasets.'''						,				)
    parser.add_argument(
        '''--dataset_config'''						,				type=_SCREAMING_SNAKE_CASE						,				default='''wikitext-103-raw-v1'''						,				help='''Configuration name of the dataset.'''							)
    parser.add_argument(
        '''--batch_size'''						,				type=_SCREAMING_SNAKE_CASE						,				default=1_000						,				help='''Batch size during training.'''						,				)
    parser.add_argument(
        '''--vocab_size'''						,				type=_SCREAMING_SNAKE_CASE						,				default=10_048						,				help='''Size of the desired vocabulary.'''						,				)
    parser.add_argument(
        '''--limit'''						,				default=_SCREAMING_SNAKE_CASE						,				type=_SCREAMING_SNAKE_CASE						,				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     UpperCAmelCase__ (							__snake_case							)   -> Any:
    _A           =    datasets.load_dataset(args.dataset_name						,				args.dataset_config						,				split='''train'''							)
  
    if args.limit is not None:
      _A           =    min(len(_SCREAMING_SNAKE_CASE							)						,				args.limit							)
      _A           =    dataset.select(range(_SCREAMING_SNAKE_CASE							)							)
      logger.info(F'''Limiting the dataset to {args.limit} entries.'''							)
  
    def batch_iterator():
      for i in range(0						,				len(_SCREAMING_SNAKE_CASE							)						,				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=_SCREAMING_SNAKE_CASE							)
    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=_SCREAMING_SNAKE_CASE							)
      new_tokenizer.push_to_hub('''unigram-tokenizer-dataset'''							)
  
  
  if __name__ == "__main__":
      __lowerCamelCase  				=					parse_args()
      main(args)
style_context: 
  
  
  
  def     UpperCAmelCase__ (							__snake_case						,				__snake_case						,				__snake_case						,				__snake_case						,				__snake_case							)   -> None:
    if target == 0:
      answer.append(path.copy()							)
    else:
      for index in range(__snake_case						,				len(__snake_case							)							):
        if target >= candidates[index]:
          path.append(candidates[index]							)
          backtrack(__snake_case						,				__snake_case						,				__snake_case						,				target - candidates[index]						,				__snake_case							)
          path.pop(len(__snake_case							) - 1							)
  
  
  
  
  def     UpperCAmelCase__ (							__snake_case						,				__snake_case							)   -> list:
    _A           =    []  # type: list[int]
    _A           =    []  # type: list[int]
    backtrack(__snake_case						,				__snake_case						,				__snake_case						,				__snake_case						,				0							)
    return answer
  
  
  
  
  def     UpperCAmelCase__ (							)   -> None:
    print(combination_sum([-8, 2.3, 0]						,				1							)							)
  
  
  if __name__ == "__main__":
      import doctest
  
      doctest.testmod()
      main()