Nvtext 分词#

group 分词

函数

std::unique_ptr<bpe_merge_pairs> load_merge_pairs(cudf::strings_column_view const &merge_pairs, rmm::cuda_stream_view stream = cudf::get_default_stream(), rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref())#

从字符串列创建 nvtext::bpe_merge_pairs 对象。

输入列应包含每行一个唯一的字符串对，它们由单个空格分隔。不正确的格式或非唯一条目将导致未定义的行为。

示例

merge_pairs = ["e n", "i t", "i s", "e s", "en t", "c e", "es t", "en ce", "t est", "s ent"]
mps = load_merge_pairs(merge_pairs)
// the mps object can be passed to the byte_pair_encoding API

期望这些对在文件中按照它们之间的相对排序进行排列。文件中位置靠前的对优先于其后的任何对。

抛出:

cudf::logic_error – 如果 merge_pairs 为空或包含 null

参数:

merge_pairs – 包含唯一合并对的列
stream – 用于设备内存操作和内核启动的 CUDA 流
mr – 分配任何返回对象的内存资源

返回:

一个 nvtext::bpe_merge_pairs 对象

std::unique_ptr<cudf::column> byte_pair_encoding(cudf::strings_column_view const &input, bpe_merge_pairs const &merges_pairs, cudf::string_scalar const &separator = cudf::string_scalar(" "), rmm::cuda_stream_view stream = cudf::get_default_stream(), rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref())#

对输入字符串进行字节对编码。

编码算法通过匹配 merge_pairs 表中的子字符串，并迭代移除排序最低的对，直到没有剩余的对。然后，在将结果连接成输出字符串之前，将分隔符插入到剩余的对之间。

merge_pairs = ["e n", "i t", "i s", "e s", "en t", "c e", "es t", "en ce", "t est", "s ent"]
mps = load_merge_pairs(merge_pairs)
input = ["test sentence", "thisis test"]
result = byte_pair_encoding(input, mps)
result is now ["test sent ence", "this is test"]

抛出:

cudf::logic_error – 如果 merge_pairs 为空
cudf::logic_error – 如果 separator 无效

参数:

input – 要编码的字符串。
merges_pairs – 通过调用 nvtext::load_merge_pairs 创建。
separator – 编码后用于构建输出的字符串。默认为空格。
stream – 用于设备内存操作和内核启动的 CUDA 流
mr – 分配任何返回对象的内存资源。

返回:

一个编码后的字符串列。

std::unique_ptr<hashed_vocabulary> load_vocabulary_file(std::string const &filename_hashed_vocabulary, rmm::cuda_stream_view stream = cudf::get_default_stream(), rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref())#

将哈希词汇文件加载到设备内存中。

此处创建的对象可用于调用 subword_tokenize，而无需每次都承担加载同一文件的开销。

抛出:

cudf::logic_error – 如果无法打开 filename_hashed_vocabulary。

参数:

filename_hashed_vocabulary – 指向预处理后的 vocab.txt 文件的路径。请注意，这是在使用 python/perfect_hash.py 进行预处理 *之后* 的文件。
stream – 用于设备内存操作和内核启动的 CUDA 流
mr – 分配任何返回对象的内存资源。

返回:

词汇哈希表元素

tokenizer_result subword_tokenize(cudf::strings_column_view const &strings, hashed_vocabulary const &vocabulary_table, uint32_t max_sequence_length, uint32_t stride, bool do_lower_case, bool do_truncate, rmm::cuda_stream_view stream = cudf::get_default_stream(), rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref())#

创建一个分词器，用于清理文本、将其分割成 token 并从输入词汇中返回 token-ids。

首先，通过转换为小写、移除标点符号、替换一组选定的多字节字符和空白字符来规范化字符串。

然后，使用空白字符作为分隔符对字符串进行分词。连续的分隔符将被忽略。然后，从提供的词汇表中映射每个 token，并为其分配一个 4 字节的 token-id。

本质上，每个字符串在输出列中被转换为一个或多个 token-ids 向量。这些向量的总数乘以 max_sequence_length 就是 tensor_token_ids 输出列的大小。对于 do_truncate==true

size of tensor_token_ids = max_sequence_length * strings.size()
size of tensor_attention_mask = max_sequence_length * strings.size()
size of tensor_metadata = 3 * strings.size()

对于 do_truncate==false，每个输出字符串的行数取决于解析的 token 数量和 stride 值，这可能会在后续溢出行中重复 token。

此函数需要输入字符串列中字符字节数的约 21 倍作为工作内存。

抛出:

cudf::logic_error – 如果 stride > max_sequence_length
std::overflow_error – 如果输出将产生超过 size_type 最大行数

参数:

strings – 要分词的输入字符串。
vocabulary_table – 预加载到此对象中的词汇表。
max_sequence_length – 最终 tensor 中每个字符串每行的 token-ids 数量限制。
stride – 输出 token-ids 中的每一行将复制前一行 max_sequence_length - stride 个 token-ids，除非它是第一个字符串。
do_lower_case – 如果为 true，分词器将把输入流中的大写字符转换为小写，并移除这些字符上的重音符号。如果为 false，带重音和大写的字符将不会被转换。
do_truncate – 如果为 true，分词器将丢弃每个输入字符串在 max_sequence_length 之后的所有 token-ids。如果为 false，它将在输出 token-ids 中使用新行继续生成输出。
stream – 用于设备内存操作和内核启动的 CUDA 流
mr – 分配任何返回对象的内存资源。

返回:

token-ids、attention-mask 和元数据

std::unique_ptr<cudf::column> tokenize(cudf::strings_column_view const &input, cudf::string_scalar const &delimiter = cudf::string_scalar{""}, rmm::cuda_stream_view stream = cudf::get_default_stream(), rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref())#

通过使用提供的字符作为分隔符对输入字符串列进行分词，返回一个包含字符串的列。

delimiter 可以是零个或多个字符。如果 delimiter 为空，则使用空白字符（字符代码点 <= ‘ ‘）来识别 token。此外，字符串中找到的任何连续分隔符都将被忽略。这意味着仅返回非空 token。

通过在每个字符串的开头查找分隔符来找到 token。分词每个字符串时，token 将按输入列的行顺序追加，以构建输出列。也就是说，在输入行 [i] 中找到的 token 将直接放在输出列中，位于输入行 [i+1] 中找到的 token 之前。

Example:
s = ["a", "b c", "d  e f "]
t = tokenize(s)
t is now ["a", "b", "c", "d", "e", "f"]

所有 null 行条目都将被忽略，输出包含所有有效行。

参数:

input – 要分词的字符串列
delimiter – 用于将每个字符串分隔成 token 的 UTF-8 字符。默认的空字符串将使用空白字符分隔 token。
stream – 用于设备内存操作和内核启动的 CUDA 流
mr – 用于分配返回列的设备内存的设备内存资源

返回:

新的 token 字符串列

std::unique_ptr<cudf::column> tokenize(cudf::strings_column_view const &input, cudf::strings_column_view const &delimiters, rmm::cuda_stream_view stream = cudf::get_default_stream(), rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref())#

通过使用多个字符串作为分隔符对输入字符串列进行分词，返回一个包含字符串的列。

通过在每个字符串的开头查找分隔符来找到 token。字符串中找到的任何连续分隔符都将被忽略。这意味着仅返回非空 token。

分词每个字符串时，token 将按输入列的行顺序追加，以构建输出列。也就是说，在输入行 [i] 中找到的 token 将直接放在输出列中，位于输入行 [i+1] 中找到的 token 之前。

Example:
s = ["a", "b c", "d.e:f;"]
d = [".", ":", ";"]
t = tokenize(s,d)
t is now ["a", "b c", "d", "e", "f"]

所有 null 行条目都将被忽略，输出包含所有有效行。

抛出:

cudf::logic_error – 如果分隔符列为空或包含 null。

参数:

input – 要分词的字符串列
delimiters – 用于将单个字符串分隔成 token 的字符串
stream – 用于设备内存操作和内核启动的 CUDA 流
mr – 用于分配返回列的设备内存的设备内存资源

返回:

新的 token 字符串列

std::unique_ptr<cudf::column> count_tokens(cudf::strings_column_view const &input, cudf::string_scalar const &delimiter = cudf::string_scalar{""}, rmm::cuda_stream_view stream = cudf::get_default_stream(), rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref())#

返回字符串列中每个字符串的 token 数量。

delimiter 可以是零个或多个字符。如果 delimiter 为空，则使用空白字符（字符代码点 <= ‘ ‘）来识别 token。此外，字符串中找到的任何连续分隔符都将被忽略。这意味着只有空字符串或 null 行的 token 计数为 0。

Example:
s = ["a", "b c", " ", "d e f"]
t = count_tokens(s)
t is now [1, 2, 0, 3]

所有 null 行条目都将被忽略，输出包含所有有效行。输出列中 null 元素的 token 数量设为 0。

参数:

input – 要计数 token 的字符串列
delimiter – 用于将每个字符串分隔成 token 的字符串。默认的空字符串将使用空白字符分隔 token。
stream – 用于设备内存操作和内核启动的 CUDA 流
mr – 用于分配返回列的设备内存的设备内存资源

返回:

新的 token 计数列

std::unique_ptr<cudf::column> count_tokens(cudf::strings_column_view const &input, cudf::strings_column_view const &delimiters, rmm::cuda_stream_view stream = cudf::get_default_stream(), rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref())#

通过使用多个字符串分隔符来识别每个字符串中的 token，返回字符串列中每个字符串的 token 数量。

此外，字符串中找到的任何连续分隔符都将被忽略。这意味着只有空字符串或 null 行的 token 计数为 0。

Example:
s = ["a", "b c", "d.e:f;"]
d = [".", ":", ";"]
t = count_tokens(s,d)
t is now [1, 1, 3]

所有 null 行条目都将被忽略，输出包含所有有效行。输出列中 null 元素的 token 数量设为 0。

抛出:

cudf::logic_error – 如果分隔符列为空或包含 null

参数:

input – 要计数 token 的字符串列
delimiters – 用于将每个字符串分隔成 token 的字符串
stream – 用于设备内存操作和内核启动的 CUDA 流
mr – 用于分配返回列的设备内存的设备内存资源

返回:

新的 token 计数列

std::unique_ptr<cudf::column> character_tokenize(cudf::strings_column_view const &input, rmm::cuda_stream_view stream = cudf::get_default_stream(), rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref())#

通过将每个字符转换为字符串，返回一个包含字符串的列。

每个字符串被转换为多个字符串 — 每个字符一个。请注意，一个字符可能占用多个字节。

Example:
s = ["hello world", null, "goodbye"]
t = character_tokenize(s)
t is now ["h","e","l","l","o"," ","w","o","r","l","d","g","o","o","d","b","y","e"]

抛出:

std::invalid_argument – 如果 input 包含 null
std::overflow_error – 如果输出将产生超过 size_type 最大行数

参数:

input – 要分词的字符串列
stream – 用于设备内存操作和内核启动的 CUDA 流
mr – 用于分配返回列的设备内存的设备内存资源

返回:

新的 token 字符串列

std::unique_ptr<cudf::column> detokenize(cudf::strings_column_view const &input, cudf::column_view const &row_indices, cudf::string_scalar const &separator = cudf::string_scalar(" "), rmm::cuda_stream_view stream = cudf::get_default_stream(), rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref())#

从 token 字符串列和关联的行 ID 列创建字符串列。

输入列中的多个 token 可以合并到输出列中的单个行（字符串）中。token 将与 separator 字符串一起，按照它们在 row_indices 列中出现的顺序进行连接。

Example:
s = ["hello", "world", "one", "two", "three"]
r = [0, 0, 1, 1, 1]
s1 = detokenize(s,r)
s1 is now ["hello world", "one two three"]
r = [0, 2, 1, 1, 0]
s2 = detokenize(s,r)
s2 is now ["hello three", "one two", "world"]

所有 null 行条目都将被忽略，输出包含所有有效行。row_indices 中的值应为正数、顺序值，且没有任何缺失的行 ID，否则输出将是未定义的。

抛出:

cudf::logic_error – 如果 separator 无效
cudf::logic_error – 如果 row_indices.size() != strings.size()
cudf::logic_error – 如果 row_indices 包含 null

参数:

input – 要 detokenize 的字符串列
row_indices – 输入列中分配给每个 token 的相对输出行索引
separator – 在将每个 token 连接到相应的输出行后附加的字符串
stream – 用于设备内存操作和内核启动的 CUDA 流
mr – 用于分配返回列的设备内存的设备内存资源

返回:

新的 token 字符串列

std::unique_ptr<tokenize_vocabulary> load_vocabulary(cudf::strings_column_view const &input, rmm::cuda_stream_view stream = cudf::get_default_stream(), rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref())#

从字符串列创建一个 tokenize_vocabulary 对象。

Token ID 是词汇列中的行索引。每个词汇条目应是唯一的，否则行为未定义。

抛出:

cudf::logic_error – 如果 vocabulary 包含 null 或为空

参数:

input – 用于构建词汇的字符串
stream – 用于设备内存操作和内核启动的 CUDA 流
mr – 用于分配返回列的设备内存的设备内存资源

返回:

用于与 nvtext::tokenize_with_vocabulary 一起使用的对象

std::unique_ptr<cudf::column> tokenize_with_vocabulary(cudf::strings_column_view const &input, tokenize_vocabulary const &vocabulary, cudf::string_scalar const &delimiter, cudf::size_type default_id = -1, rmm::cuda_stream_view stream = cudf::get_default_stream(), rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref())#

通过在给定词汇表中查找每个分隔的 token，返回输入字符串的 token ID。

Example:
s = ["hello world", "hello there", "there there world", "watch out world"]
v = load_vocabulary(["hello", "there", "world"])
r = tokenize_with_vocabulary(s,v)
r is now [[0,2], [0,1], [1,1,2], [-1,-1,2]]

任何 null 行条目在输出中都会产生相应的 null 条目

抛出:

cudf::logic_error – 如果 delimiter 无效

参数:

input – 要分词的字符串列
vocabulary – 用于在 input 中查找 token
delimiter – 用于在 input 中识别 token
default_id – 用于词汇表中未找到的 token 的 token ID；默认为 -1
stream – 用于设备内存操作和内核启动的 CUDA 流
mr – 用于分配返回列的设备内存的设备内存资源

返回:

token ID 的 Lists 列

std::unique_ptr<wordpiece_vocabulary> load_wordpiece_vocabulary(cudf::strings_column_view const &input, rmm::cuda_stream_view stream = cudf::get_default_stream(), rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref())#

从字符串列创建一个 tokenize_vocabulary 对象。

Token ID 是词汇列中的行索引。每个词汇条目应是唯一的，否则行为未定义。

抛出:

std::invalid_argument – 如果 vocabulary 包含 null 或为空

参数:

input – 用于构建词汇的字符串
stream – 用于设备内存操作和内核启动的 CUDA 流
mr – 用于分配返回列的设备内存的设备内存资源

返回:

用于与 nvtext::tokenize_with_vocabulary 一起使用的对象

std::unique_ptr<cudf::column> wordpiece_tokenize(cudf::strings_column_view const &input, wordpiece_vocabulary const &vocabulary, cudf::size_type max_words_per_row = 0, rmm::cuda_stream_view stream = cudf::get_default_stream(), rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref())#

使用给定的词汇表和 Wordpiece 分词器算法返回输入字符串的 token ID。

示例

vocabulary = ["[UNK]", "a", "have", "I", "new", "GP", "##U", "!"]
v = load_wordpiece_vocabulary(vocabulary)
input = ["I have a new GPU now !"]
t = wordpiece_tokenize(i,v)
t is now [[3, 2, 1, 4, 5, 6, 0, 7]]

max_words_per_row 也可选择通过仅处理每行最大数量的词来限制输出。此处，词被定义为由空格字符分隔的连续字符序列。

示例

vocabulary = ["[UNK]", "a", "have", "I", "new", "GP", "##U", "!"]
v = load_wordpiece_vocabulary(vocabulary)
input = ["I have  a new GPU now !"]
t4 = wordpiece_tokenize(i,v,4)
t4 is now [[3, 2, 1, 4]]
t5 = wordpiece_tokenize(i,v,5)
t5 is now [[3, 2, 1, 4, 5, 6]]

任何 null 行条目在输出中都会产生相应的 null 条目。

参数:

input – 要分词的字符串列
vocabulary – 用于在 input 中查找 token
max_words_per_row – 每行要分词的最大词数。默认值为 0 表示分词所有词。
stream – 用于设备内存操作和内核启动的 CUDA 流
mr – 用于分配返回列的设备内存的设备内存资源

返回:

token ID 的 Lists 列

struct bpe_merge_pairs#

#include <byte_pair_encoding.hpp>

BPE 编码器的合并对表。

要创建实例，请调用 nvtext::load_merge_pairs

公共函数

bpe_merge_pairs(std::unique_ptr<cudf::column> &&input, rmm::cuda_stream_view stream = cudf::get_default_stream(), rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref())#

构造新的 bpe 合并对对象。

参数:

input – 包含 BPE 合并对的输入文件
stream – 用于设备内存操作和内核启动的 CUDA 流。
mr – 用于分配设备内存的设备内存资源

bpe_merge_pairs(cudf::strings_column_view const &input, rmm::cuda_stream_view stream = cudf::get_default_stream(), rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref())#

构造新的 bpe 合并对对象。

参数:

input – 输入的字符串列
stream – 用于设备内存操作和内核启动的 CUDA 流。
mr – 用于分配设备内存的设备内存资源

struct hashed_vocabulary#

#include <subword_tokenize.hpp>

用于 subword_tokenize 函数的词汇数据。

公共成员

uint16_t first_token_id = {}#: 词汇表中的第一个 token id。

uint16_t separator_token_id = {}#: 词汇表中的分隔符 token id。

uint16_t unknown_token_id = {}#: 词汇表中的未知 token id。

uint32_t outer_hash_a = {}#: 外层哈希的参数 a。

uint32_t outer_hash_b = {}#: 外层哈希的参数 b。

uint16_t num_bins = {}#: 桶（bin）的数量。

std::unique_ptr<cudf::column> table#: uint64 列，扁平化的哈希表，包含打包在 64 位中的键值对

std::unique_ptr<cudf::column> bin_coefficients#: uint64 列，包含 GPU 上每个哈希桶的哈希参数

std::unique_ptr<cudf::column> bin_offsets#: uint16 列，包含扁平化哈希表中每个桶的起始索引

std::unique_ptr<cudf::column> cp_metadata#: uint32 列，用于规范化的码点元数据表

std::unique_ptr<cudf::column> aux_cp_table#: uint64 列，用于规范化的辅助码点表

struct tokenizer_result#

#include <subword_tokenize.hpp>

subword_tokenize 函数的结果对象。

公共成员

uint32_t nrows_tensor = {}#: 输出 token id 的行数。

uint32_t sequence_length = {}#: 每行的 token id 数量。

std::unique_ptr<cudf::column> tensor_token_ids#

每行的 token id 向量。

数据是一个扁平矩阵（nrows_tensor x sequence_length），包含 token id。此列类型为 UINT32，无空条目。

std::unique_ptr<cudf::column> tensor_attention_mask#

此掩码标识哪些张量 token id 有效。

此列类型为 UINT32，无空条目。

std::unique_ptr<cudf::column> tensor_metadata#

每个张量行的元数据。

每个张量行有三个元素 [行 id, 开始位置, 停止位置]) 此列类型为 UINT32，无空条目。

struct tokenize_vocabulary#

#include <tokenize.hpp>

与 nvtext::tokenize_with_vocabulary 一起使用的词汇对象。

使用 nvtext::load_vocabulary 创建此对象。

公共函数

tokenize_vocabulary(cudf::strings_column_view const &input, rmm::cuda_stream_view stream = cudf::get_default_stream(), rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref())#

词汇对象构造函数。

Token ID 是词汇列中的行索引。每个词汇条目应是唯一的，否则行为未定义。

抛出:

cudf::logic_error – 如果 vocabulary 包含 null 或为空

参数:

input – 用于构建词汇的字符串
stream – 用于设备内存操作和内核启动的 CUDA 流
mr – 用于分配返回列的设备内存的设备内存资源

struct wordpiece_vocabulary#

#include <wordpiece_tokenize.hpp>

与 nvtext::wordpiece_tokenizer 一起使用的词汇对象。

使用 nvtext::load_wordpiece_vocabulary 创建此对象。

公共函数

wordpiece_vocabulary(cudf::strings_column_view const &input, rmm::cuda_stream_view stream = cudf::get_default_stream(), rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref())#

词汇对象构造函数。

Token ID 是词汇列中的行索引。每个词汇条目应是唯一的，否则行为未定义。

抛出:

std::invalid_argument – 如果 vocabulary 包含 null 或为空

参数:

input – 用于构建词汇的字符串
stream – 用于设备内存操作和内核启动的 CUDA 流
mr – 用于分配返回列的设备内存的设备内存资源

Nvtext 分词#

此页