分词器

分词器用于准备模型的文本输入。

示例： 创建一个 AutoTokenizer 并使用它来分词一个句子。这将根据 tokenizer.json 中定义的分词器类自动检测分词器类型。

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

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

• 分词器
  • 静态
    • .TokenizerModel ⇐ Callable
      • new TokenizerModel(config)
      • 实例
        • .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>
      • 静态
        • .fromConfig(config, ...args) ⇒ TokenizerModel
    • .PreTrainedTokenizer
      • new PreTrainedTokenizer(tokenizerJSON, tokenizerConfig)
      • 实例
        • .added_tokens : Array.<AddedToken>
        • .remove_space : boolean
        • ._call(text, options) ⇒ BatchEncoding
        • ._encode_text(text) ⇒ Array<string> | null
        • ._tokenize_helper(text, options) ⇒ *
        • .tokenize(text, options) ⇒ Array.<string>
        • .encode(text, options) ⇒ Array.<number>
        • .batch_decode(batch, decode_args) ⇒ Array.<string>
        • .decode(token_ids, [decode_args]) ⇒ string
        • .decode_single(token_ids, decode_args) ⇒ string
        • .get_chat_template(options) ⇒ string
        • .apply_chat_template(conversation, options) ⇒ string | Tensor | Array<number> | Array<Array<number>> | BatchEncoding
      • 静态
        • .from_pretrained(pretrained_model_name_or_path, options) ⇒ Promise.<PreTrainedTokenizer>
    • .BertTokenizer ⇐ PreTrainedTokenizer
    • .AlbertTokenizer ⇐ PreTrainedTokenizer
    • .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() : *
    • .MarianTokenizer
      • new MarianTokenizer(tokenizerJSON, tokenizerConfig)
      • ._encode_text(text) ⇒ Array
    • .AutoTokenizer
      • .from_pretrained(pretrained_model_name_or_path, options) ⇒ Promise.<PreTrainedTokenizer>
    • .is_chinese_char(cp) ⇒ boolean
  • 内部
    • ~AddedToken
      • new AddedToken(config)
    • ~WordPieceTokenizer ⇐ TokenizerModel
      • new WordPieceTokenizer(config)
      • .tokens_to_ids : Map.<string, number>
      • .unk_token_id : number
      • .unk_token : string
      • .max_input_chars_per_word : number
      • .vocab : Array.<string>
      • .encode(tokens) ⇒ Array.<string>
    • ~Unigram ⇐ TokenizerModel
      • new Unigram(config, moreConfig)
      • .populateNodes(lattice)
      • .tokenize(normalized) ⇒ Array.<string>
      • .encode(tokens) ⇒ Array.<string>
    • ~BPE ⇐ TokenizerModel
      • new BPE(config)
      • .tokens_to_ids : Map.<string, number>
      • .merges : *
        • .config.merges : *
      • .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)
      • 实例
        • .normalize(text) ⇒ string
        • ._call(text) ⇒ string
      • 静态
        • .fromConfig(config) ⇒ Normalizer
    • ~Replace ⇐ Normalizer
      • .normalize(text) ⇒ string
    • ~NFC ⇐ Normalizer
      • .normalize(text) ⇒ string
    • ~NFKC ⇐ 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
      • .stripAccents(text) ⇒ string
      • .normalize(text) ⇒ string
    • ~PreTokenizer ⇐ Callable
      • 实例
        • .pre_tokenize_text(text, [options]) ⇒ Array.<string>
        • .pre_tokenize(text, [options]) ⇒ Array.<string>
        • ._call(text, [options]) ⇒ Array.<string>
      • 静态
        • .fromConfig(config) ⇒ PreTokenizer
    • ~BertPreTokenizer ⇐ PreTokenizer
      • new BertPreTokenizer(config)
      • .pre_tokenize_text(text, [options]) ⇒ Array.<string>
    • ~ByteLevelPreTokenizer ⇐ PreTokenizer
      • new ByteLevelPreTokenizer(config)
      • .add_prefix_space : boolean
      • .trim_offsets : boolean
      • .use_regex : boolean
      • .pre_tokenize_text(text, [options]) ⇒ Array.<string>
    • ~SplitPreTokenizer ⇐ PreTokenizer
      • new SplitPreTokenizer(config)
      • .pre_tokenize_text(text, [options]) ⇒ Array.<string>
    • ~PunctuationPreTokenizer ⇐ PreTokenizer
      • new PunctuationPreTokenizer(config)
      • .pre_tokenize_text(text, [options]) ⇒ Array.<string>
    • ~DigitsPreTokenizer ⇐ PreTokenizer
      • new DigitsPreTokenizer(config)
      • .pre_tokenize_text(text, [options]) ⇒ Array.<string>
    • ~PostProcessor ⇐ Callable
      • new PostProcessor(config)
      • 实例
        • .post_process(tokens, ...args) ⇒ PostProcessedOutput
        • ._call(tokens, ...args) ⇒ PostProcessedOutput
      • 静态
        • .fromConfig(config) ⇒ PostProcessor
    • ~BertProcessing
      • new BertProcessing(config)
      • .post_process(tokens, [tokens_pair]) ⇒ PostProcessedOutput
    • ~TemplateProcessing ⇐ PostProcessor
      • new TemplateProcessing(config)
      • .post_process(tokens, [tokens_pair]) ⇒ PostProcessedOutput
    • ~ByteLevelPostProcessor ⇐ PostProcessor
      • .post_process(tokens, [tokens_pair]) ⇒ PostProcessedOutput
    • ~PostProcessorSequence
      • new PostProcessorSequence(config)
      • .post_process(tokens, [tokens_pair]) ⇒ PostProcessedOutput
    • ~Decoder ⇐ Callable
      • new Decoder(config)
      • 实例
        • .added_tokens : Array.<AddedToken>
        • ._call(tokens) ⇒ string
        • .decode(tokens) ⇒ string
        • .decode_chain(tokens) ⇒ Array.<string>
      • 静态
        • .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_text(text, [options]) ⇒ 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, [options]) ⇒ Array.<string>
    • ~WhitespacePreTokenizer
      • new WhitespacePreTokenizer(config)
      • .pre_tokenize_text(text, [options]) ⇒ Array.<string>
    • ~WhitespaceSplit ⇐ PreTokenizer
      • new WhitespaceSplit(config)
      • .pre_tokenize_text(text, [options]) ⇒ Array.<string>
    • ~ReplacePreTokenizer
      • new ReplacePreTokenizer(config)
      • .pre_tokenize_text(text, [options]) ⇒ Array.<string>
    • ~BYTES_TO_UNICODE ⇒ Object
    • ~loadTokenizer(pretrained_model_name_or_path, options) ⇒ Promise.<Array<any>>
    • ~regexSplit(text, regex) ⇒ Array.<string>
    • ~createPattern(pattern, invert) ⇒ RegExp | null
    • ~objectToMap(obj) ⇒ Map.<string, any>
    • ~prepareTensorForDecode(tensor) ⇒ Array.<number>
    • ~clean_up_tokenization(text) ⇒ string
    • ~remove_accents(text) ⇒ string
    • ~lowercase_and_remove_accent(text) ⇒ string
    • ~whitespace_split(text) ⇒ Array.<string>
    • ~PretrainedTokenizerOptions : Object
    • ~BPENode : Object
    • ~SplitDelimiterBehavior : ’removed’ | ’isolated’ | ’mergedWithPrevious’ | ’mergedWithNext’ | ’contiguous’
    • ~PostProcessedOutput : Object
    • ~EncodingSingle : Object
    • ~Message : Object
    • ~BatchEncoding : Array<number> | Array<Array<number>> | Tensor

tokenizers.TokenizerModel ⇐ Callable

tokenizer 模型的抽象基类。

Kind: tokenizers 的静态类
Extends: Callable

• .TokenizerModel ⇐ Callable
  • new TokenizerModel(config)
  • 实例
    • .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>
  • 静态
    • .fromConfig(config, ...args) ⇒ TokenizerModel

new TokenizerModel(config)

创建 TokenizerModel 的新实例。

tokenizerModel.vocab : Array. < string >

Kind: TokenizerModel 的实例属性

tokenizerModel.tokens_to_ids : Map. < string, number >

令牌到 ID 的映射。

Kind: TokenizerModel 的实例属性

tokenizerModel.fuse_unk : boolean

是否在编码时融合未知令牌。默认为 false。

Kind: TokenizerModel 的实例属性

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

调用 TokenizerModel 实例的内部函数。

Kind: TokenizerModel 的实例方法
Overrides: _call
Returns: Array.<string> - 编码后的令牌。

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

将令牌列表编码为令牌 ID 列表。

Kind: TokenizerModel 的实例方法
Returns: Array.<string> - 编码后的令牌。
Throws:

• 如果子类中未实现，将抛出错误。

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

将 token 列表转换为 token ID 列表。

Kind: TokenizerModel 的实例方法
返回: Array.<number> - 转换后的 token ID。

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

将 token ID 列表转换为 token 列表。

Kind: TokenizerModel 的实例方法
返回: Array.<string> - 转换后的 token。

TokenizerModel.fromConfig(config, ...args) ⇒ <code> TokenizerModel </code>

基于提供的配置对象实例化一个新的 TokenizerModel 实例。

类型: TokenizerModel 的静态方法
返回: TokenizerModel - TokenizerModel 的新实例。
Throws:

• 如果配置中的 TokenizerModel 类型无法识别，将抛出错误。

tokenizers.PreTrainedTokenizer

Kind: tokenizers 的静态类

• .PreTrainedTokenizer
  • new PreTrainedTokenizer(tokenizerJSON, tokenizerConfig)
  • 实例
    • .added_tokens : Array.<AddedToken>
    • .remove_space : boolean
    • ._call(text, options) ⇒ BatchEncoding
    • ._encode_text(text) ⇒ Array<string> | null
    • ._tokenize_helper(text, options) ⇒ *
    • .tokenize(text, options) ⇒ Array.<string>
    • .encode(text, options) ⇒ Array.<number>
    • .batch_decode(batch, decode_args) ⇒ Array.<string>
    • .decode(token_ids, [decode_args]) ⇒ string
    • .decode_single(token_ids, decode_args) ⇒ string
    • .get_chat_template(options) ⇒ string
    • .apply_chat_template(conversation, options) ⇒ string | Tensor | Array<number> | Array<Array<number>> | BatchEncoding
  • 静态
    • .from_pretrained(pretrained_model_name_or_path, options) ⇒ Promise.<PreTrainedTokenizer>

new PreTrainedTokenizer(tokenizerJSON, tokenizerConfig)

创建一个新的 PreTrainedTokenizer 实例。

preTrainedTokenizer.added_tokens : <code> Array. < AddedToken > </code>

类型: PreTrainedTokenizer 的实例属性

preTrainedTokenizer.remove_space : <code> boolean </code>

在 token 化时是否去除文本（删除字符串前后多余的空格）。

类型: PreTrainedTokenizer 的实例属性

preTrainedTokenizer._call(text, options) ⇒ <code> BatchEncoding </code>

编码/token 化给定的文本。

类型: PreTrainedTokenizer 的实例方法
返回: BatchEncoding - 要传递给模型的对象。

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

使用 tokenizer 的预处理器管道对单个文本进行编码。

类型: PreTrainedTokenizer 的实例方法
返回: Array.<string> | null - 编码后的 token。

preTrainedTokenizer._tokenize_helper(text, options) ⇒ <code> * </code>

用于 token 化文本（以及可选的文本对）的内部辅助函数。

类型: PreTrainedTokenizer 的实例方法
返回: * - 包含 token 以及可选的 token 类型 ID 的对象。

preTrainedTokenizer.tokenize(text, options) ⇒ <code> Array. < string > </code>

将字符串转换为 token 序列。

类型: PreTrainedTokenizer 的实例方法
返回: Array.<string> - token 列表。

preTrainedTokenizer.encode(text, options) ⇒ <code> Array. < number > </code>

使用模型的 tokenizer 编码单个文本或文本对。

类型: PreTrainedTokenizer 的实例方法
返回: Array.<number> - 表示编码后的文本的 token ID 数组。

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

解码一批 token 化的序列。

类型: PreTrainedTokenizer 的实例方法
返回: Array.<string> - 解码后的序列列表。

preTrainedTokenizer.decode(token_ids, [decode_args]) ⇒ <code> string </code>

将 token ID 序列解码回字符串。

类型: PreTrainedTokenizer 的实例方法
返回: string - 解码后的字符串。
Throws:

• Error 如果 token_ids 不是非空的整数数组。

preTrainedTokenizer.decode_single(token_ids, decode_args) ⇒ <code> string </code>

将单个 token ID 列表解码为字符串。

类型: PreTrainedTokenizer 的实例方法
返回: string - 解码后的字符串

preTrainedTokenizer.get_chat_template(options) ⇒ <code> string </code>

检索用于 token 化聊天消息的聊天模板字符串。此模板在内部由 apply_chat_template 方法使用，也可以在外部使用以检索模型的聊天模板，从而更好地跟踪生成过程。

类型: PreTrainedTokenizer 的实例方法
返回: string - 聊天模板字符串。

preTrainedTokenizer.apply_chat_template(conversation, options) ⇒ <code> string </code> | <code> Tensor </code> | <code> Array < number > </code> | <code> Array < Array < number > > </code> | <code> BatchEncoding </code>

将包含 "role" 和 "content" 键的消息对象列表转换为 token ID 列表。此方法旨在用于聊天模型，并将读取 tokenizer 的 chat_template 属性以确定转换时要使用的格式和控制 token。

有关更多信息，请参阅此处。

示例： 将聊天模板应用于对话。

import { AutoTokenizer } from "@huggingface/transformers";

const tokenizer = await AutoTokenizer.from_pretrained("Xenova/mistral-tokenizer-v1");

const chat = [
  { "role": "user", "content": "Hello, how are you?" },
  { "role": "assistant", "content": "I'm doing great. How can I help you today?" },
  { "role": "user", "content": "I'd like to show off how chat templating works!" },
]

const text = tokenizer.apply_chat_template(chat, { tokenize: false });
// "<s>[INST] Hello, how are you? [/INST]I'm doing great. How can I help you today?</s> [INST] I'd like to show off how chat templating works! [/INST]"

const input_ids = tokenizer.apply_chat_template(chat, { tokenize: true, return_tensor: false });
// [1, 733, 16289, 28793, 22557, 28725, 910, 460, 368, 28804, 733, 28748, 16289, 28793, 28737, 28742, 28719, 2548, 1598, 28723, 1602, 541, 315, 1316, 368, 3154, 28804, 2, 28705, 733, 16289, 28793, 315, 28742, 28715, 737, 298, 1347, 805, 910, 10706, 5752, 1077, 3791, 28808, 733, 28748, 16289, 28793]

类型: PreTrainedTokenizer 的实例方法
返回: string | Tensor | Array.<number> | Array.<Array.<number>> | BatchEncoding - token 化后的输出。

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

从给定的 pretrained_model_name_or_path 加载预训练的 tokenizer。

类型: PreTrainedTokenizer 的静态方法
返回: Promise.<PreTrainedTokenizer> - PreTrainedTokenizer 类的新实例。
Throws:

• Error 如果在 pretrained_model_name_or_path 中找不到 tokenizer.json 或 tokenizer_config.json 文件，则抛出错误。

tokenizers.BertTokenizer ⇐ <code> PreTrainedTokenizer </code>

BertTokenizer 类用于为 BERT 模型 token 化文本。

Kind: tokenizers 的静态类
继承自: PreTrainedTokenizer

tokenizers.AlbertTokenizer ⇐ <code> PreTrainedTokenizer </code>

Albert tokenizer

Kind: tokenizers 的静态类
继承自: PreTrainedTokenizer

tokenizers.NllbTokenizer

NllbTokenizer 类用于为 NLLB（“No Language Left Behind”）模型 token 化文本。

No Language Left Behind (NLLB) 是一个首创的 AI 突破性项目，它开源了能够在 200 多种语言（包括阿斯图里亚斯语、卢干达语、乌尔都语等低资源语言）的任意两种语言之间直接进行高质量翻译的模型。它旨在帮助人们与任何人、在任何地方进行交流，无论他们的语言偏好如何。有关更多信息，请查看他们的论文。

有关支持语言列表（及其语言代码），

Kind: tokenizers 的静态类
参见: https://github.com/facebookresearch/flores/blob/main/flores200/README.md#languages-in-flores-200

nllbTokenizer._build_translation_inputs(raw_inputs, tokenizer_options, generate_kwargs) ⇒ <code> Object </code>

用于为 NllbTokenizer 构建翻译输入的辅助函数。

类型: NllbTokenizer 的实例方法
返回值: Object - 要传递给模型的对象。

tokenizers.M2M100Tokenizer

M2M100Tokenizer 类用于为 M2M100（“多对多”）模型分词文本。

M2M100 是一个用于多对多语言翻译的多语言编码器-解码器（seq-to-seq）模型。它在这篇论文中被介绍，并首次在这个仓库中发布。

有关支持语言列表（及其语言代码），

Kind: tokenizers 的静态类
参见: https://huggingface.co/facebook/m2m100_418M#languages-covered

m2M100Tokenizer._build_translation_inputs(raw_inputs, tokenizer_options, generate_kwargs) ⇒ <code> Object </code>

用于为 M2M100Tokenizer 构建翻译输入的辅助函数。

类型: M2M100Tokenizer 的实例方法
返回值: Object - 要传递给模型的对象。

tokenizers.WhisperTokenizer ⇐ <code> PreTrainedTokenizer </code>

WhisperTokenizer 分词器

Kind: tokenizers 的静态类
继承自: PreTrainedTokenizer

• .WhisperTokenizer ⇐ PreTrainedTokenizer
  • ._decode_asr(sequences, options) ⇒ *
  • .decode() : *

whisperTokenizer._decode_asr(sequences, options) ⇒ <code> * </code>

解码自动语音识别 (ASR) 序列。

类型: WhisperTokenizer 的实例方法
返回值: * - 解码后的序列。

whisperTokenizer.decode() : <code> * </code>

类型: WhisperTokenizer 的实例方法

tokenizers.MarianTokenizer

Kind: tokenizers 的静态类
待办

• Hugging Face 的“fast”分词器库（https://github.com/huggingface/tokenizers）尚不支持此模型。因此，此实现（基于 fast 分词器）可能会产生略微不准确的结果。

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

new MarianTokenizer(tokenizerJSON, tokenizerConfig)

创建一个新的 MarianTokenizer 实例。

marianTokenizer._encode_text(text) ⇒ <code> Array </code>

编码单个文本。由于必须在用 sentencepiece 模型编码之前删除语言代码，因此必须重写此方法。

类型: MarianTokenizer 的实例方法
返回值: Array - 编码后的 token。
参见: https://github.com/huggingface/transformers/blob/12d51db243a00726a548a43cc333390ebae731e3/src/transformers/models/marian/tokenization_marian.py#L204-L213

tokenizers.AutoTokenizer

辅助类，用于使用 from_pretrained 函数实例化预训练的分词器。所选的分词器类由分词器配置中指定的类型确定。

Kind: tokenizers 的静态类

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

从预训练模型实例化库中的一个分词器类。

要实例化的分词器类是根据配置对象的 tokenizer_class 属性选择的（可以作为参数传递，也可以从 pretrained_model_name_or_path 加载，如果可能）

类型: AutoTokenizer 的静态方法
返回值: Promise.<PreTrainedTokenizer> - PreTrainedTokenizer 类的新实例。

tokenizers.is_chinese_char(cp) ⇒ <code> boolean </code>

检查给定的 Unicode 代码点是否代表 CJK（中文、日文或韩文）字符。

“中文字符”定义为 CJK Unicode 区块中的任何内容：https://en.wikipedia.org/wiki/CJK_Unified_Ideographs_(Unicode_block)

请注意，CJK Unicode 区块并非所有日文和韩文字符，尽管其名称如此。现代韩文韩文是不同的区块，日文平假名和片假名也是如此。这些字母表用于书写空格分隔的单词，因此它们不会被特殊对待，并且像所有其他语言一样处理。

类型: tokenizers 的静态方法
返回值: boolean - 如果代码点代表 CJK 字符，则为 True，否则为 False。

tokenizers~AddedToken

表示用户在现有模型词汇表之上添加的 token。AddedToken 可以配置为指定它们在各种情况下的行为，例如

• 它们是否应该只匹配单个单词
• 是否在其左侧或右侧包含任何空格

类型: tokenizers 的内部类

new AddedToken(config)

创建 AddedToken 的新实例。

tokenizers~WordPieceTokenizer ⇐ <code> TokenizerModel </code>

TokenizerModel 的子类，它使用 WordPiece 编码来编码 token。

类型: tokenizers 的内部类
继承自: TokenizerModel

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

new WordPieceTokenizer(config)

wordPieceTokenizer.tokens_to_ids : <code> Map. < string, number > </code>

令牌到 ID 的映射。

类型: WordPieceTokenizer 的实例属性

wordPieceTokenizer.unk_token_id : <code> number </code>

未知 token 的 ID。

类型: WordPieceTokenizer 的实例属性

wordPieceTokenizer.unk_token : <code> string </code>

未知 token 字符串。

类型: WordPieceTokenizer 的实例属性

wordPieceTokenizer.max_input_chars_per_word : <code> number </code>

每个单词允许的最大字符数。

类型: WordPieceTokenizer 的实例属性

wordPieceTokenizer.vocab : <code> Array. < string > </code>

token 数组。

类型: WordPieceTokenizer 的实例属性

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

使用 WordPiece 编码对 token 数组进行编码。

类型: WordPieceTokenizer 的实例方法
返回值: Array.<string> - 编码后的 token 数组。

tokenizers~Unigram ⇐ <code> TokenizerModel </code>

表示 Unigram 分词器模型的类。

类型: tokenizers 的内部类
继承自: TokenizerModel

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

new Unigram(config, moreConfig)

创建一个新的 Unigram 分词器模型。

unigram.populateNodes(lattice)

填充 lattice 节点。

Kind: instance method of Unigram

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

使用 unigram 模型将 token 数组编码为 subtoken 数组。

Kind: instance method of Unigram
Returns: Array.<string> - 通过使用 unigram 模型编码输入 token 获得的 subtoken 数组。

unigram.encode(tokens) ⇒ <code> Array. < string > </code>

使用 Unigram 编码对 token 数组进行编码。

Kind: instance method of Unigram
返回值: Array.<string> - 编码后的 token 数组。

tokenizers~BPE ⇐ <code> TokenizerModel </code>

BPE 类，用于将文本编码为 Byte-Pair-Encoding (BPE) token。

类型: tokenizers 的内部类
继承自: TokenizerModel

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

new BPE(config)

创建一个 BPE 实例。

bpE.tokens_to_ids : <code> Map. < string, number > </code>

Kind: instance property of BPE

bpE.merges : <code> * </code>

Kind: instance property of BPE

merges.config.merges : <code> * </code>

Kind: static property of merges

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

Kind: instance property of BPE

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

将 Byte-Pair-Encoding (BPE) 应用于给定的 token。高效的基于堆的优先级队列实现，改编自 https://github.com/belladoreai/llama-tokenizer-js。

Kind: instance method of BPE
Returns: Array.<string> - BPE 编码后的 token 数组。

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

使用 BPE 算法对输入的 token 序列进行编码，并返回生成的 subword token。

Kind: instance method of BPE
Returns: Array.<string> - 将 BPE 算法应用于输入 token 序列后生成的 subword token。

tokenizers~LegacyTokenizerModel

用于仅具有词汇表的 tokenizer 的传统 tokenizer 类。

类型: tokenizers 的内部类

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

new LegacyTokenizerModel(config, moreConfig)

创建一个 LegacyTokenizerModel 实例。

legacyTokenizerModel.tokens_to_ids : <code> Map. < string, number > </code>

Kind: instance property of LegacyTokenizerModel

tokenizers~Normalizer

文本标准化的基类。

Kind: inner abstract class of tokenizers

• ~Normalizer
  • new Normalizer(config)
  • 实例
    • .normalize(text) ⇒ string
    • ._call(text) ⇒ string
  • 静态
    • .fromConfig(config) ⇒ Normalizer

new Normalizer(config)

normalizer.normalize(text) ⇒ <code> string </code>

标准化输入文本。

Kind: instance abstract method of Normalizer
Returns: string - 标准化后的文本。
Throws:

• Error 如果子类中未实现此方法。

normalizer._call(text) ⇒ <code> string </code>

别名，指向 Normalizer#normalize。

Kind: instance method of Normalizer
Returns: string - 标准化后的文本。

Normalizer.fromConfig(config) ⇒ <code> Normalizer </code>

用于从配置对象创建 normalizer 的工厂方法。

Kind: static method of Normalizer
Returns: Normalizer - 一个 Normalizer 对象。
Throws:

• Error 如果在配置中指定了未知的 Normalizer 类型。

tokenizers~Replace ⇐ <code> Normalizer </code>

Replace normalizer，用于将模式的出现替换为给定的字符串或正则表达式。

类型: tokenizers 的内部类
Extends: Normalizer

replace.normalize(text) ⇒ <code> string </code>

通过将模式替换为内容来标准化输入文本。

Kind: instance method of Replace
Returns: string - 将模式替换为内容后标准化后的文本。

tokenizers~NFC ⇐ <code> Normalizer </code>

一个 normalizer，它将 Unicode 标准化形式 C (NFC) 应用于输入文本。

类型: tokenizers 的内部类
Extends: Normalizer

nfC.normalize(text) ⇒ <code> string </code>

通过应用 Unicode 标准化形式 C (NFC) 来标准化输入文本。

Kind: instance method of NFC
Returns: string - 标准化后的文本。

tokenizers~NFKC ⇐ <code> Normalizer </code>

NFKC Normalizer。

类型: tokenizers 的内部类
Extends: Normalizer

nfkC.normalize(text) ⇒ <code> string </code>

使用 NFKC 标准化来标准化文本。

Kind: instance method of NFKC
Returns: string - 标准化后的文本。

tokenizers~NFKD ⇐ <code> Normalizer </code>

NFKD Normalizer。

类型: tokenizers 的内部类
Extends: Normalizer

nfkD.normalize(text) ⇒ <code> string </code>

使用 NFKD 标准化来标准化文本。

Kind: instance method of NFKD
Returns: string - 标准化后的文本。

tokenizers~StripNormalizer

一个 Normalizer，用于去除输入文本的前导和/或尾随空格。

类型: tokenizers 的内部类

stripNormalizer.normalize(text) ⇒ <code> string </code>

去除输入文本的前导和/或尾随空格。

Kind：StripNormalizer 的实例方法，请参阅 StripNormalizer。
Returns: string - 标准化后的文本。

tokenizers~StripAccents ⇐ <code> Normalizer </code>

StripAccents normalizer 从文本中删除所有重音符号。

类型: tokenizers 的内部类
Extends: Normalizer

stripAccents.normalize(text) ⇒ <code> string </code>

从文本中删除所有重音符号。

Kind：StripAccents 的实例方法，请参阅 StripAccents。
Returns: string - 不带重音符号的标准化文本。

tokenizers~Lowercase ⇐ <code> Normalizer </code>

一个 Normalizer，用于将输入字符串转换为小写。

类型: tokenizers 的内部类
Extends: Normalizer

lowercase.normalize(text) ⇒ <code> string </code>

将输入字符串转换为小写。

Kind：Lowercase 的实例方法，请参阅 Lowercase。
Returns: string - 标准化后的文本。

tokenizers~Prepend ⇐ <code> Normalizer </code>

一个 Normalizer，用于在输入字符串前面添加字符串。

类型: tokenizers 的内部类
Extends: Normalizer

prepend.normalize(text) ⇒ <code> string </code>

在输入字符串前面添加字符串。

Kind：Prepend 的实例方法，请参阅 Prepend。
Returns: string - 标准化后的文本。

tokenizers~NormalizerSequence ⇐ <code> Normalizer </code>

一个 Normalizer，用于应用 Normalizer 序列。

类型: tokenizers 的内部类
Extends: Normalizer

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

new NormalizerSequence(config)

创建 NormalizerSequence 的新实例。

normalizerSequence.normalize(text) ⇒ <code> string </code>

将 Normalizer 序列应用于输入文本。

Kind：NormalizerSequence 的实例方法，请参阅 NormalizerSequence。
Returns: string - 标准化后的文本。

tokenizers~BertNormalizer ⇐ <code> Normalizer </code>

一个类，表示 BERT 标记化中使用的 normalizer。

类型: tokenizers 的内部类
Extends: Normalizer

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

bertNormalizer._tokenize_chinese_chars(text) ⇒ <code> string </code>

在输入文本中的任何 CJK（中文、日文或韩文）字符周围添加空格。

Kind：BertNormalizer 的实例方法，请参阅 BertNormalizer。
Returns: string - 在 CJK 字符周围添加空格的标记化文本。

bertNormalizer.stripAccents(text) ⇒ <code> string </code>

从给定的文本中去除重音符号。

Kind：BertNormalizer 的实例方法，请参阅 BertNormalizer。
Returns: string - 去除重音符号的文本。

bertNormalizer.normalize(text) ⇒ <code> string </code>

根据配置规范化给定的文本。

Kind：BertNormalizer 的实例方法，请参阅 BertNormalizer。
Returns: string - 标准化后的文本。

tokenizers~PreTokenizer ⇐ <code> Callable </code>

一个可调用类，表示标记化中使用的预标记器。子类应实现 pre_tokenize_text 方法来定义特定的预标记化逻辑。

类型: tokenizers 的内部类
Extends: Callable

• ~PreTokenizer ⇐ Callable
  • 实例
    • .pre_tokenize_text(text, [options]) ⇒ Array.<string>
    • .pre_tokenize(text, [options]) ⇒ Array.<string>
    • ._call(text, [options]) ⇒ Array.<string>
  • 静态
    • .fromConfig(config) ⇒ PreTokenizer

preTokenizer.pre_tokenize_text(text, [options]) ⇒ <code> Array. < string > </code>

子类应实现的方法，用于定义特定的预标记化逻辑。

Kind：PreTokenizer 的实例抽象方法，请参阅 PreTokenizer。
Returns: Array.<string> - 预标记化文本。
Throws:

• Error 如果子类中未实现该方法。

preTokenizer.pre_tokenize(text, [options]) ⇒ <code> Array. < string > </code>

将给定的文本标记化为预标记。

Kind：PreTokenizer 的实例方法，请参阅 PreTokenizer。
Returns: Array.<string> - 预标记数组。

preTokenizer._call(text, [options]) ⇒ <code> Array. < string > </code>

PreTokenizer#pre_tokenize 的别名，请参阅 PreTokenizer#pre_tokenize。

Kind：PreTokenizer 的实例方法，请参阅 PreTokenizer。
Overrides: _call
Returns: Array.<string> - 预标记数组。

PreTokenizer.fromConfig(config) ⇒ <code> PreTokenizer </code>

工厂方法，根据提供的配置返回 PreTokenizer 子类的实例。

Kind：PreTokenizer 的静态方法，请参阅 PreTokenizer。
Returns: PreTokenizer - PreTokenizer 子类的实例。
Throws:

• Error 如果提供的配置对象与任何已知的预标记器都不对应。

tokenizers~BertPreTokenizer ⇐ <code> PreTokenizer </code>

类型: tokenizers 的内部类
Extends：PreTokenizer

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

new BertPreTokenizer(config)

一个 PreTokenizer，它使用类似于 BERT 原始实现中使用的基本标记化方案，将文本拆分为 wordpiece。

bertPreTokenizer.pre_tokenize_text(text, [options]) ⇒ <code> Array. < string > </code>

使用 BERT 预标记化方案标记化单个文本。

Kind：BertPreTokenizer 的实例方法，请参阅 BertPreTokenizer。
Returns: Array.<string> - 标记数组。

tokenizers~ByteLevelPreTokenizer ⇐ <code> PreTokenizer </code>

一个预标记器，用于将文本拆分为字节对编码 (BPE) 子词。

类型: tokenizers 的内部类
Extends：PreTokenizer

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

new ByteLevelPreTokenizer(config)

创建 ByteLevelPreTokenizer 类的新实例。

byteLevelPreTokenizer.add_prefix_space : <code> boolean </code>

是否在第一个单词前添加前导空格。这允许像对待任何其他单词一样对待前导词。

Kind：ByteLevelPreTokenizer 的实例属性，请参阅 ByteLevelPreTokenizer。

byteLevelPreTokenizer.trim_offsets : <code> boolean </code>

后处理步骤是否应修剪偏移量以避免包含空格。

Kind：ByteLevelPreTokenizer 的实例属性，请参阅 ByteLevelPreTokenizer。
待办

• 在预标记化步骤中使用此项。

byteLevelPreTokenizer.use_regex : <code> boolean </code>

是否使用标准的 GPT2 正则表达式进行空格拆分。如果您想使用自己的拆分，请将其设置为 False。默认为 true。

Kind：ByteLevelPreTokenizer 的实例属性，请参阅 ByteLevelPreTokenizer。

byteLevelPreTokenizer.pre_tokenize_text(text, [options]) ⇒ <code> Array. < string > </code>

使用字节级分词器对单段文本进行分词。

Kind: instance method of ByteLevelPreTokenizer
Returns: Array.<string> - 标记数组。

tokenizers~SplitPreTokenizer ⇐ <code> PreTokenizer </code>

使用给定的模式分割文本。

类型: tokenizers 的内部类
Extends：PreTokenizer

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

new SplitPreTokenizer(config)

splitPreTokenizer.pre_tokenize_text(text, [options]) ⇒ <code> Array. < string > </code>

通过使用给定的模式分割文本进行分词。

Kind: instance method of SplitPreTokenizer
Returns: Array.<string> - 标记数组。

tokenizers~PunctuationPreTokenizer ⇐ <code> PreTokenizer </code>

基于标点符号分割文本。

类型: tokenizers 的内部类
Extends：PreTokenizer

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

new PunctuationPreTokenizer(config)

punctuationPreTokenizer.pre_tokenize_text(text, [options]) ⇒ <code> Array. < string > </code>

通过使用给定的模式分割文本进行分词。

Kind: instance method of PunctuationPreTokenizer
Returns: Array.<string> - 标记数组。

tokenizers~DigitsPreTokenizer ⇐ <code> PreTokenizer </code>

基于数字分割文本。

类型: tokenizers 的内部类
Extends：PreTokenizer

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

new DigitsPreTokenizer(config)

digitsPreTokenizer.pre_tokenize_text(text, [options]) ⇒ <code> Array. < string > </code>

通过使用给定的模式分割文本进行分词。

Kind: instance method of DigitsPreTokenizer
Returns: Array.<string> - 标记数组。

tokenizers~PostProcessor ⇐ <code> Callable </code>

类型: tokenizers 的内部类
Extends: Callable

• ~PostProcessor ⇐ Callable
  • new PostProcessor(config)
  • 实例
    • .post_process(tokens, ...args) ⇒ PostProcessedOutput
    • ._call(tokens, ...args) ⇒ PostProcessedOutput
  • 静态
    • .fromConfig(config) ⇒ PostProcessor

new PostProcessor(config)

postProcessor.post_process(tokens, ...args) ⇒ <code> PostProcessedOutput </code>

子类中要实现的方法，用于对给定的 tokens 应用后处理。

Kind: instance method of PostProcessor

Returns: PostProcessedOutput - 后处理后的 tokens。
Throws:

• Error 如果该方法未在子类中实现。

postProcessor._call(tokens, ...args) ⇒ <code> PostProcessedOutput </code>

PostProcessor#post_process 的别名。

Kind: instance method of PostProcessor
Overrides: _call

Returns: PostProcessedOutput - 后处理后的 tokens。

PostProcessor.fromConfig(config) ⇒ <code> PostProcessor </code>

从配置对象创建 PostProcessor 对象的工厂方法。

Kind: static method of PostProcessor

Returns: PostProcessor - 从给定配置创建的 PostProcessor 对象。
Throws:

• Error 如果遇到未知的 PostProcessor 类型。

tokenizers~BertProcessing

一个后处理器，用于在输入的开头和结尾添加特殊 tokens。

类型: tokenizers 的内部类

• ~BertProcessing
  • new BertProcessing(config)
  • .post_process(tokens, [tokens_pair]) ⇒ PostProcessedOutput

new BertProcessing(config)

bertProcessing.post_process(tokens, [tokens_pair]) ⇒ <code> PostProcessedOutput </code>

将特殊 tokens 添加到输入的开头和结尾。

Kind: instance method of BertProcessing

Returns: PostProcessedOutput - 后处理后的 tokens，在开头和结尾添加了特殊 tokens。

tokenizers~TemplateProcessing ⇐ <code> PostProcessor </code>

后处理器，用于将模板中的特殊 tokens 替换为实际 tokens。

类型: tokenizers 的内部类
Extends: PostProcessor

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

new TemplateProcessing(config)

创建 TemplateProcessing 的新实例。

templateProcessing.post_process(tokens, [tokens_pair]) ⇒ <code> PostProcessedOutput </code>

将模板中的特殊 tokens 替换为实际 tokens。

Kind: instance method of TemplateProcessing

Returns: PostProcessedOutput - 一个对象，其中包含 tokens 列表，特殊 tokens 已被实际 tokens 替换。

tokenizers~ByteLevelPostProcessor ⇐ <code> PostProcessor </code>

一个后处理器，按原样返回给定的 tokens。

类型: tokenizers 的内部类
Extends: PostProcessor

byteLevelPostProcessor.post_process(tokens, [tokens_pair]) ⇒ <code> PostProcessedOutput </code>

后处理给定的 tokens。

Kind: instance method of ByteLevelPostProcessor

Returns: PostProcessedOutput - 包含后处理 tokens 的对象。

tokenizers~PostProcessorSequence

一个后处理器，按顺序应用多个后处理器。

类型: tokenizers 的内部类

• ~PostProcessorSequence
  • new PostProcessorSequence(config)
  • .post_process(tokens, [tokens_pair]) ⇒ PostProcessedOutput

new PostProcessorSequence(config)

创建 PostProcessorSequence 的新实例。

postProcessorSequence.post_process(tokens, [tokens_pair]) ⇒ <code> PostProcessedOutput </code>

后处理给定的 tokens。

Kind: instance method of PostProcessorSequence

Returns: PostProcessedOutput - 包含后处理 tokens 的对象。

tokenizers~Decoder ⇐ <code> Callable </code>

token 解码器的基类。

类型: tokenizers 的内部类
Extends: Callable

• ~Decoder ⇐ Callable
  • new Decoder(config)
  • 实例
    • .added_tokens : Array.<AddedToken>
    • ._call(tokens) ⇒ string
    • .decode(tokens) ⇒ string
    • .decode_chain(tokens) ⇒ Array.<string>
  • 静态
    • .fromConfig(config) ⇒ Decoder

new Decoder(config)

创建 Decoder 的实例。

decoder.added_tokens : <code> Array. < AddedToken > </code>

Kind: instance property of Decoder

decoder._call(tokens) ⇒ <code> string </code>

调用 decode 方法。

Kind: instance method of Decoder
Overrides: _call
返回: string - 解码后的字符串。

decoder.decode(tokens) ⇒ <code> string </code>

解码 tokens 列表。

Kind: instance method of Decoder
返回: string - 解码后的字符串。

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

将解码器应用于 token 列表。

Kind: instance method of Decoder
返回值：Array.<string> - 解码后的 token 列表。
Throws:

• Error 如果子类中未实现 `decode_chain` 方法。

Decoder.fromConfig(config) ⇒ <code> Decoder </code>

根据提供的配置创建解码器实例。

类型：Decoder 的静态方法
返回值：Decoder - 一个解码器实例。
Throws:

• Error 如果提供了未知的解码器类型。

tokenizers~FuseDecoder

Fuse 只是简单地将所有 token 融合为一个大的字符串。它通常已经是最后的解码步骤，但此解码器的存在是为了防止某些解码器需要在该步骤之后发生。

类型: tokenizers 的内部类

fuseDecoder.decode_chain() : <code> * </code>

类型：FuseDecoder 的实例方法

tokenizers~WordPieceDecoder ⇐ <code> Decoder </code>

一个将 WordPiece token 列表解码为单个字符串的解码器。

类型: tokenizers 的内部类
继承自：Decoder

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

new WordPieceDecoder(config)

创建一个 WordPieceDecoder 的新实例。

wordPieceDecoder.decode_chain() : <code> * </code>

类型：WordPieceDecoder 的实例方法

tokenizers~ByteLevelDecoder ⇐ <code> Decoder </code>

用于 tokenization 输出的字节级解码器。继承自 Decoder 类。

类型: tokenizers 的内部类
继承自：Decoder

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

new ByteLevelDecoder(config)

创建一个 ByteLevelDecoder 对象。

byteLevelDecoder.convert_tokens_to_string(tokens) ⇒ <code> string </code>

通过解码每个字节，将 token 数组转换为字符串。

类型：ByteLevelDecoder 的实例方法
返回: string - 解码后的字符串。

byteLevelDecoder.decode_chain() : <code> * </code>

类型：ByteLevelDecoder 的实例方法

tokenizers~CTCDecoder

CTC（Connectionist Temporal Classification，连接时序分类）解码器。请参阅 https://github.com/huggingface/tokenizers/blob/bb38f390a61883fc2f29d659af696f428d1cda6b/tokenizers/src/decoders/ctc.rs

类型: tokenizers 的内部类

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

ctcDecoder.convert_tokens_to_string(tokens) ⇒ <code> string </code>

将连接时序分类 (CTC) 输出 token 转换为单个字符串。

类型：CTCDecoder 的实例方法
返回: string - 解码后的字符串。

ctcDecoder.decode_chain() : <code> * </code>

类型：CTCDecoder 的实例方法

tokenizers~DecoderSequence ⇐ <code> Decoder </code>

应用一系列解码器。

类型: tokenizers 的内部类
继承自：Decoder

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

new DecoderSequence(config)

创建一个 DecoderSequence 的新实例。

decoderSequence.decode_chain() : <code> * </code>

类型：DecoderSequence 的实例方法

tokenizers~MetaspacePreTokenizer ⇐ <code> PreTokenizer </code>

此 PreTokenizer 将空格替换为给定的替换字符，如果请求，则添加前缀空格，并返回 token 列表。

类型: tokenizers 的内部类
Extends：PreTokenizer

• ~MetaspacePreTokenizer ⇐ PreTokenizer
  • new MetaspacePreTokenizer(config)
  • .pre_tokenize_text(text, [options]) ⇒ Array.<string>

new MetaspacePreTokenizer(config)

metaspacePreTokenizer.pre_tokenize_text(text, [options]) ⇒ <code> Array. < string > </code>

此方法接受一个字符串，将空格替换为替换字符，如果请求，则添加前缀空格，并返回新的 token 列表。

类型：MetaspacePreTokenizer 的实例方法
返回值：Array.<string> - 一个新的预 tokenization 后的 token 列表。

tokenizers~MetaspaceDecoder ⇐ <code> Decoder </code>

MetaspaceDecoder 类扩展了 Decoder 类，并解码 Metaspace tokenization。

类型: tokenizers 的内部类
继承自：Decoder

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

new MetaspaceDecoder(config)

构造一个新的 MetaspaceDecoder 对象。

metaspaceDecoder.decode_chain() : <code> * </code>

类型：MetaspaceDecoder 的实例方法

tokenizers~Precompiled ⇐ <code> Normalizer </code>

一个应用预编译字符映射表的 normalizer。这对于在 C++ 中应用复杂的 normalization 并将其暴露给 JavaScript 非常有用。

类型: tokenizers 的内部类
Extends: Normalizer

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

new Precompiled(config)

创建一个 Precompiled normalizer 的新实例。

precompiled.normalize(text) ⇒ <code> string </code>

通过应用预编译的字符映射表，对给定的文本进行 normalization。

类型：Precompiled 的实例方法
Returns: string - 标准化后的文本。

tokenizers~PreTokenizerSequence ⇐ <code> PreTokenizer </code>

一个将一系列预 tokenization 器应用于输入文本的预 tokenization 器。

类型: tokenizers 的内部类
Extends：PreTokenizer

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

new PreTokenizerSequence(config)

创建一个 PreTokenizerSequence 的实例。

preTokenizerSequence.pre_tokenize_text(text, [options]) ⇒ <code> Array. < string > </code>

依次将序列中的每个预 tokenization 器应用于输入文本。

类型：PreTokenizerSequence 的实例方法
Returns: Array.<string> - 预标记化文本。

tokenizers~WhitespacePreTokenizer

在单词边界上拆分（使用以下正则表达式：\w+|[^\w\s]+）。

类型: tokenizers 的内部类

• ~WhitespacePreTokenizer
  • new WhitespacePreTokenizer(config)
  • .pre_tokenize_text(text, [options]) ⇒ Array.<string>

new WhitespacePreTokenizer(config)

创建一个 WhitespacePreTokenizer 的实例。

whitespacePreTokenizer.pre_tokenize_text(text, [options]) ⇒ <code> Array. < string > </code>

通过在单词边界上拆分输入文本来对其进行预 tokenization。

类型：WhitespacePreTokenizer 的实例方法
返回值：Array.<string> - 通过在空格上拆分输入文本而生成的 token 数组。

tokenizers~WhitespaceSplit ⇐ <code> PreTokenizer </code>

通过空格字符将文本字符串拆分为单独的标记。

类型: tokenizers 的内部类
Extends：PreTokenizer

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

new WhitespaceSplit(config)

创建 WhitespaceSplit 的实例。

whitespaceSplit.pre_tokenize_text(text, [options]) ⇒ <code> Array. < string > </code>

通过在空格字符上拆分输入文本来对其进行预标记化。

类型：WhitespaceSplit 的实例方法
返回值：Array.<string> - 通过在空格上拆分输入文本而生成的 token 数组。

tokenizers~ReplacePreTokenizer

类型: tokenizers 的内部类

• ~ReplacePreTokenizer
  • new ReplacePreTokenizer(config)
  • .pre_tokenize_text(text, [options]) ⇒ Array.<string>

new ReplacePreTokenizer(config)

replacePreTokenizer.pre_tokenize_text(text, [options]) ⇒ <code> Array. < string > </code>

通过替换某些字符来预标记化输入文本。

类型：ReplacePreTokenizer 的实例方法
返回值：Array.<string> - 通过替换某些字符生成的标记数组。

tokenizers~BYTES_TO_UNICODE ⇒ <code> Object </code>

返回 utf-8 字节列表以及到 unicode 字符串的映射。 特别是避免映射到 BPE 代码会出错的空格/控制字符。

类型：tokenizers 的内部常量
返回值：Object - 具有 utf-8 字节键和 unicode 字符串值的对象。

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

从指定路径加载分词器。

类型：tokenizers 的内部方法
返回值：Promise.<Array<any>> - 一个 Promise，它解析为有关已加载分词器的信息。

tokenizers~regexSplit(text, regex) ⇒ <code> Array. < string > </code>

辅助函数，用于在正则表达式上拆分字符串，但保留分隔符。 这是必需的，因为 JavaScript 的 .split() 方法不保留分隔符，并且包装在捕获组中会导致现有捕获组出现问题（由于嵌套）。

类型：tokenizers 的内部方法
返回值：Array.<string> - 拆分后的字符串。

tokenizers~createPattern(pattern, invert) ⇒ <code> RegExp </code> | <code> null </code>

从配置对象构造模式的辅助方法。

类型：tokenizers 的内部方法
返回值：RegExp | null - 编译后的模式。

tokenizers~objectToMap(obj) ⇒ <code> Map. < string, any > </code>

将 Object 转换为 Map 的辅助函数

类型：tokenizers 的内部方法
返回值：Map.<string, any> - Map。

tokenizers~prepareTensorForDecode(tensor) ⇒ <code> Array. < number > </code>

辅助函数，用于在解码之前将张量转换为列表。

类型：tokenizers 的内部方法
返回值：Array.<number> - 作为列表的张量。

tokenizers~clean_up_tokenization(text) ⇒ <code> string </code>

清理简单的英语标记化伪像列表，例如标点符号前的空格和缩写形式

类型：tokenizers 的内部方法
返回值：string - 清理后的文本。

tokenizers~remove_accents(text) ⇒ <code> string </code>

从字符串中删除重音符号的辅助函数。

类型：tokenizers 的内部方法
Returns: string - 去除重音符号的文本。

tokenizers~lowercase_and_remove_accent(text) ⇒ <code> string </code>

将字符串转换为小写并删除重音符号的辅助函数。

类型：tokenizers 的内部方法
返回值：string - 已转换为小写并删除重音符号的文本。

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

在空格上拆分字符串。

类型：tokenizers 的内部方法
返回值：Array.<string> - 拆分后的字符串。

tokenizers~PretrainedTokenizerOptions : <code> Object </code>

其他特定于分词器的属性。

类型：tokenizers 的内部类型定义
属性

tokenizers~BPENode : <code> Object </code>

类型：tokenizers 的内部类型定义
属性

tokenizers~SplitDelimiterBehavior : <code> ’ removed ’ </code> | <code> ’ isolated ’ </code> | <code> ’ mergedWithPrevious ’ </code> | <code> ’ mergedWithNext ’ </code> | <code> ’ contiguous ’ </code>

类型：tokenizers 的内部类型定义

tokenizers~PostProcessedOutput : <code> Object </code>

类型：tokenizers 的内部类型定义
属性

tokenizers~EncodingSingle : <code> Object </code>

类型：tokenizers 的内部类型定义
属性

tokenizers~Message : <code> Object </code>

类型：tokenizers 的内部类型定义
属性

tokenizers~BatchEncoding : <code> Array < number > </code> | <code> Array < Array < number > > </code> | <code> Tensor </code>

保存分词器调用函数的输出。

类型：tokenizers 的内部类型定义
属性