 在 TensorFlow.org 上查看
|
 在 Google Colab 中运行
|
 在 GitHub 上查看源代码
|
 下载笔记本
|
简介
NLP 模型通常使用不同的字符集处理不同的语言。Unicode 是一种标准编码系统，用于表示几乎所有语言的字符。每个 Unicode 字符都使用一个唯一的整数 代码点 进行编码，该代码点介于 0 和 0x10FFFF 之间。Unicode 字符串 是零个或多个代码点的序列。
本教程展示了如何在 TensorFlow 中表示 Unicode 字符串，以及如何使用 Unicode 等效的标准字符串操作来操作它们。它根据脚本检测将 Unicode 字符串分成标记。
import tensorflow as tf
import numpy as np
tf.string 数据类型
基本的 TensorFlow tf.string dtype 允许您构建字节字符串张量。Unicode 字符串默认情况下使用 utf-8 编码。
tf.constant(u"Thanks 😊")
<tf.Tensor: shape=(), dtype=string, numpy=b'Thanks \xf0\x9f\x98\x8a'>
tf.string 张量将字节字符串视为原子单元。这使其能够存储不同长度的字节字符串。字符串长度不包含在张量维度中。
tf.constant([u"You're", u"welcome!"]).shape
TensorShape([2])
如果您使用 Python 构建字符串，请注意 字符串文字 默认情况下使用 Unicode 编码。
表示 Unicode
在 TensorFlow 中表示 Unicode 字符串有两种标准方法
string标量 - 代码点序列使用已知的 字符编码 进行编码。int32向量 - 每个位置包含一个代码点。
例如，以下三个值都表示 Unicode 字符串 "语言处理"（在中文中表示“语言处理”）
# Unicode string, represented as a UTF-8 encoded string scalar.
text_utf8 = tf.constant(u"语言处理")
text_utf8
<tf.Tensor: shape=(), dtype=string, numpy=b'\xe8\xaf\xad\xe8\xa8\x80\xe5\xa4\x84\xe7\x90\x86'>
# Unicode string, represented as a UTF-16-BE encoded string scalar.
text_utf16be = tf.constant(u"语言处理".encode("UTF-16-BE"))
text_utf16be
<tf.Tensor: shape=(), dtype=string, numpy=b'\x8b\xed\x8a\x00Y\x04t\x06'>
# Unicode string, represented as a vector of Unicode code points.
text_chars = tf.constant([ord(char) for char in u"语言处理"])
text_chars
<tf.Tensor: shape=(4,), dtype=int32, numpy=array([35821, 35328, 22788, 29702], dtype=int32)>
在表示形式之间转换
TensorFlow 提供了在这些不同表示形式之间转换的操作
tf.strings.unicode_decode: 将编码的字符串标量转换为代码点向量。tf.strings.unicode_encode: 将代码点向量转换为编码的字符串标量。tf.strings.unicode_transcode: 将编码的字符串标量转换为不同的编码。
tf.strings.unicode_decode(text_utf8,
input_encoding='UTF-8')
<tf.Tensor: shape=(4,), dtype=int32, numpy=array([35821, 35328, 22788, 29702], dtype=int32)>
tf.strings.unicode_encode(text_chars,
output_encoding='UTF-8')
<tf.Tensor: shape=(), dtype=string, numpy=b'\xe8\xaf\xad\xe8\xa8\x80\xe5\xa4\x84\xe7\x90\x86'>
tf.strings.unicode_transcode(text_utf8,
input_encoding='UTF8',
output_encoding='UTF-16-BE')
<tf.Tensor: shape=(), dtype=string, numpy=b'\x8b\xed\x8a\x00Y\x04t\x06'>
批次维度
解码多个字符串时，每个字符串中的字符数量可能不相等。返回的结果是一个 tf.RaggedTensor，其中最内层维度的长度根据每个字符串中的字符数量而变化。
# A batch of Unicode strings, each represented as a UTF8-encoded string.
batch_utf8 = [s.encode('UTF-8') for s in
[u'hÃllo', u'What is the weather tomorrow', u'Göödnight', u'😊']]
batch_chars_ragged = tf.strings.unicode_decode(batch_utf8,
input_encoding='UTF-8')
for sentence_chars in batch_chars_ragged.to_list():
print(sentence_chars)
[104, 195, 108, 108, 111] [87, 104, 97, 116, 32, 105, 115, 32, 116, 104, 101, 32, 119, 101, 97, 116, 104, 101, 114, 32, 116, 111, 109, 111, 114, 114, 111, 119] [71, 246, 246, 100, 110, 105, 103, 104, 116] [128522]
您可以直接使用此 tf.RaggedTensor，或者使用方法 tf.RaggedTensor.to_tensor 和 tf.RaggedTensor.to_sparse 将其转换为带填充的密集 tf.Tensor 或 tf.sparse.SparseTensor。
batch_chars_padded = batch_chars_ragged.to_tensor(default_value=-1)
print(batch_chars_padded.numpy())
[[ 104 195 108 108 111 -1 -1 -1 -1 -1
-1 -1 -1 -1 -1 -1 -1 -1 -1 -1
-1 -1 -1 -1 -1 -1 -1 -1]
[ 87 104 97 116 32 105 115 32 116 104
101 32 119 101 97 116 104 101 114 32
116 111 109 111 114 114 111 119]
[ 71 246 246 100 110 105 103 104 116 -1
-1 -1 -1 -1 -1 -1 -1 -1 -1 -1
-1 -1 -1 -1 -1 -1 -1 -1]
[128522 -1 -1 -1 -1 -1 -1 -1 -1 -1
-1 -1 -1 -1 -1 -1 -1 -1 -1 -1
-1 -1 -1 -1 -1 -1 -1 -1]]
batch_chars_sparse = batch_chars_ragged.to_sparse()
nrows, ncols = batch_chars_sparse.dense_shape.numpy()
elements = [['_' for i in range(ncols)] for j in range(nrows)]
for (row, col), value in zip(batch_chars_sparse.indices.numpy(), batch_chars_sparse.values.numpy()):
elements[row][col] = str(value)
# max_width = max(len(value) for row in elements for value in row)
value_lengths = []
for row in elements:
for value in row:
value_lengths.append(len(value))
max_width = max(value_lengths)
print('[%s]' % '\n '.join(
'[%s]' % ', '.join(value.rjust(max_width) for value in row)
for row in elements))
[[ 104, 195, 108, 108, 111, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _] [ 87, 104, 97, 116, 32, 105, 115, 32, 116, 104, 101, 32, 119, 101, 97, 116, 104, 101, 114, 32, 116, 111, 109, 111, 114, 114, 111, 119] [ 71, 246, 246, 100, 110, 105, 103, 104, 116, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _] [128522, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _]]
当对具有相同长度的多个字符串进行编码时，请使用 tf.Tensor 作为输入。
tf.strings.unicode_encode([[99, 97, 116], [100, 111, 103], [99, 111, 119]],
output_encoding='UTF-8')
<tf.Tensor: shape=(3,), dtype=string, numpy=array([b'cat', b'dog', b'cow'], dtype=object)>
当对具有不同长度的多个字符串进行编码时，请使用 tf.RaggedTensor 作为输入。
tf.strings.unicode_encode(batch_chars_ragged, output_encoding='UTF-8')
<tf.Tensor: shape=(4,), dtype=string, numpy=
array([b'h\xc3\x83llo', b'What is the weather tomorrow',
b'G\xc3\xb6\xc3\xb6dnight', b'\xf0\x9f\x98\x8a'], dtype=object)>
如果您有一个具有填充或稀疏格式的多个字符串的张量，请先将其转换为 tf.RaggedTensor，然后再调用 tf.strings.unicode_encode。
tf.strings.unicode_encode(
tf.RaggedTensor.from_sparse(batch_chars_sparse),
output_encoding='UTF-8')
<tf.Tensor: shape=(4,), dtype=string, numpy=
array([b'h\xc3\x83llo', b'What is the weather tomorrow',
b'G\xc3\xb6\xc3\xb6dnight', b'\xf0\x9f\x98\x8a'], dtype=object)>
tf.strings.unicode_encode(
tf.RaggedTensor.from_tensor(batch_chars_padded, padding=-1),
output_encoding='UTF-8')
<tf.Tensor: shape=(4,), dtype=string, numpy=
array([b'h\xc3\x83llo', b'What is the weather tomorrow',
b'G\xc3\xb6\xc3\xb6dnight', b'\xf0\x9f\x98\x8a'], dtype=object)>
Unicode 操作
字符长度
使用 unit 参数在 tf.strings.length 操作中指示如何计算字符长度。 unit 默认值为 "BYTE"，但可以设置为其他值，例如 "UTF8_CHAR" 或 "UTF16_CHAR"，以确定每个编码字符串中的 Unicode 代码点的数量。
# Note that the final character takes up 4 bytes in UTF8.
thanks = u'Thanks 😊'.encode('UTF-8')
num_bytes = tf.strings.length(thanks).numpy()
num_chars = tf.strings.length(thanks, unit='UTF8_CHAR').numpy()
print('{} bytes; {} UTF-8 characters'.format(num_bytes, num_chars))
11 bytes; 8 UTF-8 characters
字符子字符串
tf.strings.substr 操作接受 unit 参数，并使用它来确定 pos 和 len 参数包含哪种偏移量。
# Here, unit='BYTE' (default). Returns a single byte with len=1
tf.strings.substr(thanks, pos=7, len=1).numpy()
b'\xf0'
# Specifying unit='UTF8_CHAR', returns a single 4 byte character in this case
print(tf.strings.substr(thanks, pos=7, len=1, unit='UTF8_CHAR').numpy())
b'\xf0\x9f\x98\x8a'
拆分 Unicode 字符串
tf.strings.unicode_split 操作将 Unicode 字符串拆分为单个字符的子字符串。
tf.strings.unicode_split(thanks, 'UTF-8').numpy()
array([b'T', b'h', b'a', b'n', b'k', b's', b' ', b'\xf0\x9f\x98\x8a'],
dtype=object)
字符的字节偏移量
为了将 tf.strings.unicode_decode 生成的字符张量与原始字符串对齐，了解每个字符开始位置的偏移量非常有用。方法 tf.strings.unicode_decode_with_offsets 与 unicode_decode 类似，只是它返回第二个张量，其中包含每个字符的起始偏移量。
codepoints, offsets = tf.strings.unicode_decode_with_offsets(u'🎈🎉🎊', 'UTF-8')
for (codepoint, offset) in zip(codepoints.numpy(), offsets.numpy()):
print('At byte offset {}: codepoint {}'.format(offset, codepoint))
At byte offset 0: codepoint 127880 At byte offset 4: codepoint 127881 At byte offset 8: codepoint 127882
Unicode 脚本
每个 Unicode 代码点都属于一个称为 脚本 的单个代码点集合。字符的脚本有助于确定字符可能属于哪种语言。例如，知道“Б”属于西里尔字母表明包含该字符的现代文本很可能来自斯拉夫语言，如俄语或乌克兰语。
TensorFlow 提供了 tf.strings.unicode_script 操作来确定给定代码点使用哪个脚本。脚本代码是 int32 值，对应于 国际 Unicode 组件 (ICU) UScriptCode 值。
uscript = tf.strings.unicode_script([33464, 1041]) # ['芸', 'Б']
print(uscript.numpy()) # [17, 8] == [USCRIPT_HAN, USCRIPT_CYRILLIC]
[17 8]
tf.strings.unicode_script 操作也可以应用于代码点的多维 tf.Tensor 或 tf.RaggedTensor。
print(tf.strings.unicode_script(batch_chars_ragged))
<tf.RaggedTensor [[25, 25, 25, 25, 25], [25, 25, 25, 25, 0, 25, 25, 0, 25, 25, 25, 0, 25, 25, 25, 25, 25, 25, 25, 0, 25, 25, 25, 25, 25, 25, 25, 25] , [25, 25, 25, 25, 25, 25, 25, 25, 25], [0]]>
示例：简单分段
分段是将文本拆分为类似单词的单元的任务。当使用空格字符来分隔单词时，这通常很容易，但一些语言（如中文和日语）不使用空格，而一些语言（如德语）包含必须拆分才能分析其含义的长复合词。在网络文本中，不同的语言和脚本经常混合在一起，例如“NY株価”（纽约证券交易所）。
我们可以通过使用脚本的变化来近似单词边界来执行非常粗略的分段（无需实现任何 ML 模型）。这将适用于像“NY株価”这样的字符串。它也适用于大多数使用空格的语言，因为各种脚本的空格字符都被归类为 USCRIPT_COMMON，这是一种与任何实际文本的脚本代码不同的特殊脚本代码。
# dtype: string; shape: [num_sentences]
#
# The sentences to process. Edit this line to try out different inputs!
sentence_texts = [u'Hello, world.', u'世界こんにちは']
首先，将句子解码为字符代码点，并找到每个字符的脚本标识符。
# dtype: int32; shape: [num_sentences, (num_chars_per_sentence)]
#
# sentence_char_codepoint[i, j] is the codepoint for the j'th character in
# the i'th sentence.
sentence_char_codepoint = tf.strings.unicode_decode(sentence_texts, 'UTF-8')
print(sentence_char_codepoint)
# dtype: int32; shape: [num_sentences, (num_chars_per_sentence)]
#
# sentence_char_scripts[i, j] is the Unicode script of the j'th character in
# the i'th sentence.
sentence_char_script = tf.strings.unicode_script(sentence_char_codepoint)
print(sentence_char_script)
<tf.RaggedTensor [[72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 46], [19990, 30028, 12371, 12435, 12395, 12385, 12399]]> <tf.RaggedTensor [[25, 25, 25, 25, 25, 0, 0, 25, 25, 25, 25, 25, 0], [17, 17, 20, 20, 20, 20, 20]]>
使用脚本标识符来确定应该在何处添加单词边界。在每个句子的开头添加一个单词边界，以及每个脚本与前一个字符不同的字符。
# dtype: bool; shape: [num_sentences, (num_chars_per_sentence)]
#
# sentence_char_starts_word[i, j] is True if the j'th character in the i'th
# sentence is the start of a word.
sentence_char_starts_word = tf.concat(
[tf.fill([sentence_char_script.nrows(), 1], True),
tf.not_equal(sentence_char_script[:, 1:], sentence_char_script[:, :-1])],
axis=1)
# dtype: int64; shape: [num_words]
#
# word_starts[i] is the index of the character that starts the i'th word (in
# the flattened list of characters from all sentences).
word_starts = tf.squeeze(tf.where(sentence_char_starts_word.values), axis=1)
print(word_starts)
tf.Tensor([ 0 5 7 12 13 15], shape=(6,), dtype=int64)
然后，您可以使用这些起始偏移量来构建一个 RaggedTensor，其中包含所有批次的单词列表。
# dtype: int32; shape: [num_words, (num_chars_per_word)]
#
# word_char_codepoint[i, j] is the codepoint for the j'th character in the
# i'th word.
word_char_codepoint = tf.RaggedTensor.from_row_starts(
values=sentence_char_codepoint.values,
row_starts=word_starts)
print(word_char_codepoint)
<tf.RaggedTensor [[72, 101, 108, 108, 111], [44, 32], [119, 111, 114, 108, 100], [46], [19990, 30028], [12371, 12435, 12395, 12385, 12399]]>
最后，将单词代码点 RaggedTensor 重新分割回句子，并编码为 UTF-8 字符串以提高可读性。
# dtype: int64; shape: [num_sentences]
#
# sentence_num_words[i] is the number of words in the i'th sentence.
sentence_num_words = tf.reduce_sum(
tf.cast(sentence_char_starts_word, tf.int64),
axis=1)
# dtype: int32; shape: [num_sentences, (num_words_per_sentence), (num_chars_per_word)]
#
# sentence_word_char_codepoint[i, j, k] is the codepoint for the k'th character
# in the j'th word in the i'th sentence.
sentence_word_char_codepoint = tf.RaggedTensor.from_row_lengths(
values=word_char_codepoint,
row_lengths=sentence_num_words)
print(sentence_word_char_codepoint)
tf.strings.unicode_encode(sentence_word_char_codepoint, 'UTF-8').to_list()
<tf.RaggedTensor [[[72, 101, 108, 108, 111], [44, 32], [119, 111, 114, 108, 100], [46]], [[19990, 30028], [12371, 12435, 12395, 12385, 12399]]]> [[b'Hello', b', ', b'world', b'.'], [b'\xe4\xb8\x96\xe7\x95\x8c', b'\xe3\x81\x93\xe3\x82\x93\xe3\x81\xab\xe3\x81\xa1\xe3\x81\xaf']]