torchtext.transforms

Transforms 是常见的文本转换。它们可以使用 torch.nn.Sequential 或 torchtext.transforms.Sequential 连接在一起，以支持 torch-scriptability。

SentencePieceTokenizer

class torchtext.transforms.SentencePieceTokenizer(sp_model_path: str)

来自预训练的 sentencepiece 模型的 Sentence Piece 分词器转换

更多信息：https://github.com/google/sentencepiece

参数：

sp_model_path (str) – 预训练的 sentencepiece 模型路径

示例

>>> from torchtext.transforms import SentencePieceTokenizer
>>> transform = SentencePieceTokenizer("spm_model")
>>> transform(["hello world", "attention is all you need!"])

使用 SentencePieceTokenizer 的教程

使用 XLM-RoBERTa 模型进行 SST-2 二元文本分类

使用 XLM-RoBERTa 模型进行 SST-2 二元文本分类

forward(input: Any) → Any

参数：

input (Union[str, List[str]]) – 要应用分词器的输入句子或句子列表。

返回值：

分词后的文本

返回类型：

Union[List[str], List[List[str]]]

GPT2BPETokenizer

class torchtext.transforms.GPT2BPETokenizer(encoder_json_path: str, vocab_bpe_path: str, return_tokens: bool = False)

GPT-2 BPE 分词器转换。

在 TorchScript 中重新实现了 openai GPT-2 BPE。原始 openai 实现 https://github.com/openai/gpt-2/blob/master/src/encoder.py

参数：

• encoder_json_path (str) – GPT-2 BPE 编码器 json 文件的路径。

• vocab_bpe_path (str) – bpe 词汇表文件的路径。

• return_tokens – 指示是否返回分割后的标记。如果为 False，它将返回作为字符串的编码标记 ID（默认值：False）

forward(input: Any) → Any

参数：

input (Union[str, List[str]]) – 要应用分词器的输入句子或句子列表。

返回值：

分词后的文本

返回类型：

Union[List[str], List[List(str)]]

CLIPTokenizer

class torchtext.transforms.CLIPTokenizer(merges_path: str, encoder_json_path: Optional[str] = None, num_merges: Optional[int] = None, return_tokens: bool = False)

用于 CLIP 分词器的转换。基于字节级 BPE。

在 TorchScript 中重新实现了 CLIP 分词器。原始实现：https://github.com/mlfoundations/open_clip/blob/main/src/clip/tokenizer.py

此分词器经过训练可以将空格视为标记的一部分（有点像 sentencepiece），因此单词的编码方式将因它是否位于句子的开头（没有空格）而异。

以下代码段展示了如何使用 CLIP 分词器，编码器和合并文件来自原始论文的实现。

示例

>>> from torchtext.transforms import CLIPTokenizer
>>> MERGES_FILE = "http://download.pytorch.org/models/text/clip_merges.bpe"
>>> ENCODER_FILE = "http://download.pytorch.org/models/text/clip_encoder.json"
>>> tokenizer = CLIPTokenizer(merges_path=MERGES_FILE, encoder_json_path=ENCODER_FILE)
>>> tokenizer("the quick brown fox jumped over the lazy dog")

参数：

• merges_path (str) – bpe 合并文件的路径。

• encoder_json_path (str) – 可选，BPE 编码器 json 文件的路径。当指定时，它用于推断 num_merges。

• num_merges (int) – 可选，要从 bpe 合并文件中读取的合并次数。

• return_tokens – 指示是否返回分割后的标记。如果为 False，它将返回作为字符串的编码标记 ID（默认值：False）

forward(input: Any) → Any

参数：

input (Union[str, List[str]]) – 要应用分词器的输入句子或句子列表。

返回值：

分词后的文本

返回类型：

Union[List[str], List[List(str)]]

正则表达式分词器

class torchtext.transforms.RegexTokenizer(patterns_list)

用于字符串句子的正则表达式分词器，它应用了在 patterns_list 中定义的所有正则表达式替换。它由 Google 的 C++ RE2 正则表达式引擎 支持。

参数：

• patterns_list (List[Tuple[str, str]]) – 一系列元组（有序对），包含正则表达式模式字符串

• element. (作为第一个元素，替换字符串作为第二个元素) –

注意事项

• RE2 库不支持任意前瞻或后瞻断言，也不支持反向引用。查看 文档 了解详细信息。

• 最后的标记化步骤始终使用空格作为分隔符。要根据特定正则表达式模式分割字符串，类似于 Python 的 re.split，可以提供一个 ('<regex_pattern>', ' ') 元组。

示例

基于 (patterns, replacements) 列表的正则表达式分词。

>>> import torch
>>> from torchtext.transforms import RegexTokenizer
>>> test_sample = 'Basic Regex Tokenization for a Line of Text'
>>> patterns_list = [
    (r''', ' '  '),
    (r'"', '')]
>>> reg_tokenizer = RegexTokenizer(patterns_list)
>>> jit_reg_tokenizer = torch.jit.script(reg_tokenizer)
>>> tokens = jit_reg_tokenizer(test_sample)

基于 (single_pattern, ' ') 列表的正则表达式分词。

>>> import torch
>>> from torchtext.transforms import RegexTokenizer
>>> test_sample = 'Basic.Regex,Tokenization_for+a..Line,,of  Text'
>>> patterns_list = [
    (r'[,._+ ]+', r' ')]
>>> reg_tokenizer = RegexTokenizer(patterns_list)
>>> jit_reg_tokenizer = torch.jit.script(reg_tokenizer)
>>> tokens = jit_reg_tokenizer(test_sample)

forward(line: str) → List[str]

参数：

lines (str) – 要标记化的文本字符串。

返回值：

正则表达式后的标记列表。

返回类型：

List[str]

BERT 分词器

class torchtext.transforms.BERTTokenizer(vocab_path: str, do_lower_case: bool = True, strip_accents: Optional[bool] = None, return_tokens=False, never_split: Optional[List[str]] = None)

用于 BERT 分词器的转换。

基于论文中介绍的 WordPiece 算法：https://static.googleusercontent.com/media/research.google.com/ja//pubs/archive/37842.pdf

后端内核实现取自 https://github.com/LieluoboAi/radish 并进行了修改。

有关更多详细信息，请参阅 PR https://github.com/pytorch/text/pull/1707 摘要。

以下代码片段展示了如何使用预训练的词典文件使用 BERT 分词器。

示例

>>> from torchtext.transforms import BERTTokenizer
>>> VOCAB_FILE = "https://hugging-face.cn/bert-base-uncased/resolve/main/vocab.txt"
>>> tokenizer = BERTTokenizer(vocab_path=VOCAB_FILE, do_lower_case=True, return_tokens=True)
>>> tokenizer("Hello World, How are you!") # single sentence input
>>> tokenizer(["Hello World","How are you!"]) # batch input

参数：

• vocab_path (str) – 预训练词典文件的路径。该路径可以是本地路径或 URL。

• do_lower_case (Optional[bool]) – 指示是否进行小写转换。（默认值：True）

• strip_accents (Optional[bool]) – 指示是否去除重音。（默认值：None）

• return_tokens (bool) – 指示是否返回标记。如果为 False，则返回相应的标记 ID 作为字符串（默认值：False）

• never_split (Optional[List[str]]) – 在标记化过程中不会被分割的标记集合。（默认值：None）

forward(input: Any) → Any

参数：

input (Union[str, List[str]]) – 要应用分词器的输入句子或句子列表。

返回值：

分词后的文本

返回类型：

Union[List[str], List[List(str)]]

词典转换

class torchtext.transforms.VocabTransform(vocab: Vocab)

词典转换，用于将输入标记批次转换为相应的标记 ID

参数：

vocab – torchtext.vocab.Vocab 类的一个实例。

示例

>>> import torch
>>> from torchtext.vocab import vocab
>>> from torchtext.transforms import VocabTransform
>>> from collections import OrderedDict
>>> vocab_obj = vocab(OrderedDict([('a', 1), ('b', 1), ('c', 1)]))
>>> vocab_transform = VocabTransform(vocab_obj)
>>> output = vocab_transform([['a','b'],['a','b','c']])
>>> jit_vocab_transform = torch.jit.script(vocab_transform)

使用 VocabTransform 的教程

使用 XLM-RoBERTa 模型进行 SST-2 二元文本分类

使用 XLM-RoBERTa 模型进行 SST-2 二元文本分类

forward(input: Any) → Any

参数：

input (Union[List[str], List[List[str]]]) – 要转换为相应标记 ID 的标记的输入批次

返回值：

转换为相应标记 ID 的输入

返回类型：

Union[List[int], List[List[int]]]

转换为张量

class torchtext.transforms.ToTensor(padding_value: Optional[int] = None, dtype: dtype = torch.int64)

将输入转换为 PyTorch 张量

参数：

• padding_value (可选[int]) – 填充值，使批次中每个输入的长度等于批次中最长序列的长度。

• dtype (torch.dtype) – 输出张量的 torch.dtype

forward(input: Any) → Tensor

参数：

input (Union[List[int], List[List[int]]]) – 标记 ID 序列或批次

返回类型：

张量

LabelToIndex

class torchtext.transforms.LabelToIndex(label_names: Optional[List[str]] = None, label_path: Optional[str] = None, sort_names=False)

将标签从字符串名称转换为 ID。

参数：

• label_names (可选[List[str]]) – 唯一的标签名称列表

• label_path (可选[str]) – 包含唯一标签名称的文件路径，每行包含一个标签。请注意，应提供 label_names 或 label_path，但不能同时提供。

forward(input: Any) → Any

参数：

input (Union[str, List[str]]) – 要转换为相应 ID 的输入标签

返回类型：

Union[int, List[int]]

Truncate

class torchtext.transforms.Truncate(max_seq_len: int)

截断输入序列

参数：

max_seq_len (int) – 输入序列允许的最大长度

使用 Truncate 的教程

使用 XLM-RoBERTa 模型进行 SST-2 二元文本分类

使用 XLM-RoBERTa 模型进行 SST-2 二元文本分类

forward(input: Any) → Any

参数：

input (Union[List[Union[str, int]], List[List[Union[str, int]]]]) – 要截断的输入序列或序列批次

返回值：

截断的序列

返回类型：

Union[List[Union[str, int]], List[List[Union[str, int]]]]

AddToken

class torchtext.transforms.AddToken(token: Union[int, str], begin: bool = True)

在序列的开头或结尾添加标记

参数：

• token (Union[int, str]) – 要添加的标记

• begin (bool, 可选) – 是否在序列的开头或结尾插入标记，默认为 True

使用 AddToken 的教程

使用 XLM-RoBERTa 模型进行 SST-2 二元文本分类

使用 XLM-RoBERTa 模型进行 SST-2 二元文本分类

forward(input: Any) → Any

参数：

input (Union[List[Union[str, int]], List[List[Union[str, int]]]]) – 输入序列或批次

Sequential

class torchtext.transforms.Sequential(*args: Module)

class torchtext.transforms.Sequential(arg: OrderedDict[str, Module])

用于容纳一系列文本转换的容器。

使用 Sequential 的教程

使用 XLM-RoBERTa 模型进行 SST-2 二元文本分类

使用 XLM-RoBERTa 模型进行 SST-2 二元文本分类

forward(input: Any) → Any

参数：

input (Any) – 输入序列或批次。 输入类型必须被序列中的第一个转换支持。

PadTransform

class torchtext.transforms.PadTransform(max_length: int, pad_value: int)

使用给定的填充值将张量填充到固定长度。

参数：

• max_length (int) – 要填充到的最大长度

• pad_value (bool) – 用来填充张量的值

forward(x: Tensor) → Tensor

参数：

x (Tensor) – 要填充的张量

返回值：

用 pad_value 填充到 max_length 的张量

返回类型：

张量

StrToIntTransform

class torchtext.transforms.StrToIntTransform

将字符串标记转换为整数（单个序列或批次）。

forward(input: Any) → Any

参数：

input (Union[List[str], List[List[str]]]) – 要转换的字符串标记的序列或批次

返回值：

转换为相应标记 ID 的序列或批次

返回类型：

Union[List[int], List[List[int]]]

CharBPETokenizer

class torchtext.transforms.CharBPETokenizer(bpe_encoder_path: str, bpe_merges_path: str, return_tokens: bool = False, unk_token: Optional[str] = None, suffix: Optional[str] = None, special_tokens: Optional[List[str]] = None)

字符字节对编码分词器的转换。

:param : param bpe_encoder_path: BPE 编码器 json 文件的路径。 :param : type bpe_encoder_path: str :param : param bpe_merges_path: BPE 合并文本文件的路径。 :param : type bpe_merges_path: str :param : param return_tokens: 指示是否返回拆分的标记。 如果为 False，它将返回编码的标记 ID（默认：False）。 :param : type return_tokens: bool :param : param unk_token: 未知标记。 如果提供，它必须存在于编码器中。 :param : type unk_token: Optional[str] :param : param suffix: 用于每个作为词尾的子词的后缀。 :param : type suffix: Optional[str] :param : param special_tokens: 不应拆分为单个字符的特殊标记。 如果提供，这些必须存在于编码器中。 :param : type special_tokens: Optional[List[str]]

forward(input: Union[str, List[str]]) → Union[List, List[List]]

模块的正向方法将字符串或字符串列表编码为标记 ID

参数：

input – 要应用分词器的输入句子或句子列表。

返回值：

标记 ID 的列表或列表列表