Nvtext 分词#

group nvtext_tokenize

函数

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

文件中的对应该按照它们之间的相对排名进行排序。文件中较早出现的对优先于其下方的任何对。

Throws:

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

Parameters:

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

Returns:

一个 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::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"]

Throws:

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

Parameters:

input – 要编码的字符串。
merges_pairs – 由调用 nvtext::load_merge_pairs 创建。
separator – 用于在编码后构建输出的字符串。默认为空格。
mr – 用于分配任何返回对象的内存资源。

Returns:

一个编码的字符串列。

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，而无需每次加载相同文件的成本。

Throws:

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

Parameters:

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

Returns:

词汇哈希表元素

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())#

创建一个分词器，用于清理文本，将其分割成标记，并从输入词汇表中返回标记ID。

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

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

本质上，每个字符串在输出列中被转换为一个或多个标记ID的向量。这些向量的总数乘以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，每个输出字符串的行数取决于解析的标记数量和 stride 值，这可能会在后续的溢出行中重复标记。

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

Throws:

cudf::logic_error – 如果 stride > max_sequence_length
std::overflow_error – 如果 max_sequence_length * max_rows_tensor 超过列大小限制

Parameters:

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

Returns:

token-ids, attention-mask, 和 metadata

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 为空，则使用空白字符（字符代码点 <= ‘ ‘）来识别标记。此外，字符串中发现的任何连续分隔符都会被忽略。这意味着只返回非空的标记。

通过从每个字符串的开头定位分隔符来找到标记。当每个字符串被标记化时，标记会按照输入列的行顺序附加以构建输出列。也就是说，在输入行[i]中找到的标记将直接放在输入行[i+1]中找到的标记之前。

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

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

Parameters:

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

Returns:

新的字符串列，包含标记

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())#

通过使用多个字符串作为分隔符对输入字符串列进行标记化，返回一个字符串列。

通过从每个字符串的开头开始定位分隔符来找到标记。字符串中发现的任何连续分隔符都会被忽略。这意味着只返回非空的标记。

当每个字符串被分词时，分词结果会按照输入列的行顺序附加到输出列中。也就是说，在输入行[i]中找到的分词将直接放在输入行[i+1]中找到的分词之前。

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

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

Throws:

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

Parameters:

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

Returns:

新的字符串列，包含标记

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())#

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

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

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

所有空行条目将被忽略，输出包含所有有效行。在输出列中，空元素的标记数设置为0。

Parameters:

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

Returns:

新的标记计数列

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())#

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

此外，字符串中发现的任何连续分隔符都会被忽略。这意味着只有空字符串或空行才会导致标记计数为0。

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

所有空行条目将被忽略，输出包含所有有效行。在输出列中，空元素的标记数设置为0。

Throws:

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

Parameters:

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

Returns:

新的标记计数列

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"]

Throws:

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

Parameters:

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

Returns:

新的字符串列，包含标记

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())#

从标记的字符串列和相关的行ID列创建一个字符串列。

输入列中的多个标记可能会被合并为输出列中的单一行（字符串）。这些标记按照它们在row_indices列中出现的顺序，与separator字符串一起连接。

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"]

所有空行条目将被忽略，输出包含所有有效行。row_indices中的值应为正数且连续，不能有任何缺失的行索引，否则输出将是未定义的。

Throws:

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

Parameters:

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

Returns:

新的字符串列，包含标记

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对象。

令牌ID是词汇表列中的行索引。每个词汇表条目预期是唯一的，否则行为是未定义的。

Throws:

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

Parameters:

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

Returns:

用于与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())#

通过查找给定词汇表中的每个分隔标记，返回输入字符串的标记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]]

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

Throws:

cudf::logic_error – 如果 delimiter 无效

Parameters:

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

Returns:

列出标记ID的列

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合并对对象。

Parameters:

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合并对对象。

Parameters:

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

struct hashed_vocabulary#

#include <subword_tokenize.hpp>

用于subword_tokenize函数的词汇数据。

公共成员

uint16_t first_token_id = {}#: 词汇表中的第一个标记ID。

uint16_t separator_token_id = {}#: 词汇表中的分隔符标记ID。

uint16_t unknown_token_id = {}#: 词汇表中未知的标记ID。

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

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

uint16_t num_bins = {}#: 箱子的数量。

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 列，包含扁平化哈希表中每个 bin 的起始索引

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

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

struct tokenizer_result#

#include <subword_tokenize.hpp>

subword_tokenize 函数的结果对象。

公共成员

uint32_t nrows_tensor = {}#: 输出令牌ID的行数。

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

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

每行的token-id向量。

数据是一个平坦的矩阵（nrows_tensor x sequence_length），包含令牌ID。此列的类型为UINT32，且没有空条目。

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

此掩码标识哪些张量-令牌-ID是有效的。

此列的类型为UINT32，没有空条目。

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

每个张量行的元数据。

每个张量行有三个元素 [行号, 起始位置, 结束位置]) 该列的类型为 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())#

词汇对象构造函数。

令牌ID是词汇表列中的行索引。每个词汇表条目预期是唯一的，否则行为是未定义的。

Throws:

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

Parameters:

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