このページは Cloud Translation API によって翻訳されました。
Switch to English

不規則なテンソル

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

セットアップ

 import math
import tensorflow as tf
 

概観

データにはさまざまな形があります。あなたのテンソルもすべきです。 不規則なテンソルは、ネストされた可変長リストに相当するTensorFlowです。これらを使用すると、次のような不均一な形状のデータを簡単に保存および処理できます。

  • 映画の俳優のセットなど、可変長の機能。
  • 文やビデオクリップなど、可変長の順次入力のバッチ。
  • セクション、段落、文、単語に細分されたテキストドキュメントなどの階層的な入力。
  • プロトコルバッファなどの構造化入力の個々のフィールド。

不規則なテンソルでできること

不規則なテンソルは、数学演算( tf.addtf.reduce_mean )、配列演算( tf.concattf.tile )、文字列操作演算( tf.concatなど)を含む100以上のTensorFlow演算でサポートされていtf.substr )、制御フロー操作( tf.while_looptf.map_fn )、およびその他の多く:

 digits = tf.ragged.constant([[3, 1, 4, 1], [], [5, 9, 2], [6], []])
words = tf.ragged.constant([["So", "long"], ["thanks", "for", "all", "the", "fish"]])
print(tf.add(digits, 3))
print(tf.reduce_mean(digits, axis=1))
print(tf.concat([digits, [[5, 3]]], axis=0))
print(tf.tile(digits, [1, 2]))
print(tf.strings.substr(words, 0, 2))
print(tf.map_fn(tf.math.square, digits))
 
<tf.RaggedTensor [[6, 4, 7, 4], [], [8, 12, 5], [9], []]>
tf.Tensor([2.25              nan 5.33333333 6.                nan], shape=(5,), dtype=float64)
<tf.RaggedTensor [[3, 1, 4, 1], [], [5, 9, 2], [6], [], [5, 3]]>
<tf.RaggedTensor [[3, 1, 4, 1, 3, 1, 4, 1], [], [5, 9, 2, 5, 9, 2], [6, 6], []]>
<tf.RaggedTensor [[b'So', b'lo'], [b'th', b'fo', b'al', b'th', b'fi']]>
<tf.RaggedTensor [[9, 1, 16, 1], [], [25, 81, 4], [36], []]>

ファクトリーメソッド、変換メソッド、値マッピング操作など、不規則なテンソルに固有のメソッドと操作も多数あります。サポートされる操作のリストについては、 tf.raggedパッケージのドキュメントを参照してください。

ラグドテンソルを含む多くのTensorFlowのAPIによってサポートされてKerasデータセットtf.functionSavedModels 、およびtf.Example 。詳細については、以下のTensorFlow APIに関するセクションをご覧ください。

通常のテンソルと同様に、Pythonスタイルのインデックスを使用して、不規則なテンソルの特定のスライスにアクセスできます。詳細については、以下の索引付けに関するセクションを参照してください。

 print(digits[0])       # First row
 
tf.Tensor([3 1 4 1], shape=(4,), dtype=int32)

 print(digits[:, :2])   # First two values in each row.
 
<tf.RaggedTensor [[3, 1], [], [5, 9], [6], []]>

 print(digits[:, -2:])  # Last two values in each row.
 
<tf.RaggedTensor [[4, 1], [], [9, 2], [6], []]>

また、通常のテンソルと同様に、Pythonの算術演算子と比較演算子を使用して要素ごとの演算を実行できます。詳細については、以下のオーバーロードされた演算子のセクションを参照してください。

 print(digits + 3)
 
<tf.RaggedTensor [[6, 4, 7, 4], [], [8, 12, 5], [9], []]>

 print(digits + tf.ragged.constant([[1, 2, 3, 4], [], [5, 6, 7], [8], []]))
 
<tf.RaggedTensor [[4, 3, 7, 5], [], [10, 15, 9], [14], []]>

あなたがの値に要素単位変換を実行する必要がある場合RaggedTensorは、使用することができますtf.ragged.map_flat_values機能に加えて1つ以上の引数を取り、変換する関数を適用され、 RaggedTensorの値を。

 times_two_plus_one = lambda x: x * 2 + 1
print(tf.ragged.map_flat_values(times_two_plus_one, digits))
 
<tf.RaggedTensor [[7, 3, 9, 3], [], [11, 19, 5], [13], []]>

不規則なテンソルは、ネストされたPython listとnumpy array変換できます。

 digits.to_list()
 
[[3, 1, 4, 1], [], [5, 9, 2], [6], []]
 digits.numpy()
 
array([array([3, 1, 4, 1], dtype=int32), array([], dtype=int32),
       array([5, 9, 2], dtype=int32), array([6], dtype=int32),
       array([], dtype=int32)], dtype=object)

不規則なテンソルの作成

不規則なテンソルを作成する最も簡単な方法は、 tf.ragged.constantを使用することtf.ragged.constant 。これは、指定されたネストされたPython listまたはnumpy array対応するRaggedTensorを作成しRaggedTensor

 sentences = tf.ragged.constant([
    ["Let's", "build", "some", "ragged", "tensors", "!"],
    ["We", "can", "use", "tf.ragged.constant", "."]])
print(sentences)
 
<tf.RaggedTensor [[b"Let's", b'build', b'some', b'ragged', b'tensors', b'!'], [b'We', b'can', b'use', b'tf.ragged.constant', b'.']]>

 paragraphs = tf.ragged.constant([
    [['I', 'have', 'a', 'cat'], ['His', 'name', 'is', 'Mat']],
    [['Do', 'you', 'want', 'to', 'come', 'visit'], ["I'm", 'free', 'tomorrow']],
])
print(paragraphs)
 
<tf.RaggedTensor [[[b'I', b'have', b'a', b'cat'], [b'His', b'name', b'is', b'Mat']], [[b'Do', b'you', b'want', b'to', b'come', b'visit'], [b"I'm", b'free', b'tomorrow']]]>

均一テンソルは、 tf.RaggedTensor.from_value_rowidstf.RaggedTensor.from_row_lengths 、およびtf.RaggedTensor.from_row_splitsなどのファクトリクラスメソッドを使用して、これらの値を行に分割する方法を示す行分割テンソルとフラットテンソルをペアにすることによっても構築できます

tf.RaggedTensor.from_value_rowids

各値が属する行がわかっている場合は、 value_rowids行パーティションテンソルを使用してRaggedTensorを構築できます。

value_rowids

 print(tf.RaggedTensor.from_value_rowids(
    values=[3, 1, 4, 1, 5, 9, 2],
    value_rowids=[0, 0, 0, 0, 2, 2, 3]))
 
<tf.RaggedTensor [[3, 1, 4, 1], [], [5, 9], [2]]>

tf.RaggedTensor.from_row_lengths

各行の長さがわかっている場合は、 row_lengths行分割テンソルを使用できます。

row_lengths

 print(tf.RaggedTensor.from_row_lengths(
    values=[3, 1, 4, 1, 5, 9, 2],
    row_lengths=[4, 0, 2, 1]))
 
<tf.RaggedTensor [[3, 1, 4, 1], [], [5, 9], [2]]>

tf.RaggedTensor.from_row_splits

各行の開始と終了のインデックスがわかっている場合は、 row_splits行分割テンソルを使用できます。

row_splits

 print(tf.RaggedTensor.from_row_splits(
    values=[3, 1, 4, 1, 5, 9, 2],
    row_splits=[0, 4, 4, 6, 7]))
 
<tf.RaggedTensor [[3, 1, 4, 1], [], [5, 9], [2]]>

ファクトリメソッドの完全なリストについては、 tf.RaggedTensorクラスのドキュメントをご覧ください。

不規則なテンソルに保存できるもの

通常のTensorと同様に、 RaggedTensorの値はすべて同じ型でなければなりません。また、値はすべて同じネスト深度(テンソルのランク )にある必要があります。

 print(tf.ragged.constant([["Hi"], ["How", "are", "you"]]))  # ok: type=string, rank=2
 
<tf.RaggedTensor [[b'Hi'], [b'How', b'are', b'you']]>

 print(tf.ragged.constant([[[1, 2], [3]], [[4, 5]]]))        # ok: type=int32, rank=3
 
<tf.RaggedTensor [[[1, 2], [3]], [[4, 5]]]>

 try:
  tf.ragged.constant([["one", "two"], [3, 4]])              # bad: multiple types
except ValueError as exception:
  print(exception)
 
Can't convert Python sequence with mixed types to Tensor.

 try:
  tf.ragged.constant(["A", ["B", "C"]])                     # bad: multiple nesting depths
except ValueError as exception:
  print(exception)
 
all scalar values must have the same nesting depth

使用例

次の例は、 RaggedTensor使用して、 RaggedTensorの最初と最後に特別なマーカーを使用し、可変長クエリのバッチのユニグラムとバイグラムの埋め込みを作成して組み合わせる方法を示しています。この例で使用されているopsの詳細については、 tf.raggedパッケージのドキュメントを参照してください。

 queries = tf.ragged.constant([['Who', 'is', 'Dan', 'Smith'],
                              ['Pause'],
                              ['Will', 'it', 'rain', 'later', 'today']])

# Create an embedding table.
num_buckets = 1024
embedding_size = 4
embedding_table = tf.Variable(
    tf.random.truncated_normal([num_buckets, embedding_size],
                       stddev=1.0 / math.sqrt(embedding_size)))

# Look up the embedding for each word.
word_buckets = tf.strings.to_hash_bucket_fast(queries, num_buckets)
word_embeddings = tf.nn.embedding_lookup(embedding_table, word_buckets)     # ①

# Add markers to the beginning and end of each sentence.
marker = tf.fill([queries.nrows(), 1], '#')
padded = tf.concat([marker, queries, marker], axis=1)                       # ②

# Build word bigrams & look up embeddings.
bigrams = tf.strings.join([padded[:, :-1], padded[:, 1:]], separator='+')   # ③

bigram_buckets = tf.strings.to_hash_bucket_fast(bigrams, num_buckets)
bigram_embeddings = tf.nn.embedding_lookup(embedding_table, bigram_buckets) # ④

# Find the average embedding for each sentence
all_embeddings = tf.concat([word_embeddings, bigram_embeddings], axis=1)    # ⑤
avg_embedding = tf.reduce_mean(all_embeddings, axis=1)                      # ⑥
print(avg_embedding)
 
tf.Tensor(
[[ 0.16960017  0.2668903  -0.00337404 -0.11874141]
 [-0.23676081 -0.09729008 -0.16816251  0.11000428]
 [ 0.13829643 -0.02088889  0.02651778  0.02251156]], shape=(3, 4), dtype=float32)

ragged_example

不規則で均一な寸法

不規則な次元とは、スライスの長さが異なる可能性のある次元です。例えば、内側(コラム)の寸法rt=[[3, 1, 4, 1], [], [5, 9, 2], [6], []]カラムスライス(以降、不揃いれるrt[0, :] 、...、 rt[4, :] )は長さが異なります。スライスがすべて同じ長さの寸法は、 均一寸法と呼ばれます。

不規則なテンソルの最も外側の次元は単一のスライスで構成されるため、常に均一です(したがって、スライスの長さが異なる可能性はありません)。残りの寸法は、不規則または均一のいずれかです。例えば、我々は、形状の不揃いテンソル用いて文章のバッチ中の各単語の単語の埋め込みを格納するかもしれない[num_sentences, (num_words), embedding_size]周りの括弧、 (num_words)寸法が不揃いであることを示しています。

sent_word_embed

不規則なテンソルは、複数の不規則な次元を持つ場合があります。たとえば、形状[num_documents, (num_paragraphs), (num_sentences), (num_words)]テンソルを使用して、構造化テキストドキュメントのバッチを保存できます(ここでも括弧は不規則な寸法を示すために使用されます)。

tf.Tensorと同様に、不規則なテンソルのランクは、次元の総数(不規則な次元と均一な次元の両方を含む)です。 潜在的にぼろぼろテンソルは、どちらかであるかもしれない値であるtf.Tensortf.RaggedTensor

RaggedTensorの形状を説明する場合、不規則な寸法は従来、括弧で囲むことで示されます。たとえば、上記で見たように、文のバッチ内の各単語の単語の埋め込みを格納する3D RaggedTensorの形状は、 [num_sentences, (num_words), embedding_size]と書くことができます。

RaggedTensor.shape属性は、 tf.TensorShapeなテンソルのtf.TensorShapeを返します。不規則な次元のサイズはNoneです。

 tf.ragged.constant([["Hi"], ["How", "are", "you"]]).shape
 
TensorShape([2, None])

メソッドtf.RaggedTensor.bounding_shapeを使用して、特定のRaggedTensorタイトな境界形状を見つけることができます。

 print(tf.ragged.constant([["Hi"], ["How", "are", "you"]]).bounding_shape())
 
tf.Tensor([2 3], shape=(2,), dtype=int64)

不揃いvs疎

不規則なテンソルは、スパーステンソルの一種とは見なされません 。特に、スパーステンソルは、同じデータをコンパクトな形式でモデル化するtf.Tensorの効率的なエンコーディングです。しかし、不規則なテンソルはtf.Tensorの拡張であり、データの拡張されたクラスをモデル化します。この違いは、操作を定義するときに重要です。

  • 疎または密テンソルにopを適用すると、常に同じ結果が得られるはずです。
  • 不規則または疎なテンソルに演算を適用すると、異なる結果が得られる場合があります。

説明的な例として、不規則なテンソルと疎なテンソルに対して、 concatstacktileなどの配列演算がどのように定義されるかを考えます。不揃いなテンソルを連結すると、各行が結合され、長さが結合された単一の行が形成されます。

ragged_concat

 ragged_x = tf.ragged.constant([["John"], ["a", "big", "dog"], ["my", "cat"]])
ragged_y = tf.ragged.constant([["fell", "asleep"], ["barked"], ["is", "fuzzy"]])
print(tf.concat([ragged_x, ragged_y], axis=1))
 
<tf.RaggedTensor [[b'John', b'fell', b'asleep'], [b'a', b'big', b'dog', b'barked'], [b'my', b'cat', b'is', b'fuzzy']]>

ただし、次の例に示すように、疎テンソルを連結することは、対応する密テンソルを連結することと同じです(Øは欠損値を示します)。

sparse_concat

 sparse_x = ragged_x.to_sparse()
sparse_y = ragged_y.to_sparse()
sparse_result = tf.sparse.concat(sp_inputs=[sparse_x, sparse_y], axis=1)
print(tf.sparse.to_dense(sparse_result, ''))
 
tf.Tensor(
[[b'John' b'' b'' b'fell' b'asleep']
 [b'a' b'big' b'dog' b'barked' b'']
 [b'my' b'cat' b'' b'is' b'fuzzy']], shape=(3, 5), dtype=string)

この区別が重要である別の例として、 tf.reduce_meanなどのopの「各行の平均値」の定義を検討してtf.reduce_mean 。不規則なテンソルの場合、行の平均値は、行の値を行の幅で割った合計です。ただし、スパーステンソルの場合、行の平均値は、行の値の合計をスパーステンソルの全幅(最長の行の幅以上)で割った値です。

TensorFlow API

ケラス

tf.kerasは、ディープラーニングモデルを構築およびトレーニングするためのTensorFlowの高レベルAPIです。不規則なテンソルは、 tf.keras.Inputまたはtf.keras.layers.InputLayer ragged=Trueを設定することにより、 tf.keras.Inputモデルへの入力として渡すことができます。不規則なテンソルは、Kerasレイヤー間で渡され、Kerasモデルによって返される場合もあります。次の例は、不規則なテンソルを使用してトレーニングされたおもちゃのLSTMモデルを示しています。

 # Task: predict whether each sentence is a question or not.
sentences = tf.constant(
    ['What makes you think she is a witch?',
     'She turned me into a newt.',
     'A newt?',
     'Well, I got better.'])
is_question = tf.constant([True, False, True, False])

# Preprocess the input strings.
hash_buckets = 1000
words = tf.strings.split(sentences, ' ')
hashed_words = tf.strings.to_hash_bucket_fast(words, hash_buckets)

# Build the Keras model.
keras_model = tf.keras.Sequential([
    tf.keras.layers.Input(shape=[None], dtype=tf.int64, ragged=True),
    tf.keras.layers.Embedding(hash_buckets, 16),
    tf.keras.layers.LSTM(32, use_bias=False),
    tf.keras.layers.Dense(32),
    tf.keras.layers.Activation(tf.nn.relu),
    tf.keras.layers.Dense(1)
])

keras_model.compile(loss='binary_crossentropy', optimizer='rmsprop')
keras_model.fit(hashed_words, is_question, epochs=5)
print(keras_model.predict(hashed_words))
 
WARNING:tensorflow:Layer lstm will not use cuDNN kernel since it doesn't meet the cuDNN kernel criteria. It will use generic GPU kernel as fallback when running on GPU
Epoch 1/5

/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/framework/indexed_slices.py:432: UserWarning: Converting sparse IndexedSlices to a dense Tensor of unknown shape. This may consume a large amount of memory.
  "Converting sparse IndexedSlices to a dense Tensor of unknown shape. "

1/1 [==============================] - 0s 1ms/step - loss: 5.2951
Epoch 2/5
1/1 [==============================] - 0s 943us/step - loss: 2.2362
Epoch 3/5
1/1 [==============================] - 0s 879us/step - loss: 1.8742
Epoch 4/5
1/1 [==============================] - 0s 809us/step - loss: 1.7786
Epoch 5/5
1/1 [==============================] - 0s 869us/step - loss: 1.7076
[[0.04364644]
 [0.01928963]
 [0.03224095]
 [0.01768562]]

tf。例

tf.Exampleは、TensorFlowデータの標準protobufエンコーディングです。 tf.Exampleエンコードされたデータには、 tf.Exampleの場合、可変長機能が含まれています。たとえば、次のコードは、機能の長さが異なる4つのtf.Exampleメッセージのバッチを定義します。

 import google.protobuf.text_format as pbtext

def build_tf_example(s):
  return pbtext.Merge(s, tf.train.Example()).SerializeToString()

example_batch = [
  build_tf_example(r'''
    features {
      feature {key: "colors" value {bytes_list {value: ["red", "blue"]} } }
      feature {key: "lengths" value {int64_list {value: [7]} } } }'''),
  build_tf_example(r'''
    features {
      feature {key: "colors" value {bytes_list {value: ["orange"]} } }
      feature {key: "lengths" value {int64_list {value: []} } } }'''),
  build_tf_example(r'''
    features {
      feature {key: "colors" value {bytes_list {value: ["black", "yellow"]} } }
      feature {key: "lengths" value {int64_list {value: [1, 3]} } } }'''),
  build_tf_example(r'''
    features {
      feature {key: "colors" value {bytes_list {value: ["green"]} } }
      feature {key: "lengths" value {int64_list {value: [3, 5, 2]} } } }''')]
 

このエンコードされたデータをtf.io.parse_exampleを使用して解析できます。これは、シリアル化された文字列のテンソルと特徴仕様辞書を受け取り、辞書マッピング機能名をテンソルに返します。可変長の特徴を不規則なテンソルにtf.io.RaggedFeatureは、特徴仕様辞書でtf.io.RaggedFeatureを使用するだけです。

 feature_specification = {
    'colors': tf.io.RaggedFeature(tf.string),
    'lengths': tf.io.RaggedFeature(tf.int64),
}
feature_tensors = tf.io.parse_example(example_batch, feature_specification)
for name, value in feature_tensors.items():
  print("{}={}".format(name, value))
 
colors=<tf.RaggedTensor [[b'red', b'blue'], [b'orange'], [b'black', b'yellow'], [b'green']]>
lengths=<tf.RaggedTensor [[7], [], [1, 3], [3, 5, 2]]>

tf.io.RaggedFeatureを使用して、複数の不規則な寸法を持つフィーチャーを読み取ることもできます。詳細については、 APIドキュメントを参照してください。

データセット

tf.dataは、単純で再利用可能な部分から複雑な入力パイプラインを構築できるようにするAPIです。そのコアデータ構造はtf.data.Dataset 。これは、各要素が1つ以上のコンポーネントで構成される要素のシーケンスを表します。

 # Helper function used to print datasets in the examples below.
def print_dictionary_dataset(dataset):
  for i, element in enumerate(dataset):
    print("Element {}:".format(i))
    for (feature_name, feature_value) in element.items():
      print('{:>14} = {}'.format(feature_name, feature_value))
 

不揃いなテンソルでデータセットを構築する

データセットからそれらを構築するために使用されるのと同じ方法を使用して不規則なテンソルから構築することができるtf.Tensor Sまたはnumpyのarrayなどの、 Dataset.from_tensor_slices

 dataset = tf.data.Dataset.from_tensor_slices(feature_tensors)
print_dictionary_dataset(dataset)
 
Element 0:
        colors = [b'red' b'blue']
       lengths = [7]
Element 1:
        colors = [b'orange']
       lengths = []
Element 2:
        colors = [b'black' b'yellow']
       lengths = [1 3]
Element 3:
        colors = [b'green']
       lengths = [3 5 2]

不揃いなテンソルを持つデータセットのバッチ処理とバッチ処理解除

不揃いなテンソルを持つデータセットは、 Dataset.batchメソッドを使用してバッチ処理できます(連続するn個の要素を1つの要素に結合します)。

 batched_dataset = dataset.batch(2)
print_dictionary_dataset(batched_dataset)
 
Element 0:
        colors = <tf.RaggedTensor [[b'red', b'blue'], [b'orange']]>
       lengths = <tf.RaggedTensor [[7], []]>
Element 1:
        colors = <tf.RaggedTensor [[b'black', b'yellow'], [b'green']]>
       lengths = <tf.RaggedTensor [[1, 3], [3, 5, 2]]>

逆に、バッチ処理されたデータセットは、 Dataset.unbatchを使用してフラットデータセットに変換できます。

 unbatched_dataset = batched_dataset.unbatch()
print_dictionary_dataset(unbatched_dataset)
 
Element 0:
        colors = [b'red' b'blue']
       lengths = [7]
Element 1:
        colors = [b'orange']
       lengths = []
Element 2:
        colors = [b'black' b'yellow']
       lengths = [1 3]
Element 3:
        colors = [b'green']
       lengths = [3 5 2]

可変長の不規則なテンソルを使用したデータセットのバッチ処理

不揃いなテンソルを含むデータセットがあり、テンソルの長さが要素によって異なる場合は、 dense_to_ragged_batchdense_to_ragged_batch変換を適用することで、不揃いなテンソルを不揃いなテンソルにバッチ処理できます。

 non_ragged_dataset = tf.data.Dataset.from_tensor_slices([1, 5, 3, 2, 8])
non_ragged_dataset = non_ragged_dataset.map(tf.range)
batched_non_ragged_dataset = non_ragged_dataset.apply(
    tf.data.experimental.dense_to_ragged_batch(2))
for element in batched_non_ragged_dataset:
  print(element)
 
<tf.RaggedTensor [[0], [0, 1, 2, 3, 4]]>
<tf.RaggedTensor [[0, 1, 2], [0, 1]]>
<tf.RaggedTensor [[0, 1, 2, 3, 4, 5, 6, 7]]>

不揃いなテンソルでデータセットを変換する

Datasetsの不規則なテンソルは、 Dataset.mapを使用して作成または変換することもできます。

 def transform_lengths(features):
  return {
      'mean_length': tf.math.reduce_mean(features['lengths']),
      'length_ranges': tf.ragged.range(features['lengths'])}
transformed_dataset = dataset.map(transform_lengths)
print_dictionary_dataset(transformed_dataset)
 
Element 0:
   mean_length = 7
 length_ranges = <tf.RaggedTensor [[0, 1, 2, 3, 4, 5, 6]]>
Element 1:
   mean_length = 0
 length_ranges = <tf.RaggedTensor []>
Element 2:
   mean_length = 2
 length_ranges = <tf.RaggedTensor [[0], [0, 1, 2]]>
Element 3:
   mean_length = 3
 length_ranges = <tf.RaggedTensor [[0, 1, 2], [0, 1, 2, 3, 4], [0, 1]]>

tf.function

tf.functionは、Python関数のTensorFlowグラフを事前計算するデコレーターであり、TensorFlowコードのパフォーマンスを大幅に向上させることができます。不規則なテンソルは、 @tf.function -decorated関数で透過的に使用できます。たとえば、次の関数は不規則なテンソルと不規則なテンソルの両方で機能します。

 @tf.function
def make_palindrome(x, axis):
  return tf.concat([x, tf.reverse(x, [axis])], axis)
 
 make_palindrome(tf.constant([[1, 2], [3, 4], [5, 6]]), axis=1)
 
<tf.Tensor: shape=(3, 4), dtype=int32, numpy=
array([[1, 2, 2, 1],
       [3, 4, 4, 3],
       [5, 6, 6, 5]], dtype=int32)>
 make_palindrome(tf.ragged.constant([[1, 2], [3], [4, 5, 6]]), axis=1)
 
<tf.RaggedTensor [[1, 2, 2, 1], [3, 3], [4, 5, 6, 6, 5, 4]]>

あなたが明示的に指定したい場合はinput_signatureためtf.function 、あなたが使用して行うことができtf.RaggedTensorSpec

 @tf.function(
    input_signature=[tf.RaggedTensorSpec(shape=[None, None], dtype=tf.int32)])
def max_and_min(rt):
  return (tf.math.reduce_max(rt, axis=-1), tf.math.reduce_min(rt, axis=-1))

max_and_min(tf.ragged.constant([[1, 2], [3], [4, 5, 6]]))
 
(<tf.Tensor: shape=(3,), dtype=int32, numpy=array([2, 3, 6], dtype=int32)>,
 <tf.Tensor: shape=(3,), dtype=int32, numpy=array([1, 3, 4], dtype=int32)>)

具体的な機能

具象関数は、 tf.functionによってtf.functionされた個々のトレースされたグラフをカプセル化しtf.function 。 TensorFlow 2.3以降(およびtf-nightlyでは)、不規則なテンソルを具体的な関数で透過的に使用できます。

 # Preferred way to use ragged tensors with concrete functions (TF 2.3+):
try:
  @tf.function
  def increment(x):
    return x + 1

  rt = tf.ragged.constant([[1, 2], [3], [4, 5, 6]])
  cf = increment.get_concrete_function(rt)
  print(cf(rt))
except Exception as e:
  print(f"Not supported before TF 2.3: {type(e)}: {e}")
 
<tf.RaggedTensor [[2, 3], [4], [5, 6, 7]]>

TensorFlow 2.3より前の具象関数で不規則なテンソルを使用する必要がある場合は、不規則なテンソルをコンポーネント( valuesおよびrow_splits )に分解し、それらを個別の引数として渡すことをお勧めします。

 # Backwards-compatible way to use ragged tensors with concrete functions:
@tf.function
def decomposed_ragged_increment(x_values, x_splits):
  x = tf.RaggedTensor.from_row_splits(x_values, x_splits)
  return x + 1

rt = tf.ragged.constant([[1, 2], [3], [4, 5, 6]])
cf = decomposed_ragged_increment.get_concrete_function(rt.values, rt.row_splits)
print(cf(rt.values, rt.row_splits))
 
<tf.RaggedTensor [[2, 3], [4], [5, 6, 7]]>

SavedModels

SavedModelは、重みと計算の両方を含む、シリアル化されたTensorFlowプログラムです。 Kerasモデルまたはカスタムモデルから構築できます。どちらの場合でも、不規則なテンソルは、SavedModelによって定義された関数とメソッドで透過的に使用できます。

例:Kerasモデルの保存

 import tempfile

keras_module_path = tempfile.mkdtemp()
tf.saved_model.save(keras_model, keras_module_path)
imported_model = tf.saved_model.load(keras_module_path)
imported_model(hashed_words)
 
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/tracking/tracking.py:111: Model.state_updates (from tensorflow.python.keras.engine.training) is deprecated and will be removed in a future version.
Instructions for updating:
This property should not be used in TensorFlow 2.0, as updates are applied automatically.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/tracking/tracking.py:111: Layer.updates (from tensorflow.python.keras.engine.base_layer) is deprecated and will be removed in a future version.
Instructions for updating:
This property should not be used in TensorFlow 2.0, as updates are applied automatically.
INFO:tensorflow:Assets written to: /tmp/tmpiwzx2cd0/assets

<tf.Tensor: shape=(4, 1), dtype=float32, numpy=
array([[0.04364644],
       [0.01928963],
       [0.03224095],
       [0.01768562]], dtype=float32)>

例:カスタムモデルの保存

 class CustomModule(tf.Module):
  def __init__(self, variable_value):
    super(CustomModule, self).__init__()
    self.v = tf.Variable(variable_value)

  @tf.function
  def grow(self, x):
    return x * self.v

module = CustomModule(100.0)

# Before saving a custom model, we must ensure that concrete functions are
# built for each input signature that we will need.
module.grow.get_concrete_function(tf.RaggedTensorSpec(shape=[None, None],
                                                      dtype=tf.float32))

custom_module_path = tempfile.mkdtemp()
tf.saved_model.save(module, custom_module_path)
imported_model = tf.saved_model.load(custom_module_path)
imported_model.grow(tf.ragged.constant([[1.0, 4.0, 3.0], [2.0]]))
 
INFO:tensorflow:Assets written to: /tmp/tmpvq6pr2f2/assets

<tf.RaggedTensor [[100.0, 400.0, 300.0], [200.0]]>

オーバーロードされた演算子

RaggedTensorクラスは、標準のPython算術演算子と比較演算子をオーバーロードし、基本的な要素ごとの計算を簡単に実行できるようにします。

 x = tf.ragged.constant([[1, 2], [3], [4, 5, 6]])
y = tf.ragged.constant([[1, 1], [2], [3, 3, 3]])
print(x + y)
 
<tf.RaggedTensor [[2, 3], [5], [7, 8, 9]]>

オーバーロードされた演算子は要素ごとの計算を実行するため、すべてのバイナリ演算への入力は同じ形状であるか、同じ形状にブロードキャスト可能でなければなりません。最も単純なブロードキャストの場合、単一のスカラーが不規則なテンソルの各値と要素ごとに結合されます。

 x = tf.ragged.constant([[1, 2], [3], [4, 5, 6]])
print(x + 3)
 
<tf.RaggedTensor [[4, 5], [6], [7, 8, 9]]>

より高度なケースの説明については、 ブロードキャストのセクションを参照してください。

不規則なテンソルは、通常のTensorと同じ演算子のセットをオーバーロードします。単項演算子-~ 、およびabs() ;そして、二項演算子+-*///%**&|^==<<=> 、および>=

索引付け

不規則なテンソルは、多次元のインデックス付けやスライスなど、Pythonスタイルのインデックス付けをサポートしています。次の例は、2次元および3次元の不規則なテンソルによる不規則なテンソルインデックス付けを示しています。

インデックスの例:2D不規則テンソル

 queries = tf.ragged.constant(
    [['Who', 'is', 'George', 'Washington'],
     ['What', 'is', 'the', 'weather', 'tomorrow'],
     ['Goodnight']])
 
 print(queries[1])                   # A single query
 
tf.Tensor([b'What' b'is' b'the' b'weather' b'tomorrow'], shape=(5,), dtype=string)

 print(queries[1, 2])                # A single word
 
tf.Tensor(b'the', shape=(), dtype=string)

 print(queries[1:])                  # Everything but the first row
 
<tf.RaggedTensor [[b'What', b'is', b'the', b'weather', b'tomorrow'], [b'Goodnight']]>

 print(queries[:, :3])               # The first 3 words of each query
 
<tf.RaggedTensor [[b'Who', b'is', b'George'], [b'What', b'is', b'the'], [b'Goodnight']]>

 print(queries[:, -2:])              # The last 2 words of each query
 
<tf.RaggedTensor [[b'George', b'Washington'], [b'weather', b'tomorrow'], [b'Goodnight']]>

インデックスの例3D不規則テンソル

 rt = tf.ragged.constant([[[1, 2, 3], [4]],
                         [[5], [], [6]],
                         [[7]],
                         [[8, 9], [10]]])
 
 print(rt[1])                        # Second row (2-D RaggedTensor)
 
<tf.RaggedTensor [[5], [], [6]]>

 print(rt[3, 0])                     # First element of fourth row (1-D Tensor)
 
tf.Tensor([8 9], shape=(2,), dtype=int32)

 print(rt[:, 1:3])                   # Items 1-3 of each row (3-D RaggedTensor)
 
<tf.RaggedTensor [[[4]], [[], [6]], [], [[10]]]>

 print(rt[:, -1:])                   # Last item of each row (3-D RaggedTensor)
 
<tf.RaggedTensor [[[4]], [[6]], [[7]], [[10]]]>

RaggedTensorは、多次元のインデックス付けとスライスをサポートしていますが、1つの制限があります。不規則な次元へのインデックス付けは許可されていません。示された値は一部の行に存在するが他の行には存在しない可能性があるため、この場合は問題があります。そのような場合、(1) IndexErrorせるべきかどうかは明らかではありません。 (2)デフォルト値を使用します。または(3)その値をスキップして、最初の行よりも少ない行でテンソルを返します。 Pythonの基本原則 (「あいまいな状況に直面し、推測する誘惑を拒否する」)に従い、現在この操作は許可されていません。

テンソル型変換

RaggedTensor間で変換するために使用できるクラス定義の方法RaggedTensor S及びtf.Tensor Sまたはtf.SparseTensors

 ragged_sentences = tf.ragged.constant([
    ['Hi'], ['Welcome', 'to', 'the', 'fair'], ['Have', 'fun']])
 
 # RaggedTensor -> Tensor
print(ragged_sentences.to_tensor(default_value='', shape=[None, 10]))
 
tf.Tensor(
[[b'Hi' b'' b'' b'' b'' b'' b'' b'' b'' b'']
 [b'Welcome' b'to' b'the' b'fair' b'' b'' b'' b'' b'' b'']
 [b'Have' b'fun' b'' b'' b'' b'' b'' b'' b'' b'']], shape=(3, 10), dtype=string)

 # Tensor -> RaggedTensor
x = [[1, 3, -1, -1], [2, -1, -1, -1], [4, 5, 8, 9]]
print(tf.RaggedTensor.from_tensor(x, padding=-1))
 
<tf.RaggedTensor [[1, 3], [2], [4, 5, 8, 9]]>

 #RaggedTensor -> SparseTensor
print(ragged_sentences.to_sparse())
 
SparseTensor(indices=tf.Tensor(
[[0 0]
 [1 0]
 [1 1]
 [1 2]
 [1 3]
 [2 0]
 [2 1]], shape=(7, 2), dtype=int64), values=tf.Tensor([b'Hi' b'Welcome' b'to' b'the' b'fair' b'Have' b'fun'], shape=(7,), dtype=string), dense_shape=tf.Tensor([3 4], shape=(2,), dtype=int64))

 # SparseTensor -> RaggedTensor
st = tf.SparseTensor(indices=[[0, 0], [2, 0], [2, 1]],
                     values=['a', 'b', 'c'],
                     dense_shape=[3, 3])
print(tf.RaggedTensor.from_sparse(st))
 
<tf.RaggedTensor [[b'a'], [], [b'b', b'c']]>

不規則なテンソルの評価

不規則なテンソルの値にアクセスするには、次の方法があります。

  1. tf.RaggedTensor.to_list()を使用して、不規則なテンソルをネストされたpythonリストに変換します。
  2. tf.RaggedTensor.numpy()を使用して、不規則なテンソルを、値がネストされたnumpy配列であるnumpy配列に変換します。
  3. tf.RaggedTensor.valuesおよびtf.RaggedTensor.row_splitsプロパティ、またはtf.RaggedTensor.row_lengths()tf.RaggedTensor.value_rowids()などの行分割メソッドを使用して、不規則なテンソルをそのコンポーネントに分解します。
  4. Pythonインデックスを使用して、不規則なテンソルから値を選択します。
 rt = tf.ragged.constant([[1, 2], [3, 4, 5], [6], [], [7]])
print("python list:", rt.to_list())
print("numpy array:", rt.numpy())
print("values:", rt.values.numpy())
print("splits:", rt.row_splits.numpy())
print("indexed value:", rt[1].numpy())
 
python list: [[1, 2], [3, 4, 5], [6], [], [7]]
numpy array: [array([1, 2], dtype=int32) array([3, 4, 5], dtype=int32)
 array([6], dtype=int32) array([], dtype=int32) array([7], dtype=int32)]
values: [1 2 3 4 5 6 7]
splits: [0 2 5 6 6 7]
indexed value: [3 4 5]

放送

ブロードキャストとは、さまざまな形状のテンソルに要素単位の操作で互換性のある形状を持たせるプロセスです。ブロードキャストの背景については、以下を参照してください。

2つの入力xyをブロードキャストして互換性のある形状にするための基本的な手順は次のとおりです。

  1. xyの次元数が同じでない場合は、それらが等しくなるまで外部サイズ(サイズ1)を追加します。

  2. xyサイズが異なる各次元について:

    • xまたはyサイズが次元d1場合、他の入力のサイズと一致するように、次元dその値を繰り返します。

    • それ以外の場合は、例外を発生させます( xおよびyはブロードキャスト互換ではありません)。

一様次元のテンソルのサイズが単一の数値である場合(その次元全体のスライスのサイズ)。不規則な次元のテンソルのサイズは、スライスの長さのリストです(その次元のすべてのスライスについて)。

放送例

 # x       (2D ragged):  2 x (num_rows)
# y       (scalar)
# result  (2D ragged):  2 x (num_rows)
x = tf.ragged.constant([[1, 2], [3]])
y = 3
print(x + y)
 
<tf.RaggedTensor [[4, 5], [6]]>

 # x         (2d ragged):  3 x (num_rows)
# y         (2d tensor):  3 x          1
# Result    (2d ragged):  3 x (num_rows)
x = tf.ragged.constant(
   [[10, 87, 12],
    [19, 53],
    [12, 32]])
y = [[1000], [2000], [3000]]
print(x + y)
 
<tf.RaggedTensor [[1010, 1087, 1012], [2019, 2053], [3012, 3032]]>

 # x      (3d ragged):  2 x (r1) x 2
# y      (2d ragged):         1 x 1
# Result (3d ragged):  2 x (r1) x 2
x = tf.ragged.constant(
    [[[1, 2], [3, 4], [5, 6]],
     [[7, 8]]],
    ragged_rank=1)
y = tf.constant([[10]])
print(x + y)
 
<tf.RaggedTensor [[[11, 12], [13, 14], [15, 16]], [[17, 18]]]>

 # x      (3d ragged):  2 x (r1) x (r2) x 1
# y      (1d tensor):                    3
# Result (3d ragged):  2 x (r1) x (r2) x 3
x = tf.ragged.constant(
    [
        [
            [[1], [2]],
            [],
            [[3]],
            [[4]],
        ],
        [
            [[5], [6]],
            [[7]]
        ]
    ],
    ragged_rank=2)
y = tf.constant([10, 20, 30])
print(x + y)
 
<tf.RaggedTensor [[[[11, 21, 31], [12, 22, 32]], [], [[13, 23, 33]], [[14, 24, 34]]], [[[15, 25, 35], [16, 26, 36]], [[17, 27, 37]]]]>

ブロードキャストされない形状の例をいくつか次に示します。

 # x      (2d ragged): 3 x (r1)
# y      (2d tensor): 3 x    4  # trailing dimensions do not match
x = tf.ragged.constant([[1, 2], [3, 4, 5, 6], [7]])
y = tf.constant([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
try:
  x + y
except tf.errors.InvalidArgumentError as exception:
  print(exception)
 
Expected 'tf.Tensor(False, shape=(), dtype=bool)' to be true. Summarized data: b'Unable to broadcast: dimension size mismatch in dimension'
1
b'lengths='
4
b'dim_size='
2, 4, 1

 # x      (2d ragged): 3 x (r1)
# y      (2d ragged): 3 x (r2)  # ragged dimensions do not match.
x = tf.ragged.constant([[1, 2, 3], [4], [5, 6]])
y = tf.ragged.constant([[10, 20], [30, 40], [50]])
try:
  x + y
except tf.errors.InvalidArgumentError as exception:
  print(exception)
 
Expected 'tf.Tensor(False, shape=(), dtype=bool)' to be true. Summarized data: b'Unable to broadcast: dimension size mismatch in dimension'
1
b'lengths='
2, 2, 1
b'dim_size='
3, 1, 2

 # x      (3d ragged): 3 x (r1) x 2
# y      (3d ragged): 3 x (r1) x 3  # trailing dimensions do not match
x = tf.ragged.constant([[[1, 2], [3, 4], [5, 6]],
                        [[7, 8], [9, 10]]])
y = tf.ragged.constant([[[1, 2, 0], [3, 4, 0], [5, 6, 0]],
                        [[7, 8, 0], [9, 10, 0]]])
try:
  x + y
except tf.errors.InvalidArgumentError as exception:
  print(exception)
 
Expected 'tf.Tensor(False, shape=(), dtype=bool)' to be true. Summarized data: b'Unable to broadcast: dimension size mismatch in dimension'
2
b'lengths='
3, 3, 3, 3, 3
b'dim_size='
2, 2, 2, 2, 2

RaggedTensorエンコーディング

不規則なテンソルは、 RaggedTensorクラスを使用してエンコードされます。内部的には、各RaggedTensorRaggedTensor構成されています。

  • valuesテンソル。可変長の行を連結して平坦化されたリストにします。
  • row_partition 。フラット化された値を行に分割する方法を示します。

ragged_encoding_2

row_partitionは、4つの異なるエンコーディングを使用して格納できます。

  • row_splitsは、 row_splitsの分割点を指定する整数ベクトルです。
  • value_rowidsは、各値の行インデックスを指定する整数ベクトルです。
  • row_lengthsは、各行の長さを指定する整数ベクトルです。
  • uniform_row_lengthは、すべての行に単一の長さを指定する整数スカラーです。

partition_encodings

整数スカラーnrowsまた、中に含めることができるrow_partition持つ空の末尾行を考慮するために、符号化value_rowids有する、または空行uniform_row_length

 rt = tf.RaggedTensor.from_row_splits(
    values=[3, 1, 4, 1, 5, 9, 2],
    row_splits=[0, 4, 4, 6, 7])
print(rt)
 
<tf.RaggedTensor [[3, 1, 4, 1], [], [5, 9], [2]]>

行パーティションに使用するエンコーディングの選択は、一部のコンテキストで効率を向上させるために、不規則なテンソルによって内部的に管理されます。特に、さまざまな行パーティション分割スキームの長所と短所は次のとおりです。

  • 効率的なインデックス作成row_splitsエンコーディングにより、一定時間のインデックス作成と不規則なテンソルへのスライスが可能になります。

  • 効率的な連結 :不規則なテンソルを連結する場合、 row_lengthsエンコーディングの方が効率的です。これは、2つのテンソルを連結しても行の長さが変化しないためです。

  • 小さいエンコーディングサイズ :テンソルのサイズは値の総数にのみ依存するため、空の行が多数ある不規則なテンソルを格納する場合、 value_rowidsエンコーディングはより効率的です。一方、 row_splitsおよびrow_lengthsエンコーディングは、行ごとに1つのスカラー値しか必要としないため、長い行を持つ不規則なテンソルを格納する場合により効率的です。

  • 互換性value_rowidsスキームは、 tf.segment_sumなどの操作で使用されるセグメンテーション形式と一致します。 row_limitsスキームは、 tf.sequence_maskなどのopsで使用されるフォーマットと一致します。

  • 均一な寸法 :以下で説明するように、 uniform_row_lengthエンコーディングは、均一な寸法の不規則なテンソルをエンコードするために使用されます。

複数の不規則な寸法

複数の不規則な次元を持つ不規則なテンソルは、 valuesテンソルにネストされたRaggedTensorを使用してエンコードされvalues 。ネストされた各RaggedTensorは、単一の不揃いな次元を追加します。

ragged_rank_2

 rt = tf.RaggedTensor.from_row_splits(
    values=tf.RaggedTensor.from_row_splits(
        values=[10, 11, 12, 13, 14, 15, 16, 17, 18, 19],
        row_splits=[0, 3, 3, 5, 9, 10]),
    row_splits=[0, 1, 1, 5])
print(rt)
print("Shape: {}".format(rt.shape))
print("Number of partitioned dimensions: {}".format(rt.ragged_rank))
 
<tf.RaggedTensor [[[10, 11, 12]], [], [[], [13, 14], [15, 16, 17, 18], [19]]]>
Shape: (3, None, None)
Number of partitioned dimensions: 2

ファクトリ関数tf.RaggedTensor.from_nested_row_splitsを使用して、 row_splitsテンソルのリストを提供することにより、複数の不規則な次元を持つRaggedTensorを直接構築できます。

 rt = tf.RaggedTensor.from_nested_row_splits(
    flat_values=[10, 11, 12, 13, 14, 15, 16, 17, 18, 19],
    nested_row_splits=([0, 1, 1, 5], [0, 3, 3, 5, 9, 10]))
print(rt)
 
<tf.RaggedTensor [[[10, 11, 12]], [], [[], [13, 14], [15, 16, 17, 18], [19]]]>

不規則なランクとフラットな値

不規則なテンソルの不規則なランクは、基になるvalues Tensorが分割された回数です(つまり、 RaggedTensorオブジェクトのネストの深さ)。最も内側のvaluesテンソルは、そのflat_valuesと呼ばれます。次の例では、 conversationsはragged_rank = 3で、そのflat_valuesは24文字列の1D Tensorです。

 # shape = [batch, (paragraph), (sentence), (word)]
conversations = tf.ragged.constant(
    [[[["I", "like", "ragged", "tensors."]],
      [["Oh", "yeah?"], ["What", "can", "you", "use", "them", "for?"]],
      [["Processing", "variable", "length", "data!"]]],
     [[["I", "like", "cheese."], ["Do", "you?"]],
      [["Yes."], ["I", "do."]]]])
conversations.shape
 
TensorShape([2, None, None, None])
 assert conversations.ragged_rank == len(conversations.nested_row_splits)
conversations.ragged_rank  # Number of partitioned dimensions.
 
3
 conversations.flat_values.numpy()
 
array([b'I', b'like', b'ragged', b'tensors.', b'Oh', b'yeah?', b'What',
       b'can', b'you', b'use', b'them', b'for?', b'Processing',
       b'variable', b'length', b'data!', b'I', b'like', b'cheese.', b'Do',
       b'you?', b'Yes.', b'I', b'do.'], dtype=object)

均一な内寸

均一な内部次元を持つ不規則なテンソルは、flat_values(つまり、最も内側のvalues )に多次元tf.Tensorを使用してエンコードされvalues

uniform_inner

 rt = tf.RaggedTensor.from_row_splits(
    values=[[1, 3], [0, 0], [1, 3], [5, 3], [3, 3], [1, 2]],
    row_splits=[0, 3, 4, 6])
print(rt)
print("Shape: {}".format(rt.shape))
print("Number of partitioned dimensions: {}".format(rt.ragged_rank))
print("Flat values shape: {}".format(rt.flat_values.shape))
print("Flat values:\n{}".format(rt.flat_values))
 
<tf.RaggedTensor [[[1, 3], [0, 0], [1, 3]], [[5, 3]], [[3, 3], [1, 2]]]>
Shape: (3, None, 2)
Number of partitioned dimensions: 1
Flat values shape: (6, 2)
Flat values:
[[1 3]
 [0 0]
 [1 3]
 [5 3]
 [3 3]
 [1 2]]

均一な非内寸

非内部次元が均一な不規則なテンソルは、 uniform_row_length行を分割することによってエンコードされます。

uniform_outer

 rt = tf.RaggedTensor.from_uniform_row_length(
    values=tf.RaggedTensor.from_row_splits(
        values=[10, 11, 12, 13, 14, 15, 16, 17, 18, 19],
        row_splits=[0, 3, 5, 9, 10]),
    uniform_row_length=2)
print(rt)
print("Shape: {}".format(rt.shape))
print("Number of partitioned dimensions: {}".format(rt.ragged_rank))
 
<tf.RaggedTensor [[[10, 11, 12], [13, 14]], [[15, 16, 17, 18], [19]]]>
Shape: (2, 2, None)
Number of partitioned dimensions: 2