এই পৃষ্ঠাটি Cloud Translation API অনুবাদ করেছে।

রাগযুক্ত টেন্সর

TensorFlow.org এ দেখুন

Google Colab-এ চালান

GitHub-এ উৎস দেখুন

নোটবুক ডাউনলোড করুন

API ডকুমেন্টেশন: tf.RaggedTensor tf.ragged

সেটআপ

import math
import tensorflow as tf

ওভারভিউ

আপনার ডেটা অনেক আকারে আসে; আপনার টেনসরও উচিত। Ragged tensors হল TensorFlow সমতুল্য নেস্টেড পরিবর্তনশীল-দৈর্ঘ্য তালিকা। তারা নন-ইউনিফর্ম আকার সহ ডেটা সঞ্চয় এবং প্রক্রিয়া করা সহজ করে তোলে, যার মধ্যে রয়েছে:

পরিবর্তনশীল-দৈর্ঘ্যের বৈশিষ্ট্য, যেমন একটি চলচ্চিত্রের অভিনেতাদের সেট।
পরিবর্তনশীল-দৈর্ঘ্যের অনুক্রমিক ইনপুটগুলির ব্যাচ, যেমন বাক্য বা ভিডিও ক্লিপ।
অনুক্রমিক ইনপুট, যেমন টেক্সট ডকুমেন্ট যা বিভাগ, অনুচ্ছেদ, বাক্য এবং শব্দে বিভক্ত।
স্ট্রাকচার্ড ইনপুটগুলিতে পৃথক ক্ষেত্র, যেমন প্রোটোকল বাফার।

আপনি একটি ragged টেনসর সঙ্গে কি করতে পারেন

র্যাগড টেনসরগুলি গণিত অপারেশন (যেমন tf.add এবং tf.reduce_mean ), অ্যারে অপারেশন (যেমন tf.concat এবং tf.tile ), স্ট্রিং ম্যানিপুলেশন অপারেশন (যেমন tf.substr ) সহ শতাধিক টেনসরফ্লো অপারেশন দ্বারা সমর্থিত। ), নিয়ন্ত্রণ প্রবাহ অপারেশন (যেমন tf.while_loop এবং tf.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 প্যাকেজ ডকুমেন্টেশন দেখুন।

Ragged tensors কেরাস , ডেটাসেট , tf.function , SavedModels , এবং tf.Example সহ অনেক TensorFlow API দ্বারা সমর্থিত। আরও তথ্যের জন্য, নীচের TensorFlow API- এর বিভাগটি দেখুন।

সাধারণ টেনসরগুলির মতো, আপনি একটি র‍্যাগড টেনসরের নির্দিষ্ট স্লাইস অ্যাক্সেস করতে পাইথন-স্টাইলের সূচী ব্যবহার করতে পারেন। আরও তথ্যের জন্য, নীচের সূচীকরণের বিভাগটি পড়ুন।

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

এবং সাধারণ টেনসরের মতো, আপনি উপাদানভিত্তিক ক্রিয়াকলাপ সম্পাদন করতে পাইথন গাণিতিক এবং তুলনা অপারেটর ব্যবহার করতে পারেন। আরও তথ্যের জন্য, নীচের ওভারলোডেড অপারেটরগুলির বিভাগটি দেখুন৷

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 ব্যবহার করতে পারেন, যা একটি ফাংশন প্লাস এক বা একাধিক আর্গুমেন্ট নেয় এবং 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], []]>

রাগড টেনসরগুলি নেস্টেড পাইথন list s এবং NumPy array s এ রূপান্তরিত করা যেতে পারে:

digits.to_list()

[[3, 1, 4, 1], [], [5, 9, 2], [6], []]

digits.numpy()

/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/ops/ragged/ragged_tensor.py:2063: 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)

একটি ন্যাকড়া টেনসর নির্মাণ

একটি র‍্যাগড টেনসর নির্মাণের সহজ উপায় হল tf.ragged.constant ব্যবহার করা, যা একটি প্রদত্ত নেস্টেড পাইথন list বা NumPy array সাথে সম্পর্কিত 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_row_lengths tf.RaggedTensor.from_value_rowids , tf.RaggedTensor.from_row_lit.tf.RaggedTensor.from_row_lits.tf.RaggedTensor 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 row-partitioning tensor

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 ক্লাস ডকুমেন্টেশন দেখুন।

আপনি একটি রাগড টেনসরে কি সংরক্ষণ করতে পারেন

সাধারণ RaggedTensor Tensor মানগুলি অবশ্যই একই ধরণের হতে হবে; এবং মানগুলি অবশ্যই একই নেস্টিং গভীরতায় (টেনসরের র্যাঙ্ক ) হতে হবে:

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 s ব্যবহার করা যেতে পারে একটি পরিবর্তনশীল-দৈর্ঘ্যের প্রশ্নের ব্যাচের জন্য ইউনিগ্রাম এবং বিগ্রাম এম্বেডিং তৈরি এবং একত্রিত করতে, প্রতিটি বাক্যের শুরু এবং শেষের জন্য বিশেষ মার্কার ব্যবহার করে। এই উদাহরণে ব্যবহৃত অপ্স সম্পর্কে আরও বিশদ বিবরণের জন্য, 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 and 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.14285272  0.02908629 -0.16327512 -0.14529026]
 [-0.4479212  -0.35615516  0.17110227  0.2522229 ]
 [-0.1987868  -0.13152348 -0.0325102   0.02125177]], shape=(3, 4), dtype=float32)

রাগড টেনসর উদাহরণ

রাগড এবং অভিন্ন মাত্রা

একটি র‍্যাগড ডাইমেনশন হল একটি ডাইমেনশন যার স্লাইসগুলির দৈর্ঘ্য বিভিন্ন হতে পারে। উদাহরণস্বরূপ, rt=[[3, 1, 4, 1], [], [5, 9, 2], [6], []] এর অভ্যন্তরীণ (কলাম) মাত্রাটি র‍্যাগড, যেহেতু কলামের স্লাইসগুলি ( rt[0, :] , ..., rt[4, :] ) এর বিভিন্ন দৈর্ঘ্য আছে। যে সকল ডাইমেনশনের স্লাইসগুলির দৈর্ঘ্য একই থাকে তাকে অভিন্ন মাত্রা বলে।

একটি র‍্যাগড টেনসরের বাইরের দিকটি সর্বদা অভিন্ন, কারণ এটি একটি একক স্লাইস নিয়ে গঠিত (এবং, তাই, স্লাইস দৈর্ঘ্যের ভিন্নতার কোনো সম্ভাবনা নেই)। অবশিষ্ট মাত্রা হয় ragged বা অভিন্ন হতে পারে. উদাহরণ স্বরূপ, আপনি আকৃতি [num_sentences, (num_words), embedding_size] সহ একটি র‍্যাগড টেনসর ব্যবহার করে বাক্যগুলির একটি ব্যাচে প্রতিটি শব্দের জন্য এম্বেডিং শব্দ সংরক্ষণ করতে পারেন, যেখানে চারপাশে বন্ধনী (num_words) নির্দেশ করে যে মাত্রাটি র‍্যাগড।

একটি রাগড টেনসর ব্যবহার করে শব্দ এম্বেডিং

র‍্যাগড টেনসরের একাধিক র‍্যাগড মাত্রা থাকতে পারে। উদাহরণস্বরূপ, আপনি আকৃতি [num_documents, (num_paragraphs), (num_sentences), (num_words)] সহ একটি টেনসর ব্যবহার করে কাঠামোগত পাঠ্য নথির একটি ব্যাচ সংরক্ষণ করতে পারেন (যেখানে আবার বন্ধনী ব্যবহার করা হয় রাগ করা মাত্রা নির্দেশ করতে)।

tf.Tensor এর মতো, একটি র‍্যাগড টেনসরের র‍্যাঙ্ক হল এর মোট মাত্রার সংখ্যা (র্যাগড এবং ইউনিফর্ম উভয় মাত্রা সহ)। একটি সম্ভাব্য র‍্যাগড টেনসর হল একটি মান যা হয় একটি tf.Tensor বা একটি tf.RaggedTensor হতে পারে।

একটি RaggedTensor এর আকৃতি বর্ণনা করার সময়, র‍্যাগড মাত্রাগুলিকে প্রচলিতভাবে বন্ধনীতে আবদ্ধ করে নির্দেশ করা হয়। উদাহরণ স্বরূপ, আপনি উপরে দেখেছেন, একটি 3D RaggedTensor-এর আকৃতি যা প্রতিটি শব্দের জন্য একটি বাক্যে এম্বেডিং সংরক্ষণ করে [num_sentences, (num_words), embedding_size] হিসাবে লেখা যেতে পারে।

RaggedTensor.shape অ্যাট্রিবিউটটি একটি ragged টেনসরের জন্য একটি 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)

রাগড বনাম স্পারস

একটি র‌্যাগড টেনসরকে এক ধরনের স্পার্স টেনসর হিসেবে ভাবা উচিত নয় । বিশেষ করে, sparse tensors হল tf.Tensor এর জন্য দক্ষ এনকোডিং যা একই ডেটাকে কমপ্যাক্ট ফরম্যাটে মডেল করে; কিন্তু র‌্যাগড টেনসর হল tf. টেনসরের একটি tf.Tensor যা ডেটার একটি প্রসারিত শ্রেণীকে মডেল করে। অপারেশন সংজ্ঞায়িত করার সময় এই পার্থক্যটি অত্যন্ত গুরুত্বপূর্ণ:

একটি স্পার্স বা ঘন টেনসরে একটি অপ প্রয়োগ করা সবসময় একই ফলাফল দিতে হবে।
একটি র‍্যাগড বা স্পারস টেনসরে একটি অপ প্রয়োগ করা বিভিন্ন ফলাফল দিতে পারে।

একটি দৃষ্টান্তমূলক উদাহরণ হিসাবে, বিবেচনা করুন কিভাবে অ্যারে অপারেশন যেমন concat , stack এবং tile রাগড বনাম স্পারস টেনসরের জন্য সংজ্ঞায়িত করা হয়। একত্রিত র্যাগড টেনসর প্রতিটি সারিতে যুক্ত হয়ে মিলিত দৈর্ঘ্যের সাথে একটি একক সারি তৈরি করে:

রাগড টেনসরগুলিকে সংযুক্ত করা

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_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 মতো একটি অপের জন্য "প্রতিটি সারির গড় মান" এর সংজ্ঞাটি বিবেচনা করুন। একটি র‍্যাগড টেনসরের জন্য, একটি সারির গড় মান হল সারির প্রস্থ দ্বারা বিভক্ত সারির মানগুলির সমষ্টি৷ কিন্তু একটি স্পার্স টেনসরের জন্য, একটি সারির গড় মান হল সারির মানের সমষ্টিকে স্পার্স টেনসরের সামগ্রিক প্রস্থ (যা দীর্ঘতম সারির প্রস্থের চেয়ে বেশি বা সমান) দ্বারা ভাগ করা হয়।

TensorFlow APIs

কেরাস

tf.keras হল TensorFlow-এর উচ্চ-স্তরের API যা গভীর শিক্ষার মডেল তৈরি ও প্রশিক্ষণের জন্য। র্যাগড টেনসরগুলি কেরাস মডেলে ইনপুট হিসাবে প্রেরণ করা যেতে পারে ragged=True on tf.keras.Input বা tf.keras.layers.InputLayer করে। র্যাগড টেনসরগুলি কেরাস স্তরগুলির মধ্যেও পাস করা যেতে পারে এবং কেরাস মডেলগুলি দ্বারা ফিরে আসতে পারে। নিম্নলিখিত উদাহরণটি একটি খেলনা 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 kernels since it doesn't meet the criteria. It will use a generic GPU kernel as fallback when running on GPU.
Epoch 1/5
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/framework/indexed_slices.py:449: 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: 3.1269
Epoch 2/5
1/1 [==============================] - 0s 18ms/step - loss: 2.1197
Epoch 3/5
1/1 [==============================] - 0s 19ms/step - loss: 2.0196
Epoch 4/5
1/1 [==============================] - 0s 20ms/step - loss: 1.9371
Epoch 5/5
1/1 [==============================] - 0s 18ms/step - loss: 1.8857
[[0.02800461]
 [0.00945962]
 [0.02283431]
 [0.00252927]]

tf. উদাহরণ

tf.Example হল TensorFlow ডেটার জন্য একটি আদর্শ প্রোটোবাফ এনকোডিং। tf.Example সহ এনকোড করা ডেটা। উদাহরণ s-এ প্রায়শই পরিবর্তনশীল-দৈর্ঘ্য বৈশিষ্ট্য অন্তর্ভুক্ত থাকে। উদাহরণ স্বরূপ, নিম্নলিখিত কোডটি চারটি 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 ব্যবহার করুন:

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 , যা উপাদানগুলির একটি ক্রম প্রতিনিধিত্ব করে, যেখানে প্রতিটি উপাদান এক বা একাধিক উপাদান নিয়ে গঠিত।

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

র‍্যাগড টেনসর সহ ডেটাসেট ব্যাচিং এবং আনব্যাচ করা

Dataset.batch পদ্ধতি ব্যবহার করে র‍্যাগড টেনসর সহ ডেটাসেটগুলি ব্যাচ করা যেতে পারে (যা n পরপর উপাদানগুলিকে একক উপাদানে একত্রিত করে)।

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

র‍্যাগড টেনসর সহ ডেটাসেটগুলিকে রূপান্তর করা

এছাড়াও আপনি 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.ফাংশন

tf.function হল একটি ডেকোরেটর যা Python ফাংশনগুলির জন্য TensorFlow গ্রাফগুলিকে প্রি-কম্পিউট করে, যা আপনার TensorFlow কোডের কার্যকারিতা উল্লেখযোগ্যভাবে উন্নত করতে পারে। র‍্যাগড @tf.function সজ্জিত ফাংশনগুলির সাথে স্বচ্ছভাবে ব্যবহার করা যেতে পারে। উদাহরণস্বরূপ, নিম্নলিখিত ফাংশনটি র‍্যাগড এবং নন-র্যাগড টেনসরের সাথে কাজ করে:

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

2021-09-22 20:36:51.018367: W tensorflow/core/grappler/optimizers/loop_optimizer.cc:907] Skipping loop optimization for Merge node with control input: RaggedConcat/assert_equal_1/Assert/AssertGuard/branch_executed/_9
<tf.RaggedTensor [[1, 2, 2, 1], [3, 3], [4, 5, 6, 6, 5, 4]]>

আপনি যদি tf.function-এর জন্য 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
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]]>

সংরক্ষিত মডেল

একটি SavedModel হল একটি ক্রমিক টেনসরফ্লো প্রোগ্রাম, যার মধ্যে ওজন এবং গণনা উভয়ই রয়েছে। এটি একটি কেরাস মডেল বা একটি কাস্টম মডেল থেকে তৈরি করা যেতে পারে। উভয় ক্ষেত্রেই, একটি সংরক্ষিত মডেল দ্বারা সংজ্ঞায়িত ফাংশন এবং পদ্ধতিগুলির সাথে রাগড টেনসরগুলি স্বচ্ছভাবে ব্যবহার করা যেতে পারে।

উদাহরণ: কেরাস মডেল সংরক্ষণ করা

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)

2021-09-22 20:36:52.069689: W tensorflow/python/util/util.cc:348] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.
WARNING:absl:Function `_wrapped_model` contains input name(s) args_0 with unsupported characters which will be renamed to args_0_1 in the SavedModel.
INFO:tensorflow:Assets written to: /tmp/tmp114axtt7/assets
INFO:tensorflow:Assets written to: /tmp/tmp114axtt7/assets
<tf.Tensor: shape=(4, 1), dtype=float32, numpy=
array([[0.02800461],
       [0.00945962],
       [0.02283431],
       [0.00252927]], 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, you must ensure that concrete functions are
# built for each input signature that you 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/tmpnn4u8dy5/assets
INFO:tensorflow:Assets written to: /tmp/tmpnn4u8dy5/assets
<tf.RaggedTensor [[100.0, 400.0, 300.0], [200.0]]>

দ্রষ্টব্য: সংরক্ষিত মডেল স্বাক্ষরগুলি কংক্রিট ফাংশন। উপরের কংক্রিট ফাংশনগুলির বিভাগে যেমন আলোচনা করা হয়েছে, টেনসরফ্লো 2.3 দিয়ে শুরু হওয়া কংক্রিট ফাংশনগুলির দ্বারা র্যাগড টেনসরগুলি সঠিকভাবে পরিচালনা করা হয়। আপনার যদি TensorFlow-এর পূর্ববর্তী সংস্করণে SavedModel স্বাক্ষর ব্যবহার করার প্রয়োজন হয়, তাহলে এটি সুপারিশ করা হয় যে আপনি র‍্যাগড টেনসরটিকে এর কম্পোনেন্ট টেনসরে পচিয়ে দিন।

ওভারলোড অপারেটর

RaggedTensor ক্লাস স্ট্যান্ডার্ড পাইথন গাণিতিক এবং তুলনা অপারেটরকে ওভারলোড করে, যা মৌলিক উপাদানভিত্তিক গণিত সম্পাদন করা সহজ করে তোলে:

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() ; এবং বাইনারি অপারেটর + , - , * , / , // , % , ** , & , | , ^ , == , < , <= , > , এবং >= ।

ইনডেক্সিং

র‍্যাগড টেনসরগুলি বহুমাত্রিক ইন্ডেক্সিং এবং স্লাইসিং সহ পাইথন-স্টাইলের ইন্ডেক্সিং সমর্থন করে। নিম্নলিখিত উদাহরণগুলি একটি 2D এবং একটি 3D র্যাগড টেনসরের সাথে র্যাগড টেনসর ইন্ডেক্সিং প্রদর্শন করে।

ইন্ডেক্সিং উদাহরণ: 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 (2D RaggedTensor)

<tf.RaggedTensor [[5], [], [6]]>

print(rt[3, 0])                     # First element of fourth row (1D Tensor)

tf.Tensor([8 9], shape=(2,), dtype=int32)

print(rt[:, 1:3])                   # Items 1-3 of each row (3D RaggedTensor)

<tf.RaggedTensor [[[4]], [[], [6]], [], [[10]]]>

print(rt[:, -1:])                   # Last item of each row (3D RaggedTensor)

<tf.RaggedTensor [[[4]], [[6]], [[7]], [[10]]]>

RaggedTensor এর সমর্থন বহুমাত্রিক সূচীকরণ এবং একটি সীমাবদ্ধতার সাথে স্লাইসিং: একটি র‍্যাগড মাত্রায় সূচীকরণ অনুমোদিত নয়। এই ক্ষেত্রে সমস্যাযুক্ত কারণ নির্দেশিত মান কিছু সারিতে বিদ্যমান থাকতে পারে কিন্তু অন্যগুলিতে নয়। এই ধরনের ক্ষেত্রে, আপনার (1) একটি IndexError উত্থাপন করা উচিত কিনা তা স্পষ্ট নয়; (2) একটি ডিফল্ট মান ব্যবহার করুন; অথবা (3) সেই মানটি এড়িয়ে যান এবং আপনি শুরু করেছিলেন তার চেয়ে কম সারি সহ একটি টেনসর ফেরত দিন। পাইথনের নির্দেশিকা নীতি অনুসরণ করে ("অস্পষ্টতার মুখে, অনুমান করার প্রলোভন প্রত্যাখ্যান করুন"), এই অপারেশনটি বর্তমানে অননুমোদিত।

টেনসর টাইপ রূপান্তর

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

রাগড টেনসর মূল্যায়ন করা হচ্ছে

একটি র‍্যাগড টেনসরে মানগুলি অ্যাক্সেস করতে, আপনি করতে পারেন:

রাগড টেনসরকে নেস্টেড পাইথন তালিকায় রূপান্তর করতে tf.RaggedTensor.to_list ব্যবহার করুন।
রাগড টেনসরকে NumPy অ্যারেতে রূপান্তর করতে tf.RaggedTensor.numpy ব্যবহার করুন যার মান NumPy অ্যারে নেস্ট করা হয়।
tf.RaggedTensor.values এবং tf.RaggedTensor.row_splits বৈশিষ্ট্য ব্যবহার করে, বা সারি-বিভাজন পদ্ধতি যেমন tf.RaggedTensor.row_lengths এবং tf.RaggedTensor.value_rowids ব্যবহার করে র‌্যাগড টেনসরকে এর উপাদানগুলিতে পচনশীল করুন।
রাগড টেনসর থেকে মান নির্বাচন করতে পাইথন ইন্ডেক্সিং ব্যবহার করুন।

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.7/site-packages/tensorflow/python/ops/ragged/ragged_tensor.py:2063: 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)

সম্প্রচার

সম্প্রচার হল বিভিন্ন আকারের সাথে টেনসর তৈরির প্রক্রিয়া যা উপাদান অনুসারে ক্রিয়াকলাপের জন্য সামঞ্জস্যপূর্ণ আকার রয়েছে। সম্প্রচারের আরও পটভূমির জন্য, পড়ুন:

সামঞ্জস্যপূর্ণ আকারের জন্য দুটি ইনপুট x এবং y সম্প্রচারের প্রাথমিক পদক্ষেপগুলি হল:

যদি x এবং y এর মাত্রা একই না থাকে, তাহলে বাইরের মাত্রা যোগ করুন (আকার 1 সহ) যতক্ষণ না তারা না করে।
প্রতিটি মাত্রার জন্য যেখানে x এবং y এর বিভিন্ন আকার রয়েছে:

যদি x বা y এর আকার d এ আকার 1 থাকে, তাহলে অন্য ইনপুটের আকারের সাথে মেলে 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 এনকোডিং

Ragged RaggedTensor ক্লাস ব্যবহার করে এনকোড করা হয়। অভ্যন্তরীণভাবে, প্রতিটি RaggedTensor এর মধ্যে রয়েছে:

একটি values টেনসর, যা পরিবর্তনশীল-দৈর্ঘ্যের সারিগুলিকে একটি সমতল তালিকায় সংযুক্ত করে।
একটি row_partition , যা নির্দেশ করে কিভাবে সেই সমতল মানগুলিকে সারিতে ভাগ করা হয়েছে।

RaggedTensor এনকোডিং

row_partition চারটি ভিন্ন এনকোডিং ব্যবহার করে সংরক্ষণ করা যেতে পারে:

row_splits হল একটি পূর্ণসংখ্যা ভেক্টর যা সারিগুলির মধ্যে বিভক্ত বিন্দু নির্দিষ্ট করে।
value_rowids হল একটি পূর্ণসংখ্যা ভেক্টর যা প্রতিটি মানের জন্য সারি সূচক নির্দিষ্ট করে।
row_lengths হল একটি পূর্ণসংখ্যা ভেক্টর যা প্রতিটি সারির দৈর্ঘ্য নির্দিষ্ট করে।
uniform_row_length হল একটি পূর্ণসংখ্যা স্কেলার যা সমস্ত সারির জন্য একটি একক দৈর্ঘ্য নির্দিষ্ট করে।

row_partition এনকোডিং

একটি পূর্ণসংখ্যা স্কেলার nrows কে row_partition এনকোডিং-এ অন্তর্ভুক্ত করা যেতে পারে যাতে মান_রোভিড সহ খালি uniform_row_length সারি বা value_rowids সহ খালি সারি।

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 এনকোডিং আরও কার্যকর, যেহেতু দুটি টেনসর একসাথে সংযুক্ত হলে সারির দৈর্ঘ্য পরিবর্তিত হয় না।
ছোট এনকোডিং আকার : র্যাগড টেনসর সংরক্ষণ করার সময় value_rowids এনকোডিং আরও কার্যকর হয় যেখানে প্রচুর পরিমাণে খালি সারি রয়েছে, যেহেতু টেনসরের আকার শুধুমাত্র মোট মানের উপর নির্ভর করে। অন্যদিকে, লম্বা সারি সহ র্যাগড টেনসর সংরক্ষণ করার সময় row_splits এবং row_lengths এনকোডিংগুলি আরও কার্যকর হয়, কারণ তাদের প্রতিটি সারির জন্য শুধুমাত্র একটি স্কেলার মান প্রয়োজন।
সামঞ্জস্যতা : value_rowids স্কিমটি অপারেশন দ্বারা ব্যবহৃত বিভাজন বিন্যাসের সাথে মেলে, যেমন tf.segment_sum । row_limits স্কিমটি tf.sequence_mask এর মতো ops দ্বারা ব্যবহৃত ফর্ম্যাটের সাথে মেলে।
ইউনিফর্ম ডাইমেনশন : নিচে যেমন আলোচনা করা হয়েছে, ইউনিফর্ম_রো_লেংথ এনকোডিং ইউনিফর্ম ডাইমেনশন সহ uniform_row_length এনকোড করতে ব্যবহৃত হয়।

একাধিক রাগড মাত্রা

values টেনসরের জন্য একটি নেস্টেড RaggedTensor ব্যবহার করে একাধিক র‍্যাগড ডাইমেনশন সহ একটি র‍্যাগড টেনসর এনকোড করা হয়। প্রতিটি নেস্টেড RaggedTensor একটি একক রাগড মাত্রা যোগ করে।

একাধিক র‍্যাগড মাত্রা সহ একটি র‍্যাগড টেনসরের এনকোডিং (র্যাঙ্ক 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 টেনসরকে কতবার বিভাজন করা হয়েছে (অর্থাৎ RaggedTensor অবজেক্টের নেস্টিং গভীরতা)। অন্তঃস্থ 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.

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)

অভিন্ন অভ্যন্তরীণ মাত্রা

অভিন্ন অভ্যন্তরীণ মাত্রা সহ র্যাগড tf.Tensor সমতল_মানগুলির (অর্থাৎ, সবচেয়ে ভিতরের values ) এর জন্য একটি বহুমাত্রিক tf. টেনসর ব্যবহার করে এনকোড করা হয়।

অভিন্ন অভ্যন্তরীণ মাত্রা সহ রাগযুক্ত টেনসরগুলির এনকোডিং

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 সহ সারি পার্টিশন করে এনকোড করা হয়।

অভিন্ন অ-অভ্যন্তরীণ মাত্রা সহ রাগড টেনসরের এনকোডিং

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