---

TensorFlow Text - TensorFlow 中的文本处理

重要提示：使用 pip install 安装 TF Text（TensorFlow Text）时，请注意您正在运行的 TensorFlow 版本，因为您应该指定相应次要版本的 TF Text（例如，对于 tensorflow==2.3.x，请使用 tensorflow_text==2.3.x）。

目录

• 简介
• 文档
• Unicode
• 规范化
• 分词
  • 空白字符分词器
  • Unicode 脚本分词器
  • Unicode 分割
  • 偏移量
  • TF.Data 示例
  • Keras API
• 其他文本操作
  • 单词形状
  • N-gram 与滑动窗口
• 安装
  • 使用 PIP 安装
  • 从源代码构建步骤：

简介

TensorFlow Text 提供了一系列与文本相关的类和操作 (ops)，可直接用于 TensorFlow 2.0。该库可以执行基于文本的模型通常所需的预处理，并包含核心 TensorFlow 未提供的对序列建模有用的其他功能。

在文本预处理中使用这些操作的好处是，它们是在 TensorFlow 计算图内完成的。您无需担心训练时的分词 (tokenization) 与推理时的分词不同，也无需管理预处理脚本。

文档

请访问 http://tensorflow.org/text 查看所有文档。该网站包括 API 文档、关于如何使用 TensorFlow Text 的指南，以及构建特定模型的教程。

Unicode

大多数操作 (ops) 期望字符串为 UTF-8 格式。如果您使用不同的编码，可以使用核心 TensorFlow 的转码操作 (transcode op) 将其转码为 UTF-8。如果您的输入可能无效，您也可以使用相同的操作将您的字符串强制转换为结构上有效的 UTF-8。

docs = tf.constant([u'Everything not saved will be lost.'.encode('UTF-16-BE'),
                    u'Sad☹'.encode('UTF-16-BE')])
utf8_docs = tf.strings.unicode_transcode(docs, input_encoding='UTF-16-BE',
                                         output_encoding='UTF-8')

规范化

在处理不同来源的文本时，确保相同的单词被识别为相同非常重要。Unicode 中大小写不敏感匹配的常用技术是大小写折叠 (case folding)（类似于小写化 (lower-casing)）。（注意，大小写折叠内部应用了 NFKC 规范化。）

我们还提供了 Unicode 规范化操作，用于将字符串转换为字符的标准表示形式，默认情况下为规范化形式 KC（NFKC）。

print(text.case_fold_utf8(['Everything not saved will be lost.']))
print(text.normalize_utf8(['Äffin']))
print(text.normalize_utf8(['Äffin'], 'nfkd'))

tf.Tensor(['everything not saved will be lost.'], shape=(1,), dtype=string)
tf.Tensor(['\xc3\x84ffin'], shape=(1,), dtype=string)
tf.Tensor(['A\xcc\x88ffin'], shape=(1,), dtype=string)

分词

分词 (Tokenization) 是将字符串拆分为标记 (tokens) 的过程。通常，这些标记是单词、数字和/或标点符号。

主要接口是 Tokenizer 和 TokenizerWithOffsets，它们分别只有一个方法 tokenize 和 tokenizeWithOffsets。目前有多种实现的分词器可用。每一个都实现了 TokenizerWithOffsets（它扩展了 Tokenizer），其中包括获取原始字符串字节偏移量的选项。这使得调用者能够知道创建该标记的原始字符串中的字节。

所有分词器都返回 RaggedTensors（不规则张量），其中标记的最内维映射到原始的各个字符串。因此，结果形状的秩 (rank) 增加了一。如果您不熟悉它们，请查阅 ragged tensor 指南。https://www.tensorflow.org/guide/ragged_tensor

WhitespaceTokenizer

这是一个基本的分词器，它在 ICU (International Components for Unicode) 定义的空白字符（如空格、制表符、换行）处拆分 UTF-8 字符串。

tokenizer = text.WhitespaceTokenizer()
tokens = tokenizer.tokenize(['everything not saved will be lost.', u'Sad☹'.encode('UTF-8')])
print(tokens.to_list())

[['everything', 'not', 'saved', 'will', 'be', 'lost.'], ['Sad\xe2\x98\xb9']]

UnicodeScriptTokenizer

此分词器根据 Unicode 脚本边界拆分 UTF-8 字符串。使用的脚本代码对应于国际组件库 for Unicode (ICU) 的 UScriptCode 值。参见：http://icu-project.org/apiref/icu4c/uscript_8h.html

在实践中，这与 WhitespaceTokenizer 类似，最明显的区别在于它会区分标点符号（USCRIPT_COMMON）和语言文本（例如 USCRIPT_LATIN, USCRIPT_CYRILLIC 等），同时也会将不同的语言文本彼此分开。

tokenizer = text.UnicodeScriptTokenizer()
tokens = tokenizer.tokenize(['everything not saved will be lost.',
                             u'Sad☹'.encode('UTF-8')])
print(tokens.to_list())

[['everything', 'not', 'saved', 'will', 'be', 'lost', '.'],
 ['Sad', '\xe2\x98\xb9']]

Unicode 分割

在对没有空格的语言进行分词以分割单词时，通常只需按字符分割，这可以使用核心中的 unicode_split 操作符 (op) 来实现。

tokens = tf.strings.unicode_split([u"仅今年前".encode('UTF-8')], 'UTF-8')
print(tokens.to_list())

[['\xe4\xbb\x85', '\xe4\xbb\x8a', '\xe5\xb9\xb4', '\xe5\x89\x8d']]

偏移量

在对字符串进行分词时，通常希望知道每个 token 源自原始字符串的哪个位置。因此，每个实现了 TokenizerWithOffsets（带偏移量的分词器）的分词器都有一个 tokenize_with_offsets 方法，该方法将返回字节偏移量 (byte offsets) 以及 tokens。start_offsets 列出每个 token 在原始字符串中开始的字节（包含），而 end_offsets 列出每个 token 结束的字节（不包含，即 token 之后的第一个字节）。

tokenizer = text.UnicodeScriptTokenizer()
(tokens, start_offsets, end_offsets) = tokenizer.tokenize_with_offsets(
    ['everything not saved will be lost.', u'Sad☹'.encode('UTF-8')])
print(tokens.to_list())
print(start_offsets.to_list())
print(end_offsets.to_list())

[['everything', 'not', 'saved', 'will', 'be', 'lost', '.'],
 ['Sad', '\xe2\x98\xb9']]
[[0, 11, 15, 21, 26, 29, 33], [0, 3]]
[[10, 14, 20, 25, 28, 33, 34], [3, 6]]

TF.Data 示例

分词器与 tf.data API 配合使用效果符合预期。下面提供了一个简单的示例。

docs = tf.data.Dataset.from_tensor_slices([['Never tell me the odds.'],
                                           ["It's a trap!"]])
tokenizer = text.WhitespaceTokenizer()
tokenized_docs = docs.map(lambda x: tokenizer.tokenize(x))
iterator = tokenized_docs.make_one_shot_iterator()
print(iterator.get_next().to_list())
print(iterator.get_next().to_list())

[['Never', 'tell', 'me', 'the', 'odds.']]
[["It's", 'a', 'trap!']]

Keras API

当您使用不同的分词器 (tokenizer) 和操作符 (ops) 来预处理数据时，生成的输出是 Ragged Tensors（不规则张量）。Keras API 现在使得使用 Ragged Tensors 训练模型变得容易，无需担心数据的填充或掩码处理，您可以使用自动处理所有这些的 ToDense 层，或者依赖 Keras 内置层对原生处理不规则数据的支持。

model = tf.keras.Sequential([
  tf.keras.layers.InputLayer(input_shape=(None,), dtype='int32', ragged=True)
  text.keras.layers.ToDense(pad_value=0, mask=True),
  tf.keras.layers.Embedding(100, 16),
  tf.keras.layers.LSTM(32),
  tf.keras.layers.Dense(32, activation='relu'),
  tf.keras.layers.Dense(1, activation='sigmoid')
])

其他文本操作符

TF.Text 包封装了其他有用的预处理操作符。下面我们将回顾几个。

Wordshape 特征

某些自然语言理解模型中常用的一种特征是查看文本字符串是否具有某种属性。例如，句子分割模型可能包含检查单词大小写或标点符号是否在字符串末尾的特征。

Wordshape 定义了一系列基于正则表达式的有用辅助函数，用于匹配输入文本中的各种相关模式。以下是一些示例。

tokenizer = text.WhitespaceTokenizer()
tokens = tokenizer.tokenize(['Everything not saved will be lost.',
                             u'Sad☹'.encode('UTF-8')])

# Is capitalized?
f1 = text.wordshape(tokens, text.WordShape.HAS_TITLE_CASE)
# Are all letters uppercased?
f2 = text.wordshape(tokens, text.WordShape.IS_UPPERCASE)
# Does the token contain punctuation?
f3 = text.wordshape(tokens, text.WordShape.HAS_SOME_PUNCT_OR_SYMBOL)
# Is the token a number?
f4 = text.wordshape(tokens, text.WordShape.IS_NUMERIC_VALUE)

print(f1.to_list())
print(f2.to_list())
print(f3.to_list())
print(f4.to_list())

[[True, False, False, False, False, False], [True]]
[[False, False, False, False, False, False], [False]]
[[False, False, False, False, False, True], [True]]
[[False, False, False, False, False, False], [False]]

N-gram 与滑动窗口

给定大小为 n 的滑动窗口，N-grams 是连续的单词序列。在组合 tokens 时，支持三种归约机制。对于文本，您应该使用 Reduction.STRING_JOIN，它将字符串彼此连接。默认分隔符字符是空格，但可以通过 string_separater 参数更改。

另外两种归约方法通常与数值一起使用，它们是 Reduction.SUM 和 Reduction.MEAN。

tokenizer = text.WhitespaceTokenizer()
tokens = tokenizer.tokenize(['Everything not saved will be lost.',
                             u'Sad☹'.encode('UTF-8')])

# Ngrams, in this case bi-gram (n = 2)
bigrams = text.ngrams(tokens, 2, reduction_type=text.Reduction.STRING_JOIN)

print(bigrams.to_list())

[['Everything not', 'not saved', 'saved will', 'will be', 'be lost.'], []]

安装

使用 PIP 安装

当使用 pip install 安装 TF Text 时，请注意您正在运行的 TensorFlow 版本，因为您应该指定相应版本的 TF Text。例如，如果您使用的是 TF 2.0，请安装 TF Text 的 2.0 版本；如果您使用的是 TF 1.15，请安装 TF Text 的 1.15 版本。

pip install -U tensorflow-text==<version>

关于不同操作系统包的说明

2.10 版本之后，我们将仅提供适用于 Linux x86_64 和基于 Intel 的 Mac 的 pip 包。TF Text 一直利用核心 TensorFlow 包的发布基础设施，以更轻松地维护兼容版本并减少维护工作，使团队能够专注于 TF Text 本身以及对 TensorFlow 生态系统其他部分的贡献。

对于其他系统，如 Windows、Aarch64 和 Apple Mac，TensorFlow 依赖于 构建协作者，因此我们将不为它们提供包。不过，我们将继续接受 PRs（拉取请求），以使为这些操作系统构建变得更加容易，并尝试指向相关的社区努力。

从源码构建步骤：

请注意，TF Text 需要在与 TensorFlow 相同的环境中构建。因此， 如果您手动构建 TF Text，强烈建议您同时构建 TensorFlow。

如果在 MacOS 上构建，您必须安装 coreutils。使用 Homebrew 可能是最简单的方法。

1. 构建并安装 TensorFlow。
2. 克隆 TF Text 仓库：

   git clone https://github.com/tensorflow/text.git
   cd text
   

3. 运行构建脚本以创建 pip 包：

   ./oss_scripts/run_build.sh
   

   完成此步骤后，当前目录中应该会有一个 *.whl 文件。文件名类似于 tensorflow_text-2.5.0rc0-cp38-cp38-linux_x86_64.whl。
4. 将包安装到环境中：

   pip install ./tensorflow_text-*-*-*-os_platform.whl
   

使用 TensorFlow 的 SIG（特别兴趣组）Docker（容器引擎）镜像构建或测试：

1. 从 TensorFlow SIG Docker 构建 拉取镜像。

2. 基于拉取的镜像运行一个容器并创建一个 bash 会话。 这可以通过运行 docker run -it {image_name} bash 来完成。
   {image_name} 可以是任何符合 {tf_version}-python{python_version} 格式的字符串。 Python 3.10 和 TF 版本 2.10 的一个示例为：2.10-python3.10。

3. 在容器内克隆 TF-Text Github 仓库：git clone https://github.com/tensorflow/text.git。
   克隆完成后，使用 cd text/ 切换到工作目录。

4. 运行配置脚本：./oss_scripts/configure.sh 和 ./oss_scripts/prepare_tf_dep.sh。
   这将更新 Bazel 和 TF 依赖项以匹配容器中安装的 TensorFlow。

5. 要运行测试，请使用 Bazel 命令：bazel test --test_output=errors tensorflow_text:all。这将运行 BUILD 文件中声明的所有测试。
   要运行特定测试，请修改上述命令，将 :all 替换为测试名称（例如 :fast_bert_normalizer）。

6. 构建 pip 包/wheel：
   bazel build --config=release_cpu_linux oss_scripts/pip_package:build_pip_package
./bazel-bin/oss_scripts/pip_package/build_pip_package /{wheel_dir}
   

   构建完成后，您应该在 {wheel_dir} 目录下看到可用的 wheel。

TensorFlow Text 快速上手指南

TensorFlow Text 是 TensorFlow 官方提供的文本处理库，提供了一系列预制的文本类和操作（Ops），可直接用于 TensorFlow 2.0 及更高版本的模型中。它支持在 TensorFlow 图内完成分词、归一化等预处理任务，确保训练与推理阶段的一致性。

环境准备

在使用本工具前，请确保满足以下系统要求：

• 操作系统: Linux, MacOS, Windows
• Python 版本: 3.6 及以上
• 核心依赖: TensorFlow。

  重要提示：tensorflow-text 的版本必须与已安装的 tensorflow 版本严格对应。例如，若使用 tensorflow==2.3.x，则需安装 tensorflow-text==2.3.x。

安装步骤

推荐使用 pip 进行安装。请根据您当前 TensorFlow 的版本号指定对应的 tensorflow-text 版本。

pip install tensorflow-text==<tensorflow_version>

示例：

pip install tensorflow-text==2.10.0

开发者提示：国内用户若遇到下载缓慢，可配置国内镜像源加速安装，例如：

pip install tensorflow-text==2.10.0 -i https://pypi.tuna.tsinghua.edu.cn/simple

基本使用

1. 基础分词 (Tokenization)

引入库后，可以使用内置的 Tokenizer 对字符串进行分割。以下示例展示了如何使用 WhitespaceTokenizer 进行空格分词。

import tensorflow as tf
import tensorflow_text as text

tokenizer = text.WhitespaceTokenizer()
tokens = tokenizer.tokenize(['everything not saved will be lost.', u'Sad☹'.encode('UTF-8')])
print(tokens.to_list())

2. 获取偏移量 (Offsets)

部分分词器支持返回 Token 在原字符串中的字节偏移量，便于后续定位。

tokenizer = text.UnicodeScriptTokenizer()
(tokens, start_offsets, end_offsets) = tokenizer.tokenize_with_offsets(
    ['everything not saved will be lost.', u'Sad☹'.encode('UTF-8')])
print(tokens.to_list())
print(start_offsets.to_list())
print(end_offsets.to_list())

3. Keras 集成

TensorFlow Text 支持与 Keras 无缝集成，可直接处理 Ragged Tensors（不规则张量），无需手动填充或掩码。

model = tf.keras.Sequential([
  tf.keras.layers.InputLayer(input_shape=(None,), dtype='int32', ragged=True),
  text.keras.layers.ToDense(pad_value=0, mask=True),
  tf.keras.layers.Embedding(100, 16),
  tf.keras.layers.LSTM(32),
  tf.keras.layers.Dense(32, activation='relu'),
  tf.keras.layers.Dense(1, activation='sigmoid')
])

更多详细文档和 API 说明，请访问 http://tensorflow.org/text。