tokenizers

Tokenizers are used to prepare textual inputs for a model.

Example: Create an AutoTokenizer and use it to tokenize a sentence. This will automatically detect the tokenizer type based on the tokenizer class defined in tokenizer.json.

import { AutoTokenizer } from '@xenova/transformers';

let tokenizer = await AutoTokenizer.from_pretrained('Xenova/bert-base-uncased');
let { input_ids } = await tokenizer('I love transformers!');
// Tensor {
//   data: BigInt64Array(6) [101n, 1045n, 2293n, 19081n, 999n, 102n],
//   dims: [1, 6],
//   type: 'int64',
//   size: 6,
// }

• tokenizers
  • static
    • .TokenizerModel ⇐ Callable
      • new TokenizerModel(config)
      • instance
        • .vocab : Array.<string>
        • .tokens_to_ids : Map.<string, number>
        • .fuse_unk : boolean
        • ._call(tokens) ⇒ Array.<string>
        • .encode(tokens) ⇒ Array.<string>
        • .convert_tokens_to_ids(tokens) ⇒ Array.<number>
        • .convert_ids_to_tokens(ids) ⇒ Array.<string>
      • static
        • .fromConfig(config, ...args) ⇒ TokenizerModel
    • .PreTrainedTokenizer
      • new PreTrainedTokenizer(tokenizerJSON, tokenizerConfig)
      • instance
        • .remove_space : boolean
        • .getToken(...keys) ⇒ string | null
        • .prepare_model_inputs(inputs) ⇒ Object
        • ._call(text, options) ⇒ Object
        • ._encode_text(text) ⇒ Array<string> | null
        • .encode(text, text_pair) ⇒ Array.<number>
        • .batch_decode(batch, decode_args) ⇒ Array.<string>
        • .decode(token_ids, [decode_args]) ⇒ string
        • .decode_single(token_ids, decode_args) ⇒ string
      • static
        • .from_pretrained(pretrained_model_name_or_path, options) ⇒ Promise.<PreTrainedTokenizer>
    • .BertTokenizer ⇐ PreTrainedTokenizer
      • .prepare_model_inputs() : add_token_types
    • .AlbertTokenizer ⇐ PreTrainedTokenizer
      • .prepare_model_inputs() : add_token_types
    • .NllbTokenizer
      • ._build_translation_inputs(raw_inputs, tokenizer_options, generate_kwargs) ⇒ Object
    • .M2M100Tokenizer
      • ._build_translation_inputs(raw_inputs, tokenizer_options, generate_kwargs) ⇒ Object
    • .WhisperTokenizer ⇐ PreTrainedTokenizer
      • ._decode_asr(sequences, options) ⇒ *
      • .decode() : *
      • .get_decoder_prompt_ids(options) ⇒ Array.<Array<number>>
    • .MarianTokenizer
      • new MarianTokenizer(tokenizerJSON, tokenizerConfig)
      • ._encode_text(text) ⇒ Array
    • .AutoTokenizer
      • .from_pretrained(pretrained_model_name_or_path, options) ⇒ Promise.<PreTrainedTokenizer>
  • inner
    • ~WordPieceTokenizer ⇐ TokenizerModel
      • new WordPieceTokenizer(config)
      • .tokens_to_ids : Map.<string, number>
      • .unk_token_id : number
      • .unk_token : string
      • .vocab : Array.<string>
      • .encode(tokens) ⇒ Array.<string>
    • ~Unigram ⇐ TokenizerModel
      • new Unigram(config, moreConfig)
      • .populateNodes(lattice)
      • .tokenize(normalized) ⇒ Array.<string>
      • .encode(tokens) ⇒ Array
    • ~BPE ⇐ TokenizerModel
      • new BPE(config)
      • .cache : Map.<string, Array<string>>
      • .bpe(token) ⇒ Array.<string>
      • .encode(tokens) ⇒ Array.<string>
    • ~LegacyTokenizerModel
      • new LegacyTokenizerModel(config, moreConfig)
      • .tokens_to_ids : Map.<string, number>
    • ~Normalizer
      • new Normalizer(config)
      • instance
        • .normalize(text) ⇒ string
        • ._call(text) ⇒ string
      • static
        • .fromConfig(config) ⇒ Normalizer
    • ~Replace ⇐ Normalizer
      • .normalize(text) ⇒ string
    • ~NFC ⇐ Normalizer
      • .normalize(text) ⇒ string
    • ~NFKD ⇐ Normalizer
      • .normalize(text) ⇒ string
    • ~StripNormalizer
      • .normalize(text) ⇒ string
    • ~StripAccents ⇐ Normalizer
      • .normalize(text) ⇒ string
    • ~Lowercase ⇐ Normalizer
      • .normalize(text) ⇒ string
    • ~Prepend ⇐ Normalizer
      • .normalize(text) ⇒ string
    • ~NormalizerSequence ⇐ Normalizer
      • new NormalizerSequence(config)
      • .normalize(text) ⇒ string
    • ~BertNormalizer ⇐ Normalizer
      • ._tokenize_chinese_chars(text) ⇒ string
      • ._is_chinese_char(cp) ⇒ boolean
      • .stripAccents(text) ⇒ string
      • .normalize(text) ⇒ string
    • ~PreTokenizer ⇐ Callable
      • instance
        • .pre_tokenize_text(text) ⇒ Array.<string>
        • .pre_tokenize(text) ⇒ Array.<string>
        • ._call(text) ⇒ Array.<string>
      • static
        • .fromConfig(config) ⇒ PreTokenizer
    • ~BertPreTokenizer ⇐ PreTokenizer
      • new BertPreTokenizer(config)
      • .pre_tokenize_text(text) ⇒ Array.<string>
    • ~ByteLevelPreTokenizer ⇐ PreTokenizer
      • new ByteLevelPreTokenizer(config)
      • .add_prefix_space : boolean
      • .trim_offsets : boolean
      • .use_regex : boolean
      • .pre_tokenize_text(text) ⇒ Array.<string>
    • ~SplitPreTokenizer ⇐ PreTokenizer
      • new SplitPreTokenizer(config)
      • .pre_tokenize_text(text) ⇒ Array.<string>
    • ~PunctuationPreTokenizer ⇐ PreTokenizer
      • new PunctuationPreTokenizer(config)
      • .pre_tokenize_text(text) ⇒ Array.<string>
    • ~DigitsPreTokenizer ⇐ PreTokenizer
      • new DigitsPreTokenizer(config)
      • .pre_tokenize_text(text) ⇒ Array.<string>
    • ~PostProcessor ⇐ Callable
      • new PostProcessor(config)
      • instance
        • .post_process(tokens, ...args) ⇒ Array
        • ._call(tokens, ...args) ⇒ Array
      • static
        • .fromConfig(config) ⇒ PostProcessor
    • ~RobertaProcessing ⇐ PostProcessor
      • new RobertaProcessing(config)
      • .post_process(tokens, tokens_pair) ⇒ Array.<string>
    • ~TemplateProcessing ⇐ PostProcessor
      • new TemplateProcessing(config)
      • .post_process(tokens, [tokens_pair]) ⇒ Array
    • ~ByteLevelPostProcessor ⇐ PostProcessor
      • .post_process(tokens) ⇒ Array.<string>
    • ~Decoder ⇐ Callable
      • new Decoder(config)
      • instance
        • ._call(tokens) ⇒ string
        • .decode(tokens) ⇒ string
        • .decode_chain(tokens) ⇒ Array.<string>
      • static
        • .fromConfig(config) ⇒ Decoder
    • ~FuseDecoder
      • .decode_chain() : *
    • ~WordPieceDecoder ⇐ Decoder
      • new WordPieceDecoder(config)
      • .decode_chain() : *
    • ~ByteLevelDecoder ⇐ Decoder
      • new ByteLevelDecoder(config)
      • .convert_tokens_to_string(tokens) ⇒ string
      • .decode_chain() : *
    • ~CTCDecoder
      • .convert_tokens_to_string(tokens) ⇒ string
      • .decode_chain() : *
    • ~DecoderSequence ⇐ Decoder
      • new DecoderSequence(config)
      • .decode_chain() : *
    • ~MetaspacePreTokenizer ⇐ PreTokenizer
      • new MetaspacePreTokenizer(config)
      • .pre_tokenize(normalizedTokens) ⇒ Array.<string>
    • ~MetaspaceDecoder ⇐ Decoder
      • new MetaspaceDecoder(config)
      • .decode_chain() : *
    • ~Precompiled ⇐ Normalizer
      • new Precompiled(config)
      • .normalize(text) ⇒ string
    • ~PreTokenizerSequence ⇐ PreTokenizer
      • new PreTokenizerSequence(config)
      • .pre_tokenize_text(text) ⇒ Array.<string>
    • ~WhitespaceSplit ⇐ PreTokenizer
      • new WhitespaceSplit(config)
      • .pre_tokenize_text(text) ⇒ Array.<string>
    • ~BYTES_TO_UNICODE ⇒ Object
    • ~loadTokenizer(pretrained_model_name_or_path, options) ⇒ Promise.<Array>
    • ~createPattern(pattern, invert) ⇒ RegExp | string | null
    • ~clean_up_tokenization(text) ⇒ string
    • ~fuse(arr, value)
    • ~whitespace_split(text) ⇒ Array.<string>
    • ~add_token_types(inputs) ⇒ Object
    • ~PretrainedOptions : *
    • ~BPENode : Object
    • ~SplitDelimiterBehavior : ’removed’ | ’isolated’ | ’mergedWithPrevious’ | ’mergedWithNext’ | ’contiguous’

tokenizers.TokenizerModel ⇐ Callable

Abstract base class for tokenizer models.

Kind: static class of tokenizers
Extends: Callable

• .TokenizerModel ⇐ Callable
  • new TokenizerModel(config)
  • instance
    • .vocab : Array.<string>
    • .tokens_to_ids : Map.<string, number>
    • .fuse_unk : boolean
    • ._call(tokens) ⇒ Array.<string>
    • .encode(tokens) ⇒ Array.<string>
    • .convert_tokens_to_ids(tokens) ⇒ Array.<number>
    • .convert_ids_to_tokens(ids) ⇒ Array.<string>
  • static
    • .fromConfig(config, ...args) ⇒ TokenizerModel

new TokenizerModel(config)

Creates a new instance of TokenizerModel.

tokenizerModel.vocab : Array.<string>

Kind: instance property of TokenizerModel

tokenizerModel.tokens_to_ids : Map.<string, number>

A mapping of tokens to ids.

Kind: instance property of TokenizerModel

tokenizerModel.fuse_unk : boolean

Whether to fuse unknown tokens when encoding. Defaults to false.

Kind: instance property of TokenizerModel

tokenizerModel._call(tokens) ⇒ Array.<string>

Internal function to call the TokenizerModel instance.

Kind: instance method of TokenizerModel
Returns: Array.<string> - The encoded token IDs.

tokenizerModel.encode(tokens) ⇒ Array.<string>

Encodes a list of tokens into a list of token IDs.

Kind: instance method of TokenizerModel
Returns: Array.<string> - The encoded tokens.
Throws:

• Will throw an error if not implemented in a subclass.

tokenizerModel.convert_tokens_to_ids(tokens) ⇒ Array.<number>

Converts a list of tokens into a list of token IDs.

Kind: instance method of TokenizerModel
Returns: Array.<number> - The converted token IDs.

tokenizerModel.convert_ids_to_tokens(ids) ⇒ Array.<string>

Converts a list of token IDs into a list of tokens.

Kind: instance method of TokenizerModel
Returns: Array.<string> - The converted tokens.

TokenizerModel.fromConfig(config, ...args) ⇒ TokenizerModel

Instantiates a new TokenizerModel instance based on the configuration object provided.

Kind: static method of TokenizerModel
Returns: TokenizerModel - A new instance of a TokenizerModel.
Throws:

• Will throw an error if the TokenizerModel type in the config is not recognized.

tokenizers.PreTrainedTokenizer

Kind: static class of tokenizers

• .PreTrainedTokenizer
  • new PreTrainedTokenizer(tokenizerJSON, tokenizerConfig)
  • instance
    • .remove_space : boolean
    • .getToken(...keys) ⇒ string | null
    • .prepare_model_inputs(inputs) ⇒ Object
    • ._call(text, options) ⇒ Object
    • ._encode_text(text) ⇒ Array<string> | null
    • .encode(text, text_pair) ⇒ Array.<number>
    • .batch_decode(batch, decode_args) ⇒ Array.<string>
    • .decode(token_ids, [decode_args]) ⇒ string
    • .decode_single(token_ids, decode_args) ⇒ string
  • static
    • .from_pretrained(pretrained_model_name_or_path, options) ⇒ Promise.<PreTrainedTokenizer>

new PreTrainedTokenizer(tokenizerJSON, tokenizerConfig)

Create a new PreTrainedTokenizer instance.

preTrainedTokenizer.remove_space : boolean

Whether or not to strip the text when tokenizing (removing excess spaces before and after the string).

Kind: instance property of PreTrainedTokenizer

preTrainedTokenizer.getToken(...keys) ⇒ string | null

Returns the value of the first matching key in the tokenizer config object.

Kind: instance method of PreTrainedTokenizer
Returns: string | null - The value associated with the first matching key, or null if no match is found.
Throws:

• Error If an object is found for a matching key and its __type property is not "AddedToken".

preTrainedTokenizer.prepare_model_inputs(inputs) ⇒ Object

This function can be overridden by a subclass to apply additional preprocessing to a model’s input data.

Kind: instance method of PreTrainedTokenizer
Returns: Object - The modified inputs object.

preTrainedTokenizer._call(text, options) ⇒ Object

Encode/tokenize the given text(s).

Kind: instance method of PreTrainedTokenizer
Returns: Object - Object to be passed to the model.

preTrainedTokenizer._encode_text(text) ⇒ Array<string> | null

Encodes a single text using the preprocessor pipeline of the tokenizer.

Kind: instance method of PreTrainedTokenizer
Returns: Array<string> | null - The encoded tokens.

preTrainedTokenizer.encode(text, text_pair) ⇒ Array.<number>

Encodes a single text or a pair of texts using the model’s tokenizer.

Kind: instance method of PreTrainedTokenizer
Returns: Array.<number> - An array of token IDs representing the encoded text(s).

preTrainedTokenizer.batch_decode(batch, decode_args) ⇒ Array.<string>

Decode a batch of tokenized sequences.

Kind: instance method of PreTrainedTokenizer
Returns: Array.<string> - List of decoded sequences.

preTrainedTokenizer.decode(token_ids, [decode_args]) ⇒ string

Decodes a sequence of token IDs back to a string.

Kind: instance method of PreTrainedTokenizer
Returns: string - The decoded string.
Throws:

• Error If `token_ids` is not a non-empty array of integers.

preTrainedTokenizer.decode_single(token_ids, decode_args) ⇒ string

Decode a single list of token ids to a string.

Kind: instance method of PreTrainedTokenizer
Returns: string - The decoded string

PreTrainedTokenizer.from_pretrained(pretrained_model_name_or_path, options) ⇒ Promise.<PreTrainedTokenizer>

Loads a pre-trained tokenizer from the given pretrained_model_name_or_path.

Kind: static method of PreTrainedTokenizer
Returns: Promise.<PreTrainedTokenizer> - A new instance of the PreTrainedTokenizer class.
Throws:

• Error Throws an error if the tokenizer.json or tokenizer_config.json files are not found in the `pretrained_model_name_or_path`.

tokenizers.BertTokenizer ⇐ PreTrainedTokenizer

BertTokenizer is a class used to tokenize text for BERT models.

Kind: static class of tokenizers
Extends: PreTrainedTokenizer

bertTokenizer.prepare_model_inputs() : add_token_types

Kind: instance method of BertTokenizer

tokenizers.AlbertTokenizer ⇐ PreTrainedTokenizer

Albert tokenizer

Kind: static class of tokenizers
Extends: PreTrainedTokenizer

albertTokenizer.prepare_model_inputs() : add_token_types

Kind: instance method of AlbertTokenizer

tokenizers.NllbTokenizer

The NllbTokenizer class is used to tokenize text for NLLB (“No Language Left Behind”) models.

No Language Left Behind (NLLB) is a first-of-its-kind, AI breakthrough project that open-sources models capable of delivering high-quality translations directly between any pair of 200+ languages — including low-resource languages like Asturian, Luganda, Urdu and more. It aims to help people communicate with anyone, anywhere, regardless of their language preferences. For more information, check out their paper.

For a list of supported languages (along with their language codes),

Kind: static class of tokenizers
See: https://github.com/facebookresearch/flores/blob/main/flores200/README.md#languages-in-flores-200

nllbTokenizer._build_translation_inputs(raw_inputs, tokenizer_options, generate_kwargs) ⇒ Object

Helper function to build translation inputs for an NllbTokenizer.

Kind: instance method of NllbTokenizer
Returns: Object - Object to be passed to the model.

tokenizers.M2M100Tokenizer

The M2M100Tokenizer class is used to tokenize text for M2M100 (“Many-to-Many”) models.

M2M100 is a multilingual encoder-decoder (seq-to-seq) model trained for Many-to-Many multilingual translation. It was introduced in this paper and first released in this repository.

For a list of supported languages (along with their language codes),

Kind: static class of tokenizers
See: https://huggingface.co/facebook/m2m100_418M#languages-covered

m2M100Tokenizer._build_translation_inputs(raw_inputs, tokenizer_options, generate_kwargs) ⇒ Object

Helper function to build translation inputs for an M2M100Tokenizer.

Kind: instance method of M2M100Tokenizer
Returns: Object - Object to be passed to the model.

tokenizers.WhisperTokenizer ⇐ PreTrainedTokenizer

WhisperTokenizer tokenizer

Kind: static class of tokenizers
Extends: PreTrainedTokenizer

• .WhisperTokenizer ⇐ PreTrainedTokenizer
  • ._decode_asr(sequences, options) ⇒ *
  • .decode() : *
  • .get_decoder_prompt_ids(options) ⇒ Array.<Array<number>>

whisperTokenizer._decode_asr(sequences, options) ⇒ *

Decodes automatic speech recognition (ASR) sequences.

Kind: instance method of WhisperTokenizer
Returns: * - The decoded sequences.

whisperTokenizer.decode() : *

Kind: instance method of WhisperTokenizer

whisperTokenizer.get_decoder_prompt_ids(options) ⇒ Array.<Array<number>>

Helper function to build translation inputs for a WhisperTokenizer, depending on the language, task, and whether to predict timestamp tokens.

Used to override the prefix tokens appended to the start of the label sequence.

Example: Get ids for a language

// instantiate the tokenizer and set the prefix token to Spanish
let tokenizer = await WhisperTokenizer.from_pretrained('Xenova/whisper-tiny');
let forced_decoder_ids = tokenizer.get_decoder_prompt_ids({ language: 'spanish' });
// [(1, 50262), (2, 50363)]

Kind: instance method of WhisperTokenizer
Returns: Array.<Array<number>> - The decoder prompt ids.

tokenizers.MarianTokenizer

Kind: static class of tokenizers
Todo

• This model is not yet supported by Hugging Face’s “fast” tokenizers library (https://github.com/huggingface/tokenizers). Therefore, this implementation (which is based on fast tokenizers) may produce slightly inaccurate results.

• .MarianTokenizer
  • new MarianTokenizer(tokenizerJSON, tokenizerConfig)
  • ._encode_text(text) ⇒ Array

new MarianTokenizer(tokenizerJSON, tokenizerConfig)

Create a new MarianTokenizer instance.

marianTokenizer._encode_text(text) ⇒ Array

Encodes a single text. Overriding this method is necessary since the language codes must be removed before encoding with sentencepiece model.

Kind: instance method of MarianTokenizer
Returns: Array - The encoded tokens.
See: https://github.com/huggingface/transformers/blob/12d51db243a00726a548a43cc333390ebae731e3/src/transformers/models/marian/tokenization_marian.py#L204-L213

tokenizers.AutoTokenizer

Helper class which is used to instantiate pretrained tokenizers with the from_pretrained function. The chosen tokenizer class is determined by the type specified in the tokenizer config.

Kind: static class of tokenizers

AutoTokenizer.from_pretrained(pretrained_model_name_or_path, options) ⇒ Promise.<PreTrainedTokenizer>

Instantiate one of the tokenizer classes of the library from a pretrained model.

The tokenizer class to instantiate is selected based on the tokenizer_class property of the config object (either passed as an argument or loaded from pretrained_model_name_or_path if possible)

Kind: static method of AutoTokenizer
Returns: Promise.<PreTrainedTokenizer> - A new instance of the PreTrainedTokenizer class.

tokenizers~WordPieceTokenizer ⇐ TokenizerModel

A subclass of TokenizerModel that uses WordPiece encoding to encode tokens.

Kind: inner class of tokenizers
Extends: TokenizerModel

• ~WordPieceTokenizer ⇐ TokenizerModel
  • new WordPieceTokenizer(config)
  • .tokens_to_ids : Map.<string, number>
  • .unk_token_id : number
  • .unk_token : string
  • .vocab : Array.<string>
  • .encode(tokens) ⇒ Array.<string>

new WordPieceTokenizer(config)

wordPieceTokenizer.tokens_to_ids : Map.<string, number>

A mapping of tokens to ids.

Kind: instance property of WordPieceTokenizer

wordPieceTokenizer.unk_token_id : number

The id of the unknown token.

Kind: instance property of WordPieceTokenizer

wordPieceTokenizer.unk_token : string

The unknown token string.

Kind: instance property of WordPieceTokenizer

wordPieceTokenizer.vocab : Array.<string>

An array of tokens.

Kind: instance property of WordPieceTokenizer

wordPieceTokenizer.encode(tokens) ⇒ Array.<string>

Encodes an array of tokens using WordPiece encoding.

Kind: instance method of WordPieceTokenizer
Returns: Array.<string> - An array of encoded tokens.

tokenizers~Unigram ⇐ TokenizerModel

Class representing a Unigram tokenizer model.

Kind: inner class of tokenizers
Extends: TokenizerModel

• ~Unigram ⇐ TokenizerModel
  • new Unigram(config, moreConfig)
  • .populateNodes(lattice)
  • .tokenize(normalized) ⇒ Array.<string>
  • .encode(tokens) ⇒ Array

new Unigram(config, moreConfig)

Create a new Unigram tokenizer model.

unigram.populateNodes(lattice)

Populates lattice nodes.

Kind: instance method of Unigram

unigram.tokenize(normalized) ⇒ Array.<string>

Encodes an array of tokens into an array of subtokens using the unigram model.

Kind: instance method of Unigram
Returns: Array.<string> - An array of subtokens obtained by encoding the input tokens using the unigram model.

unigram.encode(tokens) ⇒ Array

Encodes an array of tokens using Unigram encoding.

Kind: instance method of Unigram
Returns: Array - An array of encoded tokens.

tokenizers~BPE ⇐ TokenizerModel

BPE class for encoding text into Byte-Pair-Encoding (BPE) tokens.

Kind: inner class of tokenizers
Extends: TokenizerModel

• ~BPE ⇐ TokenizerModel
  • new BPE(config)
  • .cache : Map.<string, Array<string>>
  • .bpe(token) ⇒ Array.<string>
  • .encode(tokens) ⇒ Array.<string>

new BPE(config)

Create a BPE instance.

bpE.cache : Map.<string, Array<string>>

Kind: instance property of BPE

bpE.bpe(token) ⇒ Array.<string>

Apply Byte-Pair-Encoding (BPE) to a given token. Efficient heap-based priority queue implementation adapted from https://github.com/belladoreai/llama-tokenizer-js.

Kind: instance method of BPE
Returns: Array.<string> - The BPE encoded tokens.

bpE.encode(tokens) ⇒ Array.<string>

Encodes the input sequence of tokens using the BPE algorithm and returns the resulting subword tokens.

Kind: instance method of BPE
Returns: Array.<string> - The resulting subword tokens after applying the BPE algorithm to the input sequence of tokens.

tokenizers~LegacyTokenizerModel

Legacy tokenizer class for tokenizers with only a vocabulary.

Kind: inner class of tokenizers

• ~LegacyTokenizerModel
  • new LegacyTokenizerModel(config, moreConfig)
  • .tokens_to_ids : Map.<string, number>

new LegacyTokenizerModel(config, moreConfig)

Create a LegacyTokenizerModel instance.

legacyTokenizerModel.tokens_to_ids : Map.<string, number>

Kind: instance property of LegacyTokenizerModel

*tokenizers~Normalizer*

A base class for text normalization.

Kind: inner abstract class of tokenizers

• ~Normalizer
  • new Normalizer(config)
  • instance
    • .normalize(text) ⇒ string
    • ._call(text) ⇒ string
  • static
    • .fromConfig(config) ⇒ Normalizer

*new Normalizer(config)*

**normalizer.normalize(text) ⇒ string**

Normalize the input text.

Kind: instance abstract method of Normalizer
Returns: string - The normalized text.
Throws:

• Error If this method is not implemented in a subclass.

*normalizer._call(text) ⇒ string*

Alias for Normalizer#normalize.

Kind: instance method of Normalizer
Returns: string - The normalized text.

*Normalizer.fromConfig(config) ⇒ Normalizer*

Factory method for creating normalizers from config objects.

Kind: static method of Normalizer
Returns: Normalizer - A Normalizer object.
Throws:

• Error If an unknown Normalizer type is specified in the config.

tokenizers~Replace ⇐ Normalizer

Replace normalizer that replaces occurrences of a pattern with a given string or regular expression.

Kind: inner class of tokenizers
Extends: Normalizer

replace.normalize(text) ⇒ string

Normalize the input text by replacing the pattern with the content.

Kind: instance method of Replace
Returns: string - The normalized text after replacing the pattern with the content.

tokenizers~NFC ⇐ Normalizer

A normalizer that applies Unicode normalization form C (NFC) to the input text.

Kind: inner class of tokenizers
Extends: Normalizer

nfC.normalize(text) ⇒ string

Normalize the input text by applying Unicode normalization form C (NFC).

Kind: instance method of NFC
Returns: string - The normalized text.

tokenizers~NFKD ⇐ Normalizer

NFKD Normalizer.

Kind: inner class of tokenizers
Extends: Normalizer

nfkD.normalize(text) ⇒ string

Normalize text using NFKD normalization.

Kind: instance method of NFKD
Returns: string - The normalized text.

tokenizers~StripNormalizer

A normalizer that strips leading and/or trailing whitespace from the input text.

Kind: inner class of tokenizers

stripNormalizer.normalize(text) ⇒ string

Strip leading and/or trailing whitespace from the input text.

Kind: instance method of StripNormalizer
Returns: string - The normalized text.

tokenizers~StripAccents ⇐ Normalizer

StripAccents normalizer removes all accents from the text.

Kind: inner class of tokenizers
Extends: Normalizer

stripAccents.normalize(text) ⇒ string

Remove all accents from the text.

Kind: instance method of StripAccents
Returns: string - The normalized text without accents.

tokenizers~Lowercase ⇐ Normalizer

A Normalizer that lowercases the input string.

Kind: inner class of tokenizers
Extends: Normalizer

lowercase.normalize(text) ⇒ string

Lowercases the input string.

Kind: instance method of Lowercase
Returns: string - The normalized text.

tokenizers~Prepend ⇐ Normalizer

A Normalizer that prepends a string to the input string.

Kind: inner class of tokenizers
Extends: Normalizer

prepend.normalize(text) ⇒ string

Prepends the input string.

Kind: instance method of Prepend
Returns: string - The normalized text.

tokenizers~NormalizerSequence ⇐ Normalizer

A Normalizer that applies a sequence of Normalizers.

Kind: inner class of tokenizers
Extends: Normalizer

• ~NormalizerSequence ⇐ Normalizer
  • new NormalizerSequence(config)
  • .normalize(text) ⇒ string

new NormalizerSequence(config)

Create a new instance of NormalizerSequence.

normalizerSequence.normalize(text) ⇒ string

Apply a sequence of Normalizers to the input text.

Kind: instance method of NormalizerSequence
Returns: string - The normalized text.

tokenizers~BertNormalizer ⇐ Normalizer

A class representing a normalizer used in BERT tokenization.

Kind: inner class of tokenizers
Extends: Normalizer

• ~BertNormalizer ⇐ Normalizer
  • ._tokenize_chinese_chars(text) ⇒ string
  • ._is_chinese_char(cp) ⇒ boolean
  • .stripAccents(text) ⇒ string
  • .normalize(text) ⇒ string

bertNormalizer._tokenize_chinese_chars(text) ⇒ string

Adds whitespace around any CJK (Chinese, Japanese, or Korean) character in the input text.

Kind: instance method of BertNormalizer
Returns: string - The tokenized text with whitespace added around CJK characters.

bertNormalizer._is_chinese_char(cp) ⇒ boolean

Checks whether the given Unicode codepoint represents a CJK (Chinese, Japanese, or Korean) character.

A “chinese character” is defined as anything in the CJK Unicode block: https://en.wikipedia.org/wiki/CJK_Unified_Ideographs_(Unicode_block)

Note that the CJK Unicode block is NOT all Japanese and Korean characters, despite its name. The modern Korean Hangul alphabet is a different block, as is Japanese Hiragana and Katakana. Those alphabets are used to write space-separated words, so they are not treated specially and are handled like all other languages.

Kind: instance method of BertNormalizer
Returns: boolean - True if the codepoint represents a CJK character, false otherwise.

bertNormalizer.stripAccents(text) ⇒ string

Strips accents from the given text.

Kind: instance method of BertNormalizer
Returns: string - The text with accents removed.

bertNormalizer.normalize(text) ⇒ string

Normalizes the given text based on the configuration.

Kind: instance method of BertNormalizer
Returns: string - The normalized text.

tokenizers~PreTokenizer ⇐ Callable

A callable class representing a pre-tokenizer used in tokenization. Subclasses should implement the pre_tokenize_text method to define the specific pre-tokenization logic.

Kind: inner class of tokenizers
Extends: Callable

• ~PreTokenizer ⇐ Callable
  • instance
    • .pre_tokenize_text(text) ⇒ Array.<string>
    • .pre_tokenize(text) ⇒ Array.<string>
    • ._call(text) ⇒ Array.<string>
  • static
    • .fromConfig(config) ⇒ PreTokenizer

*preTokenizer.pre_tokenize_text(text) ⇒ Array.<string>*

Method that should be implemented by subclasses to define the specific pre-tokenization logic.

Kind: instance abstract method of PreTokenizer
Returns: Array.<string> - The pre-tokenized text.
Throws:

• Error If the method is not implemented in the subclass.

preTokenizer.pre_tokenize(text) ⇒ Array.<string>

Tokenizes the given text into pre-tokens.

Kind: instance method of PreTokenizer
Returns: Array.<string> - An array of pre-tokens.

preTokenizer._call(text) ⇒ Array.<string>

Alias for PreTokenizer#pre_tokenize.

Kind: instance method of PreTokenizer
Returns: Array.<string> - An array of pre-tokens.

PreTokenizer.fromConfig(config) ⇒ PreTokenizer

Factory method that returns an instance of a subclass of PreTokenizer based on the provided configuration.

Kind: static method of PreTokenizer
Returns: PreTokenizer - An instance of a subclass of PreTokenizer.
Throws:

• Error If the provided configuration object does not correspond to any known pre-tokenizer.

tokenizers~BertPreTokenizer ⇐ PreTokenizer

Kind: inner class of tokenizers
Extends: PreTokenizer

• ~BertPreTokenizer ⇐ PreTokenizer
  • new BertPreTokenizer(config)
  • .pre_tokenize_text(text) ⇒ Array.<string>

new BertPreTokenizer(config)

A PreTokenizer that splits text into wordpieces using a basic tokenization scheme similar to that used in the original implementation of BERT.

bertPreTokenizer.pre_tokenize_text(text) ⇒ Array.<string>

Tokenizes a single text using the BERT pre-tokenization scheme.

Kind: instance method of BertPreTokenizer
Returns: Array.<string> - An array of tokens.

tokenizers~ByteLevelPreTokenizer ⇐ PreTokenizer

A pre-tokenizer that splits text into Byte-Pair-Encoding (BPE) subwords.

Kind: inner class of tokenizers
Extends: PreTokenizer

• ~ByteLevelPreTokenizer ⇐ PreTokenizer
  • new ByteLevelPreTokenizer(config)
  • .add_prefix_space : boolean
  • .trim_offsets : boolean
  • .use_regex : boolean
  • .pre_tokenize_text(text) ⇒ Array.<string>

new ByteLevelPreTokenizer(config)

Creates a new instance of the ByteLevelPreTokenizer class.

byteLevelPreTokenizer.add_prefix_space : boolean

Whether to add a leading space to the first word.This allows to treat the leading word just as any other word.

Kind: instance property of ByteLevelPreTokenizer

byteLevelPreTokenizer.trim_offsets : boolean

Whether the post processing step should trim offsetsto avoid including whitespaces.

Kind: instance property of ByteLevelPreTokenizer
Todo

• Use this in the pretokenization step.

byteLevelPreTokenizer.use_regex : boolean

Whether to use the standard GPT2 regex for whitespace splitting.Set it to False if you want to use your own splitting. Defaults to true.

Kind: instance property of ByteLevelPreTokenizer

byteLevelPreTokenizer.pre_tokenize_text(text) ⇒ Array.<string>

Tokenizes a single piece of text using byte-level tokenization.

Kind: instance method of ByteLevelPreTokenizer
Returns: Array.<string> - An array of tokens.

tokenizers~SplitPreTokenizer ⇐ PreTokenizer

Splits text using a given pattern.

Kind: inner class of tokenizers
Extends: PreTokenizer

• ~SplitPreTokenizer ⇐ PreTokenizer
  • new SplitPreTokenizer(config)
  • .pre_tokenize_text(text) ⇒ Array.<string>

new SplitPreTokenizer(config)

splitPreTokenizer.pre_tokenize_text(text) ⇒ Array.<string>

Tokenizes text by splitting it using the given pattern.

Kind: instance method of SplitPreTokenizer
Returns: Array.<string> - An array of tokens.

tokenizers~PunctuationPreTokenizer ⇐ PreTokenizer

Splits text based on punctuation.

Kind: inner class of tokenizers
Extends: PreTokenizer

• ~PunctuationPreTokenizer ⇐ PreTokenizer
  • new PunctuationPreTokenizer(config)
  • .pre_tokenize_text(text) ⇒ Array.<string>

new PunctuationPreTokenizer(config)

punctuationPreTokenizer.pre_tokenize_text(text) ⇒ Array.<string>

Tokenizes text by splitting it using the given pattern.

Kind: instance method of PunctuationPreTokenizer
Returns: Array.<string> - An array of tokens.

tokenizers~DigitsPreTokenizer ⇐ PreTokenizer

Splits text based on digits.

Kind: inner class of tokenizers
Extends: PreTokenizer

• ~DigitsPreTokenizer ⇐ PreTokenizer
  • new DigitsPreTokenizer(config)
  • .pre_tokenize_text(text) ⇒ Array.<string>

new DigitsPreTokenizer(config)

digitsPreTokenizer.pre_tokenize_text(text) ⇒ Array.<string>

Tokenizes text by splitting it using the given pattern.

Kind: instance method of DigitsPreTokenizer
Returns: Array.<string> - An array of tokens.

tokenizers~PostProcessor ⇐ Callable

Kind: inner class of tokenizers
Extends: Callable

• ~PostProcessor ⇐ Callable
  • new PostProcessor(config)
  • instance
    • .post_process(tokens, ...args) ⇒ Array
    • ._call(tokens, ...args) ⇒ Array
  • static
    • .fromConfig(config) ⇒ PostProcessor

new PostProcessor(config)

postProcessor.post_process(tokens, ...args) ⇒ Array

Method to be implemented in subclass to apply post-processing on the given tokens.

Kind: instance method of PostProcessor
Returns: Array - The post-processed tokens.
Throws:

• Error If the method is not implemented in subclass.

postProcessor._call(tokens, ...args) ⇒ Array

Alias for PostProcessor#post_process.

Kind: instance method of PostProcessor
Returns: Array - An array of post-processed tokens.

PostProcessor.fromConfig(config) ⇒ PostProcessor

Factory method to create a PostProcessor object from a configuration object.

Kind: static method of PostProcessor
Returns: PostProcessor - A PostProcessor object created from the given configuration.
Throws:

• Error If an unknown PostProcessor type is encountered.

tokenizers~RobertaProcessing ⇐ PostProcessor

A post-processor that adds special tokens to the beginning and end of the input.

Kind: inner class of tokenizers
Extends: PostProcessor

• ~RobertaProcessing ⇐ PostProcessor
  • new RobertaProcessing(config)
  • .post_process(tokens, tokens_pair) ⇒ Array.<string>

new RobertaProcessing(config)

robertaProcessing.post_process(tokens, tokens_pair) ⇒ Array.<string>

Adds the special tokens to the beginning and end of the input.

Kind: instance method of RobertaProcessing
Returns: Array.<string> - The input tokens with the special tokens added to the beginning and end.

tokenizers~TemplateProcessing ⇐ PostProcessor

Post processor that replaces special tokens in a template with actual tokens.

Kind: inner class of tokenizers
Extends: PostProcessor

• ~TemplateProcessing ⇐ PostProcessor
  • new TemplateProcessing(config)
  • .post_process(tokens, [tokens_pair]) ⇒ Array

new TemplateProcessing(config)

Creates a new instance of TemplateProcessing.

templateProcessing.post_process(tokens, [tokens_pair]) ⇒ Array

Replaces special tokens in the template with actual tokens.

Kind: instance method of TemplateProcessing
Returns: Array - The list of tokens with the special tokens replaced with actual tokens.

tokenizers~ByteLevelPostProcessor ⇐ PostProcessor

A PostProcessor that returns the given tokens as is.

Kind: inner class of tokenizers
Extends: PostProcessor

byteLevelPostProcessor.post_process(tokens) ⇒ Array.<string>

Post process the given tokens.

Kind: instance method of ByteLevelPostProcessor
Returns: Array.<string> - The post processed tokens.

tokenizers~Decoder ⇐ Callable

The base class for token decoders.

Kind: inner class of tokenizers
Extends: Callable

• ~Decoder ⇐ Callable
  • new Decoder(config)
  • instance
    • ._call(tokens) ⇒ string
    • .decode(tokens) ⇒ string
    • .decode_chain(tokens) ⇒ Array.<string>
  • static
    • .fromConfig(config) ⇒ Decoder

new Decoder(config)

Creates an instance of Decoder.

decoder._call(tokens) ⇒ string

Calls the decode method.

Kind: instance method of Decoder
Returns: string - The decoded string.

decoder.decode(tokens) ⇒ string

Decodes a list of tokens.

Kind: instance method of Decoder
Returns: string - The decoded string.

decoder.decode_chain(tokens) ⇒ Array.<string>

Apply the decoder to a list of tokens.

Kind: instance method of Decoder
Returns: Array.<string> - The decoded list of tokens.
Throws:

• Error If the `decode_chain` method is not implemented in the subclass.

Decoder.fromConfig(config) ⇒ Decoder

Creates a decoder instance based on the provided configuration.

Kind: static method of Decoder
Returns: Decoder - A decoder instance.
Throws:

• Error If an unknown decoder type is provided.

tokenizers~FuseDecoder

Fuse simply fuses all tokens into one big string. It’s usually the last decoding step anyway, but this decoder exists incase some decoders need to happen after that step

Kind: inner class of tokenizers

fuseDecoder.decode_chain() : *

Kind: instance method of FuseDecoder

tokenizers~WordPieceDecoder ⇐ Decoder

A decoder that decodes a list of WordPiece tokens into a single string.

Kind: inner class of tokenizers
Extends: Decoder

• ~WordPieceDecoder ⇐ Decoder
  • new WordPieceDecoder(config)
  • .decode_chain() : *

new WordPieceDecoder(config)

Creates a new instance of WordPieceDecoder.

wordPieceDecoder.decode_chain() : *

Kind: instance method of WordPieceDecoder

tokenizers~ByteLevelDecoder ⇐ Decoder

Byte-level decoder for tokenization output. Inherits from the Decoder class.

Kind: inner class of tokenizers
Extends: Decoder

• ~ByteLevelDecoder ⇐ Decoder
  • new ByteLevelDecoder(config)
  • .convert_tokens_to_string(tokens) ⇒ string
  • .decode_chain() : *

new ByteLevelDecoder(config)

Create a ByteLevelDecoder object.

byteLevelDecoder.convert_tokens_to_string(tokens) ⇒ string

Convert an array of tokens to string by decoding each byte.

Kind: instance method of ByteLevelDecoder
Returns: string - The decoded string.

byteLevelDecoder.decode_chain() : *

Kind: instance method of ByteLevelDecoder

tokenizers~CTCDecoder

The CTC (Connectionist Temporal Classification) decoder. See https://github.com/huggingface/tokenizers/blob/bb38f390a61883fc2f29d659af696f428d1cda6b/tokenizers/src/decoders/ctc.rs

Kind: inner class of tokenizers

• ~CTCDecoder
  • .convert_tokens_to_string(tokens) ⇒ string
  • .decode_chain() : *

ctcDecoder.convert_tokens_to_string(tokens) ⇒ string

Converts a connectionist-temporal-classification (CTC) output tokens into a single string.

Kind: instance method of CTCDecoder
Returns: string - The decoded string.

ctcDecoder.decode_chain() : *

Kind: instance method of CTCDecoder

tokenizers~DecoderSequence ⇐ Decoder

Apply a sequence of decoders.

Kind: inner class of tokenizers
Extends: Decoder

• ~DecoderSequence ⇐ Decoder
  • new DecoderSequence(config)
  • .decode_chain() : *

new DecoderSequence(config)

Creates a new instance of DecoderSequence.

decoderSequence.decode_chain() : *

Kind: instance method of DecoderSequence

tokenizers~MetaspacePreTokenizer ⇐ PreTokenizer

This PreTokenizer replaces spaces with the given replacement character, adds a prefix space if requested, and returns a list of tokens.

Kind: inner class of tokenizers
Extends: PreTokenizer

• ~MetaspacePreTokenizer ⇐ PreTokenizer
  • new MetaspacePreTokenizer(config)
  • .pre_tokenize(normalizedTokens) ⇒ Array.<string>

new MetaspacePreTokenizer(config)

metaspacePreTokenizer.pre_tokenize(normalizedTokens) ⇒ Array.<string>

This method takes a list of normalized tokens, replaces spaces with the replacement character, adds a prefix space if requested, and returns a new list of tokens.

Kind: instance method of MetaspacePreTokenizer
Returns: Array.<string> - A new list of pre-tokenized tokens.

tokenizers~MetaspaceDecoder ⇐ Decoder

MetaspaceDecoder class extends the Decoder class and decodes Metaspace tokenization.

Kind: inner class of tokenizers
Extends: Decoder

• ~MetaspaceDecoder ⇐ Decoder
  • new MetaspaceDecoder(config)
  • .decode_chain() : *

new MetaspaceDecoder(config)

Constructs a new MetaspaceDecoder object.

metaspaceDecoder.decode_chain() : *

Kind: instance method of MetaspaceDecoder

tokenizers~Precompiled ⇐ Normalizer

A normalizer that applies a precompiled charsmap. This is useful for applying complex normalizations in C++ and exposing them to JavaScript.

Kind: inner class of tokenizers
Extends: Normalizer

• ~Precompiled ⇐ Normalizer
  • new Precompiled(config)
  • .normalize(text) ⇒ string

new Precompiled(config)

Create a new instance of Precompiled normalizer.

precompiled.normalize(text) ⇒ string

Normalizes the given text by applying the precompiled charsmap.

Kind: instance method of Precompiled
Returns: string - The normalized text.

tokenizers~PreTokenizerSequence ⇐ PreTokenizer

A pre-tokenizer that applies a sequence of pre-tokenizers to the input text.

Kind: inner class of tokenizers
Extends: PreTokenizer

• ~PreTokenizerSequence ⇐ PreTokenizer
  • new PreTokenizerSequence(config)
  • .pre_tokenize_text(text) ⇒ Array.<string>

new PreTokenizerSequence(config)

Creates an instance of PreTokenizerSequence.

preTokenizerSequence.pre_tokenize_text(text) ⇒ Array.<string>

Applies each pre-tokenizer in the sequence to the input text in turn.

Kind: instance method of PreTokenizerSequence
Returns: Array.<string> - The pre-tokenized text.

tokenizers~WhitespaceSplit ⇐ PreTokenizer

Splits a string of text by whitespace characters into individual tokens.

Kind: inner class of tokenizers
Extends: PreTokenizer

• ~WhitespaceSplit ⇐ PreTokenizer
  • new WhitespaceSplit(config)
  • .pre_tokenize_text(text) ⇒ Array.<string>

new WhitespaceSplit(config)

Creates an instance of WhitespaceSplit.

whitespaceSplit.pre_tokenize_text(text) ⇒ Array.<string>

Pre-tokenizes the input text by splitting it on whitespace characters.

Kind: instance method of WhitespaceSplit
Returns: Array.<string> - An array of tokens produced by splitting the input text on whitespace.

tokenizers~BYTES_TO_UNICODE ⇒ Object

Returns list of utf-8 byte and a mapping to unicode strings. Specifically avoids mapping to whitespace/control characters the BPE code barfs on.

Kind: inner constant of tokenizers
Returns: Object - Object with utf-8 byte keys and unicode string values.

tokenizers~loadTokenizer(pretrained_model_name_or_path, options) ⇒ Promise.<Array>

Loads a tokenizer from the specified path.

Kind: inner method of tokenizers
Returns: Promise.<Array> - A promise that resolves with information about the loaded tokenizer.

tokenizers~createPattern(pattern, invert) ⇒ RegExp | string | null

Helper method to construct a pattern from a config object.

Kind: inner method of tokenizers
Returns: RegExp | string | null - The compiled pattern.

tokenizers~clean_up_tokenization(text) ⇒ string

Clean up a list of simple English tokenization artifacts like spaces before punctuations and abbreviated forms

Kind: inner method of tokenizers
Returns: string - The cleaned up text.

tokenizers~fuse(arr, value)

Helper function to fuse consecutive values in an array equal to the specified value.

Kind: inner method of tokenizers

tokenizers~whitespace_split(text) ⇒ Array.<string>

Split a string on whitespace.

Kind: inner method of tokenizers
Returns: Array.<string> - The split string.

tokenizers~add_token_types(inputs) ⇒ Object

Helper method for adding token_type_ids to model inputs

Kind: inner method of tokenizers
Returns: Object - The prepared inputs object.

tokenizers~PretrainedOptions : *

Kind: inner typedef of tokenizers

tokenizers~BPENode : Object

Kind: inner typedef of tokenizers
Properties

tokenizers~SplitDelimiterBehavior : 'removed' | 'isolated' | 'mergedWithPrevious' | 'mergedWithNext' | 'contiguous'

Kind: inner typedef of tokenizers