サブワードトークナイザー

TensorFlow.orgで表示 GoogleColabで実行 GitHubでソースを表示ノートブックをダウンロードする

このチュートリアルでは、データセットからサブワード語彙を生成し、それを使用して語彙からtext.BertTokenizerを構築するtext.BertTokenizerを示します。

サブワードトークナイザーの主な利点は、単語ベースのトークン化と文字ベースのトークン化の間で補間することです。一般的な単語は語彙にスロットを取得しますが、トークナイザーは未知の単語の単語の断片や個々の文字にフォールバックできます。

概要概要

tensorflow_textパッケージには、多くの一般的なトークナイザーのTensorFlow実装が含まれています。これには、3つのサブワードスタイルのトークナイザーが含まれます。

  • text.BertTokenizer - BertTokenizerクラスは高レベルのインターフェースです。これには、BERTのトークン分割アルゴリズムとWordPieceTokenizerます。入力としてを受け取り、トークンIDを返します
  • text.WordpeiceTokenizer - WordPieceTokenizerクラスは低レベルのインターフェースです。 WordPieceアルゴリズムのみを実装します。呼び出す前に、テキストを標準化して単語に分割する必要があります。入力として単語を受け取り、トークンIDを返します。
  • text.SentencepieceTokenizer - SentencepieceTokenizerは、より複雑な設定が必要です。その初期化子には、事前にトレーニングされたセンテンスピースモデルが必要です。これらのモデルの1つを構築する方法については、 google / sentencepieceリポジトリを参照してください。トークン化するときに入力としてを受け入れることができます。

このチュートリアルでは、既存の単語から始めて、トップダウン方式でWordpieceの語彙を構築します。日本語、中国語、韓国語には明確な複数文字の単位がないため、このプロセスは機能しません。これらの言語をトークン化するには、 text.UnicodeCharTokenizertext.UnicodeCharTokenizerまたはこのアプローチを使用することを検討してtext.SentencepieceTokenizer

セットアップ

pip install -q -U tensorflow-text
pip install -q tensorflow_datasets
import collections
import os
import pathlib
import re
import string
import sys
import tempfile
import time

import numpy as np
import matplotlib.pyplot as plt

import tensorflow_datasets as tfds
import tensorflow_text as text
import tensorflow as tf
tf.get_logger().setLevel('ERROR')
pwd = pathlib.Path.cwd()

データセットをダウンロードする

tfdsからポルトガル語/英語の翻訳データセットを取得します。

examples, metadata = tfds.load('ted_hrlr_translate/pt_to_en', with_info=True,
                               as_supervised=True)
train_examples, val_examples = examples['train'], examples['validation']

このデータセットは、ポルトガル語と英語の文のペアを生成します。

for pt, en in train_examples.take(1):
  print("Portuguese: ", pt.numpy().decode('utf-8'))
  print("English:   ", en.numpy().decode('utf-8'))
Portuguese:  e quando melhoramos a procura , tiramos a única vantagem da impressão , que é a serendipidade .
English:    and when you improve searchability , you actually take away the one advantage of print , which is serendipity .

上記の例文についていくつか注意してください。

  • それらは小文字です。
  • 句読点の周りにスペースがあります。
  • ユニコード正規化が使用されているかどうか、またはどのユニコード正規化が使用されているかは明確ではありません。
train_en = train_examples.map(lambda pt, en: en)
train_pt = train_examples.map(lambda pt, en: pt)

語彙を生成する

このセクションでは、データセットからワードピースの語彙を生成します。あなたは既に語彙ファイルを持っているだけで構築する方法を確認したい場合はtext.BertTokenizerまたはtext.Wordpieceそれは、あなたが先にスキップすることができるとのトークナイザをビルドトークナイザのセクション。

語彙生成コードは、 tensorflow_textパッケージに含まれています。デフォルトではインポートされません。手動でインポートする必要があります。

from tensorflow_text.tools.wordpiece_vocab import bert_vocab_from_dataset as bert_vocab

bert_vocab.bert_vocab_from_dataset関数は語彙を生成します。

その動作を調整するために設定できる多くの引数があります。このチュートリアルでは、主にデフォルトを使用します。オプションについて詳しく知りたい場合は、最初にアルゴリズムについて読んでから、コードを見てください。

これには約2分かかります。

bert_tokenizer_params=dict(lower_case=True)
reserved_tokens=["[PAD]", "[UNK]", "[START]", "[END]"]

bert_vocab_args = dict(
    # The target vocabulary size
    vocab_size = 8000,
    # Reserved tokens that must be included in the vocabulary
    reserved_tokens=reserved_tokens,
    # Arguments for `text.BertTokenizer`
    bert_tokenizer_params=bert_tokenizer_params,
    # Arguments for `wordpiece_vocab.wordpiece_tokenizer_learner_lib.learn`
    learn_params={},
)
%%time
pt_vocab = bert_vocab.bert_vocab_from_dataset(
    train_pt.batch(1000).prefetch(2),
    **bert_vocab_args
)
CPU times: user 1min 21s, sys: 2.76 s, total: 1min 23s
Wall time: 1min 17s

結果の語彙の一部を次に示します。

print(pt_vocab[:10])
print(pt_vocab[100:110])
print(pt_vocab[1000:1010])
print(pt_vocab[-10:])
['[PAD]', '[UNK]', '[START]', '[END]', '!', '#', '$', '%', '&', "'"]
['no', 'por', 'mais', 'na', 'eu', 'esta', 'muito', 'isso', 'isto', 'sao']
['90', 'desse', 'efeito', 'malaria', 'normalmente', 'palestra', 'recentemente', '##nca', 'bons', 'chave']
['##–', '##—', '##‘', '##’', '##“', '##”', '##⁄', '##€', '##♪', '##♫']

語彙ファイルを書く:

def write_vocab_file(filepath, vocab):
  with open(filepath, 'w') as f:
    for token in vocab:
      print(token, file=f)
write_vocab_file('pt_vocab.txt', pt_vocab)

その関数を使用して、英語のデータから語彙を生成します。

%%time
en_vocab = bert_vocab.bert_vocab_from_dataset(
    train_en.batch(1000).prefetch(2),
    **bert_vocab_args
)
CPU times: user 57.6 s, sys: 2.34 s, total: 59.9 s
Wall time: 54.2 s
print(en_vocab[:10])
print(en_vocab[100:110])
print(en_vocab[1000:1010])
print(en_vocab[-10:])
['[PAD]', '[UNK]', '[START]', '[END]', '!', '#', '$', '%', '&', "'"]
['as', 'all', 'at', 'one', 'people', 're', 'like', 'if', 'our', 'from']
['choose', 'consider', 'extraordinary', 'focus', 'generation', 'killed', 'patterns', 'putting', 'scientific', 'wait']
['##_', '##`', '##ย', '##ร', '##อ', '##–', '##—', '##’', '##♪', '##♫']

2つの語彙ファイルは次のとおりです。

write_vocab_file('en_vocab.txt', en_vocab)
ls *.txt
en_vocab.txt  pt_vocab.txt

トークナイザーを構築する

text.BertTokenizerは、語彙ファイルのパスを最初の引数として渡すことで初期化できます(他のオプションについては、 tf.lookupのセクションを参照してください)。

pt_tokenizer = text.BertTokenizer('pt_vocab.txt', **bert_tokenizer_params)
en_tokenizer = text.BertTokenizer('en_vocab.txt', **bert_tokenizer_params)

これで、これを使用してテキストをエンコードできます。英語のデータから3つの例のバッチを取ります:

for pt_examples, en_examples in train_examples.batch(3).take(1):
  for ex in en_examples:
    print(ex.numpy())
b'and when you improve searchability , you actually take away the one advantage of print , which is serendipity .'
b'but what if it were active ?'
b"but they did n't test for curiosity ."

BertTokenizer.tokenizeメソッドを介して実行します。最初に、これは軸(batch, word, word-piece)持つtf.RaggedTensorを返します:

# Tokenize the examples -> (batch, word, word-piece)
token_batch = en_tokenizer.tokenize(en_examples)
# Merge the word and word-piece axes -> (batch, tokens)
token_batch = token_batch.merge_dims(-2,-1)

for ex in token_batch.to_list():
  print(ex)
[72, 117, 79, 1259, 1491, 2362, 13, 79, 150, 184, 311, 71, 103, 2308, 74, 2679, 13, 148, 80, 55, 4840, 1434, 2423, 540, 15]
[87, 90, 107, 76, 129, 1852, 30]
[87, 83, 149, 50, 9, 56, 664, 85, 2512, 15]

トークンIDを( tf.gatherを使用して)テキスト表現に置き換えると、最初の例では、 "searchability""serendipity"という単語が"search ##ability""s ##ere ##nd ##ip ##ity"分解されていることがわかります。 "s ##ere ##nd ##ip ##ity"

# Lookup each token id in the vocabulary.
txt_tokens = tf.gather(en_vocab, token_batch)
# Join with spaces.
tf.strings.reduce_join(txt_tokens, separator=' ', axis=-1)
<tf.Tensor: shape=(3,), dtype=string, numpy=
array([b'and when you improve search ##ability , you actually take away the one advantage of print , which is s ##ere ##nd ##ip ##ity .',
       b'but what if it were active ?',
       b"but they did n ' t test for curiosity ."], dtype=object)>

抽出されたトークンから単語を再構成するには、 BertTokenizer.detokenizeメソッドを使用しBertTokenizer.detokenize

words = en_tokenizer.detokenize(token_batch)
tf.strings.reduce_join(words, separator=' ', axis=-1)
<tf.Tensor: shape=(3,), dtype=string, numpy=
array([b'and when you improve searchability , you actually take away the one advantage of print , which is serendipity .',
       b'but what if it were active ?',
       b"but they did n ' t test for curiosity ."], dtype=object)>

カスタマイズとエクスポート

このチュートリアルでは、 Transformerチュートリアルで使用されるテキストトークナイザーとデトークンライザーを作成します。このセクションでは、そのチュートリアルを簡素化するためのメソッドと処理手順を追加し、 tf.saved_modelを使用してtf.saved_modelをエクスポートして、他のチュートリアルでインポートできるようにします。

カスタムトークン化

ダウンストリームチュートリアルは両方とも、トークン化されたテキストに[START] [END]トークンと[END]トークンが含まれていることを想定しています。

reserved_tokensは語彙の先頭にスペースをreserved_tokensため、 [START][END]は両方の言語で同じインデックスを持ちます。

START = tf.argmax(tf.constant(reserved_tokens) == "[START]")
END = tf.argmax(tf.constant(reserved_tokens) == "[END]")

def add_start_end(ragged):
  count = ragged.bounding_shape()[0]
  starts = tf.fill([count,1], START)
  ends = tf.fill([count,1], END)
  return tf.concat([starts, ragged, ends], axis=1)
words = en_tokenizer.detokenize(add_start_end(token_batch))
tf.strings.reduce_join(words, separator=' ', axis=-1)
<tf.Tensor: shape=(3,), dtype=string, numpy=
array([b'[START] and when you improve searchability , you actually take away the one advantage of print , which is serendipity . [END]',
       b'[START] but what if it were active ? [END]',
       b"[START] but they did n ' t test for curiosity . [END]"],
      dtype=object)>

カスタムトークン化解除

トークナイザーをエクスポートする前に、ダウンストリームチュートリアル用にクリーンアップできることがいくつかあります。

  1. 彼らはクリーンなテキスト出力を生成したいので、 [START][END][PAD]などの予約済みトークンを削除します。
  2. 彼らは完全な文字列に興味があるので、結果のwords軸に沿って文字列結合を適用します。
def cleanup_text(reserved_tokens, token_txt):
  # Drop the reserved tokens, except for "[UNK]".
  bad_tokens = [re.escape(tok) for tok in reserved_tokens if tok != "[UNK]"]
  bad_token_re = "|".join(bad_tokens)

  bad_cells = tf.strings.regex_full_match(token_txt, bad_token_re)
  result = tf.ragged.boolean_mask(token_txt, ~bad_cells)

  # Join them into strings.
  result = tf.strings.reduce_join(result, separator=' ', axis=-1)

  return result
en_examples.numpy()
array([b'and when you improve searchability , you actually take away the one advantage of print , which is serendipity .',
       b'but what if it were active ?',
       b"but they did n't test for curiosity ."], dtype=object)
token_batch = en_tokenizer.tokenize(en_examples).merge_dims(-2,-1)
words = en_tokenizer.detokenize(token_batch)
words
<tf.RaggedTensor [[b'and', b'when', b'you', b'improve', b'searchability', b',', b'you', b'actually', b'take', b'away', b'the', b'one', b'advantage', b'of', b'print', b',', b'which', b'is', b'serendipity', b'.'], [b'but', b'what', b'if', b'it', b'were', b'active', b'?'], [b'but', b'they', b'did', b'n', b"'", b't', b'test', b'for', b'curiosity', b'.']]>
cleanup_text(reserved_tokens, words).numpy()
array([b'and when you improve searchability , you actually take away the one advantage of print , which is serendipity .',
       b'but what if it were active ?',
       b"but they did n ' t test for curiosity ."], dtype=object)

書き出す

次のコードブロックビルドCustomTokenizer格納するクラスをtext.BertTokenizerインスタンス、カスタム・ロジック、および@tf.function輸出に必要なラッパーを。

class CustomTokenizer(tf.Module):
  def __init__(self, reserved_tokens, vocab_path):
    self.tokenizer = text.BertTokenizer(vocab_path, lower_case=True)
    self._reserved_tokens = reserved_tokens
    self._vocab_path = tf.saved_model.Asset(vocab_path)

    vocab = pathlib.Path(vocab_path).read_text().splitlines()
    self.vocab = tf.Variable(vocab)

    ## Create the signatures for export:   

    # Include a tokenize signature for a batch of strings. 
    self.tokenize.get_concrete_function(
        tf.TensorSpec(shape=[None], dtype=tf.string))

    # Include `detokenize` and `lookup` signatures for:
    #   * `Tensors` with shapes [tokens] and [batch, tokens]
    #   * `RaggedTensors` with shape [batch, tokens]
    self.detokenize.get_concrete_function(
        tf.TensorSpec(shape=[None, None], dtype=tf.int64))
    self.detokenize.get_concrete_function(
          tf.RaggedTensorSpec(shape=[None, None], dtype=tf.int64))

    self.lookup.get_concrete_function(
        tf.TensorSpec(shape=[None, None], dtype=tf.int64))
    self.lookup.get_concrete_function(
          tf.RaggedTensorSpec(shape=[None, None], dtype=tf.int64))

    # These `get_*` methods take no arguments
    self.get_vocab_size.get_concrete_function()
    self.get_vocab_path.get_concrete_function()
    self.get_reserved_tokens.get_concrete_function()

  @tf.function
  def tokenize(self, strings):
    enc = self.tokenizer.tokenize(strings)
    # Merge the `word` and `word-piece` axes.
    enc = enc.merge_dims(-2,-1)
    enc = add_start_end(enc)
    return enc

  @tf.function
  def detokenize(self, tokenized):
    words = self.tokenizer.detokenize(tokenized)
    return cleanup_text(self._reserved_tokens, words)

  @tf.function
  def lookup(self, token_ids):
    return tf.gather(self.vocab, token_ids)

  @tf.function
  def get_vocab_size(self):
    return tf.shape(self.vocab)[0]

  @tf.function
  def get_vocab_path(self):
    return self._vocab_path

  @tf.function
  def get_reserved_tokens(self):
    return tf.constant(self._reserved_tokens)

言語ごとにCustomTokenizerを作成します。

tokenizers = tf.Module()
tokenizers.pt = CustomTokenizer(reserved_tokens, 'pt_vocab.txt')
tokenizers.en = CustomTokenizer(reserved_tokens, 'en_vocab.txt')

saved_modelとしてエクスポートしsaved_model

model_name = 'ted_hrlr_translate_pt_en_converter'
tf.saved_model.save(tokenizers, model_name)

saved_modelをリロードし、 saved_modelをテストします。

reloaded_tokenizers = tf.saved_model.load(model_name)
reloaded_tokenizers.en.get_vocab_size().numpy()
7010
tokens = reloaded_tokenizers.en.tokenize(['Hello TensorFlow!'])
tokens.numpy()
array([[   2, 4006, 2358,  687, 1192, 2365,    4,    3]])
text_tokens = reloaded_tokenizers.en.lookup(tokens)
text_tokens
<tf.RaggedTensor [[b'[START]', b'hello', b'tens', b'##or', b'##f', b'##low', b'!', b'[END]']]>
round_trip = reloaded_tokenizers.en.detokenize(tokens)

print(round_trip.numpy()[0].decode('utf-8'))
hello tensorflow !

翻訳チュートリアルのためにアーカイブしてください

zip -r {model_name}.zip {model_name}
adding: ted_hrlr_translate_pt_en_converter/ (stored 0%)
  adding: ted_hrlr_translate_pt_en_converter/variables/ (stored 0%)
  adding: ted_hrlr_translate_pt_en_converter/variables/variables.data-00000-of-00001 (deflated 51%)
  adding: ted_hrlr_translate_pt_en_converter/variables/variables.index (deflated 33%)
  adding: ted_hrlr_translate_pt_en_converter/assets/ (stored 0%)
  adding: ted_hrlr_translate_pt_en_converter/assets/pt_vocab.txt (deflated 57%)
  adding: ted_hrlr_translate_pt_en_converter/assets/en_vocab.txt (deflated 54%)
  adding: ted_hrlr_translate_pt_en_converter/saved_model.pb (deflated 91%)
du -h *.zip
184K    ted_hrlr_translate_pt_en_converter.zip

オプション:アルゴリズム

ここで、WordPieceアルゴリズムにはボトムアップとトップダウンの2つのバージョンがあることに注意してください。どちらの場合も、目標は同じです。「トレーニングコーパスと必要なトークンDの数が与えられた場合、最適化問題は、選択したワードピースモデルに従ってセグメント化したときに、結果のコーパスがワードピースの数で最小になるようにDワードピースを選択することです。 「」

オリジナルのボトムアップWordPieceアルゴリズムは、 バイトペアエンコーディングに基づいています。 BPEのように、それはアルファベットで始まり、一般的なバイグラムを繰り返し組み合わせて単語の断片と単語を形成します。

TensorFlow Textの語彙ジェネレーターは、 BERTのトップダウン実装に従います。単語から始めて、頻度のしきい値に達するまで、またはそれ以上分解できないまで、単語を小さなコンポーネントに分解します。次のセクションでは、これについて詳しく説明します。日本語、中国語、韓国語の場合、最初に明示的な単語単位がないため、このトップダウンアプローチは機能しません。それらのためにあなたは別のアプローチが必要です。

語彙の選択

トップダウンのWordPiece生成アルゴリズムは、(単語、カウント)ペアのセットとしきい値T受け取り、語彙Vを返します。

アルゴリズムは反復的です。これはk回の反復で実行されます。通常はk = 4ですが、実際に重要なのは最初の2回だけです。 3番目と4番目(およびそれ以降)は2番目とまったく同じです。二分探索の各ステップは、 k回の反復でアルゴリズムを最初から実行することに注意してください。

以下に説明する反復:

最初の反復

  1. (w, c)として示される、入力内のすべての単語とカウントのペアを反復処理します。
  2. 単語wごとに、 sで示されるすべての部分文字列を生成します。たとえば、 humanという単語human場合、 {h, hu, hum, huma, human, ##u, ##um, ##uma, ##uman, ##m, ##ma, ##man, #a, ##an, ##n}
  3. サブストリングからカウントへのハッシュマップを維持し、各sカウントをcずつインクリメントします。たとえば、入力に(human, 113)(humas, 3)がある場合、 s = humaカウントは(humas, 3) 113+3=116ます。
  4. すべての部分文字列のカウントを収集したら、最長sから始めて(s, c)ペアを繰り返し処理します。
  5. c > Tを持つすべてsを保持します。たとえば、 T = 100(pers, 231); (dogs, 259); (##rint; 76)その後、我々は続けるだろうpersdogs
  6. sが保持されている場合は、すべてのプレフィックスからそのカウントを減算します。これが、ステップ4ですべてのsを長さでソートする理由です。そうしないと、単語が二重にカウントされるため、これはアルゴリズムの重要な部分です。たとえば、私たちがhumanを維持し、 (huma, 116)到達したとしましょう。 116のうち113humanからhumanであり、 3humasからのものであることがhumasます。ただし、 humanが語彙に含まれるようになったため、 human huma ##n分割することは決してありません。したがって、 humanhumaされると、 human有効数は3ます。

このアルゴリズムは、WordPieceの語彙として使用できる単語のセットs (その多くは単語全体w )を生成します。

ただし、問題があります。このアルゴリズムは、単語の断片を大幅に過剰生成します。その理由は、プレフィックストークンのカウントを差し引くだけだからです。したがって、 humanという単語を保持する場合、 h, hu, hu, humaのカウントを減算しますが、 ##u, ##um, ##uma, ##umanなどのカウントは減算しません。したがって、 ##umanが適用されることはありませんが、 human##uman両方を単語の断片として生成する可能性があります。

では、すべてのプレフィックスだけでなく、すべてのサブストリングのカウントを差し引いてみませんか?その場合、カウントを複数回減算することになりかねないためです。長さ5 sを処理していて、 (##denia, 129)(##eniab, 137)両方を保持しているとしましょう。ここで、これらのカウントの65undeniableという単語から来ています。すべてのサブストリングから減算すると、 1回だけ減算する必要がありますが、サブストリング##eniaから65を2回減算します。ただし、プレフィックスから減算するだけの場合、正しく減算されるのは1回だけです。

2番目(および3番目...)の反復

上記の過剰生成の問題を解決するために、アルゴリズムを複数回繰り返します。

後続の反復は最初の反復と同じですが、重要な違いが1つあります。ステップ2では、すべてのサブストリングを考慮する代わりに、前の反復の語彙を使用してWordPieceトークン化アルゴリズムを適用し、分割点で始まるサブストリングのみを考慮します。

たとえば、アルゴリズムのステップ2を実行していて、 undeniableという単語に遭遇したとします。最初の反復では、すべての部分文字列、たとえば{u, un, und, ..., undeniable, ##n, ##nd, ..., ##ndeniable, ...}

ここで、2回目の反復では、これらのサブセットのみを検討します。最初の反復の後、関連する単語の断片は次のようになります。

un, ##deni, ##able, ##ndeni, ##iable

WordPieceアルゴリズムは、これをun ##deni ##able deni ## ableにセグメント化します(詳細については、「 WordPieceの適用」セクションを参照してください)。この場合、セグメンテーションポイントで始まる部分文字列のみを考慮します。考えられるすべての終了位置を引き続き検討します。したがって、2回目の反復では、 undeniable sのセットは次のようになります。

{u, un, und, unden, undeni, undenia, undeniab, undeniabl, undeniable, ##d, ##de, ##den, ##deni, ##denia, ##deniab, ##deniabl , ##deniable, ##a, ##ab, ##abl, ##able}

それ以外のアルゴリズムは同じです。この例では、最初の反復で、アルゴリズムが重要なトークン##ndeniおよび##iable ##ndeniを生成します。現在、これらのトークンは考慮されないため、2回目の反復では生成されません。結果が収束することを確認するために、いくつかの反復を実行します(ただし、文字通りの収束保証はありません)。

WordPieceの適用

WordPieceの語彙が生成されたら、それを新しいデータに適用できるようにする必要があります。アルゴリズムは、単純な貪欲な最長一致優先アプリケーションです。

たとえば、 undeniable単語をセグメント化することを検討してください。

最初にWordPiece辞書でundeniableを検索し、それが存在する場合は完了です。そうでない場合は、エンドポイントを1文字デクリメントし、繰り返します(例: undeniabl

最終的には、語彙にサブトークンを見つけるか、1文字のサブトークンになります。 (In general, we assume that every character is in our vocabulary, although this might not be the case for rare Unicode characters. If we encounter a rare Unicode character that's not in the vocabulary we simply map the entire word to <unk> ).

この場合、語彙にunが見つかります。これが私たちの最初の言葉です。その後、我々はの終わりにジャンプしunと探してみてください、例えば、処理を繰り返す##deniable 、その後、 ##deniabl我々は単語全体をセグメント化するまでこれが繰り返されるなど、。

直感

直感的に、WordPieceトークン化は2つの異なる目的を達成しようとしています。

  1. データをできるだけ少ない数にトークン化します。 WordPieceアルゴリズムは単語を分割することを「望んでいない」ことを覚えておくことが重要です。それ以外の場合は、すべての単語をその文字に分割します(例: human -> {h, ##u, ##m, ##a, #n} 。これは、WordPieceを形態素スプリッターとは異なる重要な点の1つです。形態素スプリッターは、一般的な単語(たとえば、 unwanted -> {un, want, ed} )に対しても言語形態素を分割します。

  2. 単語を分割する必要がある場合は、トレーニングデータで最大数の単語に分割します。たとえば、 undeniable単語が{unde, ##niab, ##le}ような代替語ではundeniable {un, ##deni, ##able}分割される理由は、 un##ableカウントがこれらは一般的な接頭辞と接尾辞であるため、特に非常に高くなります。 ##leのカウントは##ableよりも大きくなければなりませんが、 unde##niabカウントが少ないと、アルゴリズムにとって「望ましくない」トークン化になります。

オプション:tf.lookup

語彙へのアクセスまたはより詳細な制御が必要な場合は、ルックアップテーブルを自分で作成し、それをBertTokenizer渡すことができることに注意してください。

文字列を渡すと、 BertTokenizerは次のことを行います。

pt_lookup = tf.lookup.StaticVocabularyTable(
    num_oov_buckets=1,
    initializer=tf.lookup.TextFileInitializer(
        filename='pt_vocab.txt',
        key_dtype=tf.string,
        key_index = tf.lookup.TextFileIndex.WHOLE_LINE,
        value_dtype = tf.int64,
        value_index=tf.lookup.TextFileIndex.LINE_NUMBER)) 
pt_tokenizer = text.BertTokenizer(pt_lookup)

これで、トークナイザーで使用されるルックアップテーブルに直接アクセスできます。

pt_lookup.lookup(tf.constant(['é', 'um', 'uma', 'para', 'não']))
<tf.Tensor: shape=(5,), dtype=int64, numpy=array([7765,   85,   86,   87, 7765])>

語彙ファイルを使用する必要はありませんtf.lookupは他の初期化オプションがあります。メモリに語彙がある場合は、 lookup.KeyValueTensorInitializerを使用できます。

pt_lookup = tf.lookup.StaticVocabularyTable(
    num_oov_buckets=1,
    initializer=tf.lookup.KeyValueTensorInitializer(
        keys=pt_vocab,
        values=tf.range(len(pt_vocab), dtype=tf.int64))) 
pt_tokenizer = text.BertTokenizer(pt_lookup)