Bu sayfa, Cloud Translation API ile çevrilmiştir.
Switch to English

Düzensiz tensörler

TensorFlow.org'da görüntüleyin Google Colab'de çalıştırın Kaynağı GitHub'da görüntüleyin Defteri indirin

API Belgeleri:tf.RaggedTensor tf.ragged

Kurmak

import math
import tensorflow as tf

Genel Bakış

Verileriniz birçok şekilde gelir; sizin tensörleriniz de olmalı. Ragged tensörler , iç içe geçmiş değişken uzunluk listelerinin TensorFlow eşdeğeridir. Aşağıdakiler dahil, tek tip olmayan şekillere sahip verileri depolamayı ve işlemeyi kolaylaştırırlar:

  • Bir filmdeki oyuncu seti gibi değişken uzunluktaki özellikler.
  • Cümleler veya video klipler gibi değişken uzunluklu ardışık girdiler grupları.
  • Bölümlere, paragraflara, cümlelere ve kelimelere bölünmüş metin belgeleri gibi hiyerarşik girdiler.
  • Protokol arabellekleri gibi yapılandırılmış girdilerdeki ayrı alanlar.

Düzensiz bir tensörle ne yapabilirsiniz?

Dağınık tansörler (örneğin matematik işlemleri de dahil olmak üzere, birden fazla yüz TensorFlow işlemleri desteklediği tf.add ve tf.reduce_mean ), (örneğin, dizi işlemleri tf.concat ve tf.tile gibi), dize işleme ops ( tf.substr ), kontrol akış işlemlerini ( tf.while_loop ve tf.map_fn ) ve diğerleri:

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], []]>

Fabrika yöntemleri, dönüştürme yöntemleri ve değer haritalama işlemleri dahil, düzensiz tensörlere özgü bir dizi yöntem ve işlem de vardır. Desteklenen işlemlerin listesi için tf.ragged paket belgelerine bakın .

Dağınık tansörler dahil birçok TensorFlow API'ler, desteklediği keras , Veri kümeleri , tf.function , SavedModels ve tf.Example . Daha fazla bilgi için aşağıdaki TensorFlow API'leri ile ilgili bölüme bakın.

Normal tensörlerde olduğu gibi, düzensiz bir tensörün belirli dilimlerine erişmek için Python tarzı indekslemeyi kullanabilirsiniz. Daha fazla bilgi için aşağıdaki Dizin Oluşturma bölümüne bakın.

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], []]>

Ve normal tensörler gibi, element bazlı işlemler gerçekleştirmek için Python aritmetiğini ve karşılaştırma operatörlerini kullanabilirsiniz. Daha fazla bilgi için aşağıdaki Aşırı Yüklenmiş Operatörler bölümüne bakın.

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], []]>

Bir değerlerine bir elementwise dönüşümü gerçekleştirmek için ihtiyaç RaggedTensor , kullanabilirsiniz tf.ragged.map_flat_values bir işlevi ve bir veya daha fazla bağımsız değişken alır ve transforme etmek üzere işlevini geçerli olduğu, RaggedTensor 'nin değerleri.

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], []]>

Dağınık tansörler iç içe Python dönüştürülebilir list ler ve numpy array s:

digits.to_list()
[[3, 1, 4, 1], [], [5, 9, 2], [6], []]
digits.numpy()
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/ops/ragged/ragged_tensor.py:2012: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray
  return np.array(rows)

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)

Düzensiz bir tensör oluşturmak

tf.ragged.constant bir tensör oluşturmanın en basit yolu, belirli bir yuvalanmış Python list veya numpy array karşılık gelen RaggedTensor oluşturan tf.ragged.constant kullanmaktır:

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_rowids tf.RaggedTensor.from_row_lengths , tf.RaggedTensor.from_value_rowids , tf.RaggedTensor.from_row_lengths ve tf.RaggedTensor.from_row_splits gibi fabrika tf.RaggedTensor.from_value_rowids kullanarak bu değerlerin satırlara nasıl bölüneceğini belirten düz değer tensörleri ile satır bölümleme tensörlerini eşleştirerek de oluşturulabilir.

tf.RaggedTensor.from_value_rowids

Her değer olduğunu kabul eden satır biliyorsanız, o zaman bir inşa edebilirsiniz RaggedTensor bir kullanarak value_rowids satır bölümleme tensörünü:

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

Her satırın ne kadar uzun olduğunu biliyorsanız, bir row_lengths satır bölümleme tensörü kullanabilirsiniz:

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

Her satırın başladığı ve bittiği dizini biliyorsanız, bir row_splits satır bölümleme tensörü kullanabilirsiniz:

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

Fabrika yöntemlerinin tam listesi içintf.RaggedTensor sınıfı belgelerine bakın.

Düzensiz bir tensörde ne saklayabilirsiniz?

Normal gibi Tensor s, bir değerler RaggedTensor aynı türü olmalıdır; ve değerlerin tümü aynı yuvalama derinliğinde olmalıdır (tensörün derecesi ):

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

Örnek kullanım durumu

Aşağıdaki örnek, her cümlenin başlangıcı ve sonu için özel işaretler kullanarak, değişken uzunluklu sorgulardan oluşan bir grup için unigram ve bigram yerleştirmelerini oluşturmak ve birleştirmek için RaggedTensor ların nasıl kullanılabileceğini gösterir. Bu örnekte kullanılan işlemlerle ilgili daha fazla ayrıntı için tf.ragged paket belgelerine bakın.

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.07226902 -0.03359559 -0.03866251 -0.04422581]
 [-0.10786405 -0.38157812 -0.11010554 -0.07145723]
 [ 0.18454719 -0.05851733 -0.13204828  0.14964654]], shape=(3, 4), dtype=float32)

ragged_example

Düzensiz ve tek tip boyutlar

Düzensiz boyut , dilimlerinin farklı uzunluklara sahip olabileceği bir boyuttur. Örneğin, rt=[[3, 1, 4, 1], [], [5, 9, 2], [6], []] nin iç (sütun) boyutu, sütun dilimleri ( rt[0, :] rt[4, :] rt[0, :] , ..., rt[4, :] ) farklı uzunluklara sahiptir. Tüm dilimlerinin aynı uzunlukta olduğu boyutlara tek tip boyutlar denir.

Düzensiz bir tensörün en dış boyutu, tek bir dilimden oluştuğundan (ve bu nedenle farklı dilim uzunlukları olasılığı olmadığından) her zaman tek tiptir. Kalan boyutlar düzensiz veya tek tip olabilir. Örneğin, her bir kelime için kelime gömmelerini, şekil [num_sentences, (num_words), embedding_size] ile düzensiz bir tensör kullanarak bir grup cümlede [num_sentences, (num_words), embedding_size] , burada parantezler (num_words) boyutun düzensiz olduğunu gösterir.

sent_word_embed

Düzensiz tensörler birden fazla düzensiz boyuta sahip olabilir. Örneğin, [num_documents, (num_paragraphs), (num_sentences), (num_words)] şeklinde bir tensör kullanarak bir grup yapılandırılmış metin belgesini [num_documents, (num_paragraphs), (num_sentences), (num_words)] (burada yine düzensiz boyutları belirtmek için parantezler kullanılır).

tf.Tensor olduğu gibi, düzensiz bir tensörün sıralaması , toplam boyut sayısıdır (hem düzensiz hem de tek tip boyutlar dahil). Potansiyel olarak düzensiz bir tensör , bir tf.Tensor veya birtf.RaggedTensor olabilecek birtf.RaggedTensor .

Bir RaggedTensor'ın şeklini açıklarken, düzensiz boyutlar geleneksel olarak parantez içine alınarak belirtilir. Örneğin, yukarıda gördüğümüz gibi, cümle kümesindeki her kelime için kelime yerleştirmelerini depolayan 3-D RaggedTensor'ın şekli [num_sentences, (num_words), embedding_size] olarak yazılabilir.

RaggedTensor.shape özelliği, düzensiz boyutların boyutunun None olduğu bir düzensiz tensör için bir tf.TensorShape döndürür:

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

tf.RaggedTensor.bounding_shape yöntemi, belirli bir RaggedTensor için sıkı bir sınırlayıcı şekil bulmak için kullanılabilir:

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

Düzensiz ve seyrek

Bir düzensiz tensör seyrek tensör türü olarak düşünülebilir olmamalıdır. Özellikle, seyrek tensörler, aynı verileri kompakt bir formatta modelleyen tf.Tensor için verimli kodlamalardır ; ancak düzensiz tensör, genişletilmiş bir veri sınıfını modelleyen tf.Tensor'un bir uzantısıdır . İşlemleri tanımlarken bu fark çok önemlidir:

  • Seyrek veya yoğun bir tensöre op uygulamak her zaman aynı sonucu vermelidir.
  • Düzensiz veya seyrek tensöre bir op uygulamak farklı sonuçlar verebilir.

Açıklayıcı bir örnek olarak, düzensiz ve seyrek tensörler için concat , stack ve tile gibi dizi işlemlerinin nasıl tanımlandığını düşünün. Düzensiz tensörlerin birleştirilmesi, her satırı birleştirerek, birleşik uzunlukta tek bir sıra oluşturur:

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

Ancak seyrek tensörleri birleştirmek, aşağıdaki örnekte gösterildiği gibi karşılık gelen yoğun tensörleri birleştirmeye eşdeğerdir (burada Ø, eksik değerleri gösterir):

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)

Bu ayrımın neden önemli olduğuna dair başka bir örnek olarak, tf.reduce_mean gibi bir işlem için "her satırın ortalama değeri" tanımını tf.reduce_mean . Düzensiz bir tensör için, bir satırın ortalama değeri, satır değerlerinin toplamının satır genişliğine bölünmesidir. Ancak seyrek bir tensör için, bir satırın ortalama değeri, satır değerlerinin toplamının seyrek tensörün toplam genişliğine (en uzun satırın genişliğine eşit veya daha büyük olan) bölünmesidir.

TensorFlow API'leri

Keras

tf.keras , TensorFlow'un derin öğrenme modellerini oluşturmak ve eğitmek için kullandığı üst düzey API'dir. Düzensiz tensörler, tf.keras.Input veya tf.keras.layers.InputLayer ragged=True tf.keras.Input modeline girdi olarak geçirilebilir. Düzensiz tensörler, Keras katmanları arasında da geçirilebilir ve Keras modelleri tarafından döndürülebilir. Aşağıdaki örnek, düzensiz tensörler kullanılarak eğitilmiş bir oyuncak LSTM modelini göstermektedir.

# 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:437: UserWarning: Converting sparse IndexedSlices(IndexedSlices(indices=Tensor("gradient_tape/sequential/lstm/RaggedToTensor/boolean_mask_1/GatherV2:0", shape=(None,), dtype=int32), values=Tensor("gradient_tape/sequential/lstm/RaggedToTensor/boolean_mask/GatherV2:0", shape=(None, 16), dtype=float32), dense_shape=Tensor("gradient_tape/sequential/lstm/RaggedToTensor/Shape:0", shape=(2,), dtype=int32))) to a dense Tensor of unknown shape. This may consume a large amount of memory.
  "shape. This may consume a large amount of memory." % value)

1/1 [==============================] - 2s 2s/step - loss: 2.7506
Epoch 2/5
1/1 [==============================] - 0s 16ms/step - loss: 1.9755
Epoch 3/5
1/1 [==============================] - 0s 15ms/step - loss: 1.8869
Epoch 4/5
1/1 [==============================] - 0s 16ms/step - loss: 1.8256
Epoch 5/5
1/1 [==============================] - 0s 19ms/step - loss: 1.7605
[[0.03648993]
 [0.00550611]
 [0.02936834]
 [0.0077349 ]]

tf.Example

tf.Example bir standarttır protobuf TensorFlow veri kodlaması. tf.Example s ile kodlanmış veriler genellikle değişken uzunluklu özellikler içerir. Örneğin, aşağıdaki kod dört tf.Example bir toplu işi tanımlar.Farklı özellik uzunluklarına sahip tf.Example mesajlar:

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]} } } }''')]

Bu kodlanmış veriyi tf.io.parse_example kullanarak ayrıştırabiliriz, bu tf.io.parse_example , serileştirilmiş dizelerin bir tensörünü ve bir özellik belirtim sözlüğünü alır ve tensörlere bir sözlük eşleme özelliği adları döndürür. Değişken uzunluktaki özellikleri düzensiz tensörler halinde okumak için, özellik belirtimi sözlüğünde tf.io.RaggedFeature kullanıyoruz:

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 , birden çok düzensiz boyuta sahip unsurları okumak için de kullanılabilir. Ayrıntılar için API belgelerine bakın .

Veri kümeleri

tf.data , basit, yeniden kullanılabilir parçalardan karmaşık giriş ardışık düzenleri oluşturmanıza olanak tanıyan bir API'dir. Temel veri yapısı, her bir öğenin bir veya daha fazla bileşenden oluştuğu bir dizi öğeyi temsil edentf.data.Dataset .

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

Düzensiz tensörlerle Veri Kümeleri Oluşturma

Veri kayıtları bunları oluşturmak için kullanılan aynı usuller kullanılarak düzensiz tensörlerle inşa edilebilir tf.Tensor ler veya numpy array gibi s, 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]

Düzensiz tensörlerle Veri Kümelerini gruplama ve ayırma

Düzensiz tensörlere sahip veri Dataset.batch , Dataset.batch yöntemi kullanılarak Dataset.batch (bu, n ardışık öğeyi tek bir Dataset.batch birleştirir).

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

Tersine, toplu bir veri kümesi Dataset.unbatch kullanılarak düz bir veri kümesine dönüştürülebilir.

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]

Değişken uzunlukta düzensiz tensörlere sahip Toplu Veri Kümeleri

Düzensiz olmayan tensörler içeren bir Veri Kümeniz varsa ve tensör uzunlukları öğelere göre değişiklik gösteriyorsa, bu düzensiz tensörleri dense_to_ragged_batch dönüşümünü uygulayarak düzensiz tensörler halinde dense_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]]>

Veri Kümelerini düzensiz tensörlerle dönüştürme

Veri Kümelerindeki Dataset.map tensörler, Dataset.map kullanılarak da oluşturulabilir veya dönüştürülebilir.

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 işlevleri için TensorFlow grafiklerini önceden hesaplayan ve TensorFlow kodunuzun performansını önemli ölçüde artırabilen bir dekoratördür. Ragged tensörler, @tf.function dekorlu fonksiyonlarla şeffaf olarak kullanılabilir. Örneğin, aşağıdaki işlev hem düzensiz hem de düzensiz tensörlerle çalışır:

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

Açıkça belirtmek isterseniz input_signature için tf.function , o zaman kullanarak yapabilirsiniz 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)>)

Somut fonksiyonlar

Somut işlevler , tf.function tarafından tf.function tek tek izlenen grafikleri tf.function . Düzensiz tensörler, somut fonksiyonlarla şeffaf olarak kullanılabilir.

@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))
<tf.RaggedTensor [[2, 3], [4], [5, 6, 7]]>

SavedModels

SavedModel , hem ağırlıkları hem de hesaplamayı içeren serileştirilmiş bir TensorFlow programıdır. Bir Keras modelinden veya özel bir modelden oluşturulabilir. Her iki durumda da düzensiz tensörler, bir SavedModel tarafından tanımlanan işlevler ve yöntemlerle şeffaf bir şekilde kullanılabilir.

Örnek: Keras modelini kaydetme

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)
INFO:tensorflow:Assets written to: /tmp/tmpyr1dlj_r/assets

<tf.Tensor: shape=(4, 1), dtype=float32, numpy=
array([[0.03648993],
       [0.00550611],
       [0.02936834],
       [0.0077349 ]], dtype=float32)>

Örnek: özel bir modeli kaydetme

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/tmpen_1gfeg/assets

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

Aşırı yüklenmiş operatörler

RaggedTensor sınıfı, standart Python aritmetiği ve karşılaştırma işleçlerini aşırı yükleyerek temel elementsel matematik işlemlerini gerçekleştirmeyi kolaylaştırır:

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

Aşırı yüklenmiş operatörler element bazlı hesaplamalar yaptıkları için, tüm ikili işlemlerin girdileri aynı şekle sahip olmalı veya aynı şekle yayınlanabilir olmalıdır. En basit yayın durumunda, tek bir skaler, düzensiz bir tensördeki her bir değerle elementel olarak birleştirilir:

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

Daha gelişmiş vakalarla ilgili bir tartışma için, Yayınlama bölümüne bakın.

Dağınık tansörler normal operatörlerin aynı kümesini aşırı Tensor s: tekli operatörler - , ~ ve abs() ; ve ikili operatörler + , - , * , / , // , % , ** , & , | , ^ , == , < , <= , > ve >= .

Endeksleme

Ragged tensörler, çok boyutlu indeksleme ve dilimleme dahil olmak üzere Python tarzı indekslemeyi destekler. Aşağıdaki örnekler, bir 2-D ve bir 3-D düzensiz tensör ile düzensiz tensör indekslemeyi gösterir.

İndeksleme örnekleri: 2D düzensiz tensör

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

İndeksleme örnekleri 3B düzensiz tensör

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 , tek bir kısıtlama ile çok boyutlu indekslemeyi ve dilimlemeyi destekler: düzensiz bir boyuta indekslemeye izin verilmez. Bu durum sorunludur çünkü belirtilen değer bazı satırlarda olabilirken diğerlerinde olmayabilir. Bu gibi durumlarda, (1) bir IndexError yükseltmemiz gerekip gerekmediği açık değildir; (2) varsayılan bir değer kullanın; veya (3) bu değeri atlayın ve başladığımızdan daha az satır içeren bir tensör döndürür. Python'un yol gösterici ilkelerini izleyerek ("belirsizlik karşısında, tahmin etme cazibesini reddedin"), şu anda bu işleme izin vermiyoruz.

Tensör tipi dönüştürme

RaggedTensor sınıfı, RaggedTensor s ve tf.Tensor s veya tf.SparseTensors arasında dönüştürme yapmak için kullanılabilecek yöntemleri tanımlar:

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

Düzensiz tensörleri değerlendirme

Düzensiz bir tensördeki değerlere erişmek için şunları yapabilirsiniz:

  1. tf.RaggedTensor.to_list() tensörü iç içe geçmiş bir python listesine dönüştürmek için tf.RaggedTensor.to_list() kullanın.
  2. tf.RaggedTensor.numpy() tensörü, değerleri iç içe geçmiş numpy dizileri olan bir uyuşmuş diziye dönüştürmek için tf.RaggedTensor.numpy() kullanın.
  3. tf.RaggedTensor.values ve tf.RaggedTensor.row_splits özelliklerini veya tf.RaggedTensor.row_lengths() ve tf.RaggedTensor.value_rowids() gibi satır tf.RaggedTensor.row_lengths() yöntemlerini kullanarak ragged tensörü bileşenlerine tf.RaggedTensor.value_rowids() .
  4. Düzensiz tensörden değer seçmek için Python indekslemeyi kullanın.
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]

/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/ops/ragged/ragged_tensor.py:2012: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray
  return np.array(rows)

Yayın

Yayın, farklı şekillere sahip tensörlerin elementsel işlemler için uyumlu şekillere sahip olması sürecidir. Yayın hakkında daha fazla arka plan için bkz:

Uyumlu şekillere sahip olmak üzere iki giriş x ve y yayınlamak için temel adımlar şunlardır:

  1. x ve y aynı sayıda boyuta sahip değilse, oluşana kadar dış boyutları (boyut 1 ile) ekleyin.

  2. x ve y farklı boyutlara sahip olduğu her boyut için:

    • x veya y , d boyutunda 1 boyutuna sahipse, diğer girdinin boyutuyla eşleşmesi için değerlerini d boyutunda tekrarlayın.

    • Aksi takdirde, bir istisna oluşturun ( x ve y yayınla uyumlu değildir).

Tek tip bir boyuttaki bir tensörün boyutunun tek bir sayı olduğu durumda (bu boyuttaki dilimlerin boyutu); ve düzensiz bir boyuttaki bir tensörün boyutu, dilim uzunluklarının bir listesidir (bu boyuttaki tüm dilimler için).

Yayın örnekleri

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

Aşağıda, yayınlamayan şekillere bazı örnekler verilmiştir:

# 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 kodlama

RaggedTensor tensörler, RaggedTensor sınıfı kullanılarak kodlanır. Dahili olarak, her bir RaggedTensor şunlardan oluşur:

  • Değişken uzunluktaki satırları düzleştirilmiş bir liste halinde birleştiren bir values tensörü.
  • Bu düzleştirilmiş değerlerin satırlara nasıl bölündüğünü gösteren bir row_partition .

ragged_encoding_2

row_partition dört farklı kodlama kullanılarak depolanabilir:

  • row_splits , satırlar arasındaki bölünme noktalarını belirten bir tamsayı vektörüdür.
  • value_rowids , her değer için satır dizinini belirten bir tamsayı vektörüdür.
  • row_lengths , her satırın uzunluğunu belirten bir tam sayı vektörüdür.
  • uniform_row_length , tüm satırlar için tek bir uzunluk belirten bir tamsayı uniform_row_length .

partition_encodings

Bir tam sayı skalar nrows de dahil edilebilir row_partition boş arka satır için hesap, kodlama value_rowids ile ya da boş satır 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]]>

Satır bölümleri için hangi kodlamanın kullanılacağının seçimi, bazı bağlamlarda verimliliği artırmak için dahili olarak düzensiz tensörler tarafından yönetilir. Özellikle, farklı sıra bölümleme şemalarının bazı avantajları ve dezavantajları şunlardır:

  • Etkili indeksleme : row_splits kodlaması, sabit zamanlı indekslemeyi ve düzensiz tensörlere dilimlemeyi sağlar.

  • Etkili birleştirme : row_lengths kodlaması, düzensiz tensörleri birleştirirken daha etkilidir, çünkü iki tensör birlikte birleştirildiğinde satır uzunlukları değişmez.

  • Küçük kodlama boyutu : value_rowids kodlaması, çok sayıda boş satıra sahip düzensiz tensörleri depolarken daha etkilidir, çünkü tensörün boyutu yalnızca toplam değer sayısına bağlıdır. Öte yandan, her satır için yalnızca bir skaler değer gerektirdiklerinden, row_splits ve row_lengths kodlamaları daha uzun satırlara sahip düzensiz tensörleri depolarken daha etkilidir.

  • Uyumluluk : value_rowids şeması, tf.segment_sum gibi işlemler tarafından kullanılan segmentasyon formatıyla tf.segment_sum . row_limits şeması tf.sequence_mask gibi tf.sequence_mask tarafından kullanılan tf.sequence_mask .

  • Düzgün boyutlar : Aşağıda tartışıldığı gibi, uniform_row_length kodlaması, düzgün boyutlara sahip düzensiz tensörleri kodlamak için kullanılır.

Birden çok düzensiz boyut

Birden çok düzensiz boyuta sahip düzensiz bir tensör, tensör values için yuvalanmış bir RaggedTensor kullanılarak kodlanır. Her yuvalanmış RaggedTensor , tek bir düzensiz boyut ekler.

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 fabrika işlevi, row_splits tensörlerinin bir listesini sağlayarak, birden çok düzensiz boyuta sahip bir RaggedTensor oluşturmak için doğrudan kullanılabilir:

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

Düzensiz derece ve düz değerler

Düzensiz bir tensörün düzensiz sıralaması , RaggedTensor temel values kaç kez bölümlendiğini (yani, RaggedTensor nesnelerinin yuvalama derinliği) RaggedTensor . En içteki values tensörü, düz_değerleri olarak bilinir. Aşağıdaki örnekte, conversations ragged_rank = 3 sahiptir, ve flat_values 1B olduğu Tensor 24 telli:

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

Düzgün iç boyutlar

Düzgün iç boyutlara sahip düzensiz tensörler, düz_değerler (yani, en içteki values ) için çok boyutlu bir tf.Tensor kullanılarak kodlanır.

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

Düzgün olmayan iç boyutlar

Düzgün olmayan iç boyutlara sahip düzensiz tensörler, uniform_row_length ile satırların bölümlenmesiyle kodlanır.

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