This page was translated by the Cloud Translation API.
Switch to English

র‌্যাগড টেনারস

টেনসরফ্লো.আর.জে দেখুন গুগল কোলাবে চালান গিটহাবের উত্স দেখুন নোটবুক ডাউনলোড করুন

এপিআই ডকুমেন্টেশন: tf.RaggedTensor tf.Ragged

সেটআপ

import math
import tensorflow as tf

ওভারভিউ

আপনার ডেটা বিভিন্ন আকারে আসে; আপনার টেনারদেরও উচিত। র‌্যাগড টেনসর হ'ল নেস্টেড ভেরিয়েবল-দৈর্ঘ্যের তালিকার টেনসরফ্লো equivalent এগুলি সহ অ-ইউনিফর্ম আকার সহ ডেটা সঞ্চয় এবং প্রক্রিয়াজাতকরণকে সহজ করে তোলে:

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

র‌্যাগড টেনসর দিয়ে আপনি কী করতে পারেন

র‌্যাগড tf.add গণিত ক্রিয়াকলাপগুলি (যেমন 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 তালিকার জন্য, দেখুন tf.ragged প্যাকেজ ডকুমেন্টেশন

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

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

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

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

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 হল tf.ragged.constant ব্যবহার করা, যা একটি নির্দিষ্ট নেস্টেড পাইথন list বা রেপিড 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_value_rowids , tf.RaggedTensor.from_row_lengths , এবং tf.RaggedTensor.from_row_splits হিসাবে ফ্যাক্টরি শ্রেণিবদ্ধ ব্যবহার করতে হবে tf.RaggedTensor.from_row_splits

tf.RaggedTensor.from_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 সারি বিভাজনকারী টেনসর ব্যবহার করতে পারেন:

সারি_ দৈর্ঘ্য

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

371e02747 বি
tf.Tensor(
[[ 0.10999689  0.10575606 -0.28228763  0.24919255]
 [-0.22778393  0.14891823  0.45986378 -0.3109092 ]
 [ 0.09017418 -0.02079154  0.23155184 -0.01072874]], shape=(3, 4), dtype=float32)

ragged_example

রাগযুক্ত এবং অভিন্ন মাত্রা

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

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

প্রেরণ_ শব্দ_ইম্বড

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

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

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

RaggedTensor.shape বৈশিষ্ট্যটি একটি tf.TensorShape জন্য একটি tf.TensorShape প্রদান করে, যেখানে tf.TensorShape মাত্রাগুলির আকার None :

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

tf.RaggedTensor.bounding_shape পদ্ধতিটি প্রদত্ত RaggedTensor জন্য RaggedTensor আকারটি ব্যবহার করতে ব্যবহার করা যেতে পারে:

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

র‌্যাগড বনাম বিরল

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

  • একটি বিচ্ছিন্ন বা ঘন টেনসর একটি বিকল্প প্রয়োগ সর্বদা একই ফলাফল দেওয়া উচিত।
  • র‌্যাগড বা স্পার্স টেনসারে একটি বিকল্প প্রয়োগ করা বিভিন্ন ফলাফল দিতে পারে।

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

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

তবে স্পর্স টেনারগুলিকে সামঞ্জস্য করার সাথে সম্পর্কিত ঘন টেনারগুলি সংশ্লেষ করার সমতুল্য, যেমন নীচের উদাহরণ দ্বারা চিত্রিত হয়েছে (যেখানে missing অনুপস্থিত মানগুলি নির্দেশ করে):

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

টেনসরফ্লো এপিআই

কেরাস

tf.keras গভীর শিক্ষার মডেলগুলি তৈরি এবং প্রশিক্ষণের জন্য টেনসরফ্লো এর উচ্চ-স্তরের এপিআই। র‌্যাগড tf.keras.Input কেরাস মডেলের ইনপুট হিসাবে পাস করা যেতে পারে tf.keras.Input ragged=True tf.keras.Input বা tf.keras.layers.InputLayer ragged=True স্থাপন করে। র‌্যাগড টেনারগুলি কেরাস স্তরগুলির মধ্যেও পাস হতে পারে এবং কেরাস মডেলগুলি দ্বারা ফিরে আসতে পারে। নিম্নলিখিত উদাহরণটি একটি খেলনা এলএসটিএম মডেল দেখায় যা র‌্যাগড টেনার ব্যবহার করে প্রশিক্ষিত হয়।

# 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 2ms/step - loss: 3.3884
Epoch 2/5
1/1 [==============================] - 0s 977us/step - loss: 2.0579
Epoch 3/5
1/1 [==============================] - 0s 1ms/step - loss: 2.0157
Epoch 4/5
1/1 [==============================] - 0s 988us/step - loss: 1.9858
Epoch 5/5
1/1 [==============================] - 0s 990us/step - loss: 1.9260
[[0.03027334]
 [0.01302399]
 [0.01826342]
 [0.00842744]]

tf.Example

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

ডেটাসেটস

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 গুলি থেকে যেমন Dataset.from_tensor_slices তৈরি করতে ব্যবহৃত হয় একই পদ্ধতি ব্যবহার করে ডেটাসেটগুলি tf.Tensor থেকে তৈরি করা যেতে পারে:

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]

র‌্যাগড টেনার সহ ডেটাসেটগুলি ব্যাচিং এবং আনবাচিং

জীর্ণ tensors সঙ্গে ডেটাসেট শ্রেণীবদ্ধ করা যেতে পারে (যা সম্মিলন এন একটি একক উপাদান মধ্যে পরপর উপাদান) ব্যবহার Dataset.batch পদ্ধতি।

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 ডেটাসেটটি 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 এবং টেনসরের দৈর্ঘ্য উপাদানগুলির মধ্যে পৃথক হয় তবে আপনি dense_to_ragged_batch রূপান্তরটি প্রয়োগ করে সেই নন- dense_to_ragged_batch করতে 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 ব্যবহার করে তৈরি বা রূপান্তর করা 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 একটি সাজসজ্জা যা পাইথন ফাংশনগুলির জন্য টেনসরফ্লো গ্রাফগুলিকে প্রাক্পম্প্ট করে, যা আপনার টেনসরফ্লো কোডটির কার্যকারিতা যথেষ্ট পরিমাণে উন্নত করতে পারে। র‌্যাগড @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 গ্রাফকে encapsulate করে। টেনসরফ্লো ২.৩ (এবং 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]]>

টেনসরফ্লো ২.৩ এর আগে যদি আপনাকে row_splits কংক্রিটের ফাংশনগুলির সাথে ব্যবহার করার প্রয়োজন হয়, তবে আমরা row_splits তাদের উপাদানগুলিতে ( values এবং row_splits ) বিভক্ত করার এবং তাদের পৃথক যুক্তি হিসাবে পাস করার পরামর্শ 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]]>

সেভডমডেলস

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

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

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

<tf.Tensor: shape=(4, 1), dtype=float32, numpy=
array([[0.03027334],
       [0.01302399],
       [0.01826342],
       [0.00842744]], 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/tmphdjk87du/assets

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

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

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

সূচক

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

সূচকের উদাহরণ: 2 ডি রগড টেনসর

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

সূচক উদাহরণগুলি 3 ডি র‌্যাগড টেনসর or

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) IndexError বাড়াতে হবে কিনা তা স্পষ্ট নয়; (২) একটি ডিফল্ট মান ব্যবহার করুন; বা (3) সেই মানটি এড়িয়ে যান এবং আমরা শুরু করার চেয়ে কম সারি দিয়ে একটি সেন্সরটি ফিরিয়ে দেব। পাইথনের গাইড নীতি অনুসরণ করে ("অস্পষ্টতার মুখে অনুমান করার প্রলোভনটি অস্বীকার করুন"), আমরা বর্তমানে এই ক্রিয়াকলাপটিকে অস্বীকার করি।

টেনসর ধরণের রূপান্তর

RaggedTensor শ্রেণি এমন পদ্ধতিগুলি সংজ্ঞায়িত করে যা RaggedTensor এবং tf.Tensor গুলি বা 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() নেস্টেড পাইথন তালিকায় রূপান্তর করতে tf.RaggedTensor.to_list() ব্যবহার করুন।
  2. tf.RaggedTensor.numpy() একটি নম্পী অ্যারে রূপান্তর করতে tf.RaggedTensor.numpy() ব্যবহার করুন যার মানগুলি নেস্টি অ্যারেগুলিতে থাকে।
  3. tf.RaggedTensor.values এবং tf.RaggedTensor.row_splits বৈশিষ্ট্য, অথবা tf.RaggedTensor.row_lengths() এবং tf.RaggedTensor.value_rowids() মতো সারি-পার্টিশন পদ্ধতিগুলি ব্যবহার করে, tf.RaggedTensor.values তার উপাদানগুলিতে বিভক্ত করুন।
  4. র‌্যাগড টেনসর থেকে মানগুলি নির্বাচন করতে পাইথন সূচী ব্যবহার করুন।
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]

সম্প্রচার

ব্রডকাস্টিং হ'ল বিভিন্ন আকারের টেনারগুলি তৈরির প্রক্রিয়াটি এলিমেন্টওয়ালা ক্রিয়াকলাপগুলির জন্য উপযুক্ত আকারযুক্ত থাকে। সম্প্রচারের আরও পটভূমির জন্য, দেখুন:

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

  1. যদি x এবং y এর মাত্রা একই পরিমাণে না থাকে, তবে বাহ্যিক মাত্রা (আকার 1 সহ) তারা না করা পর্যন্ত যুক্ত করুন।

  2. প্রতিটি মাত্রার জন্য যেখানে x এবং y বিভিন্ন আকার রয়েছে:

    • যদি x বা y আকার 1 মাত্রা d , তবে অন্যান্য ইনপুটটির আকারের সাথে মাপতে ডাইমেনশন d জুড়ে এর মানগুলি পুনরাবৃত্তি করুন।

    • অন্যথায়, একটি ব্যতিক্রম উত্থাপন ( x এবং y সম্প্রচারিত সঙ্গতিপূর্ণ নয়)।

যেখানে অভিন্ন মাত্রায় টেনসরের আকার একক সংখ্যা (সেই মাত্রা জুড়ে স্লাইসের আকার); এবং একটি রাগযুক্ত মাত্রায় একটি সেন্সরের আকার হ'ল স্লাইস দৈর্ঘ্যের একটি তালিকা (সেই মাত্রা জুড়ে সমস্ত স্লাইসের জন্য)।

সম্প্রচারের উদাহরণ

d2e022674 বি
<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 :

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

ragged_encoding_2

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

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

পার্টিশন_এনকোডিংস

একটি পূর্ণসংখ্যা স্কালে 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_splits সক্ষম করে।

  • দক্ষ row_lengths : row_lengths এনকোডিং আরও কার্যকরী, যেহেতু দুটি টেনার একসাথে একত্রিত হয়ে গেলে সারি দৈর্ঘ্য পরিবর্তন হয় না।

  • ছোট এনকোডিংয়ের আকার : প্রচুর পরিমাণে খালি সারি রয়েছে এমন value_rowids সংরক্ষণ করার সময় value_rowids এনকোডিং আরও কার্যকর, যেহেতু value_rowids আকার কেবলমাত্র মানগুলির মোট সংখ্যার উপর নির্ভর করে। অন্যদিকে, লম্বা সারিগুলির সাথে row_lengths সংরক্ষণ করার সময় row_splits এবং row_lengths এনকোডিংগুলি আরও দক্ষ হয়, যেহেতু তাদের প্রতিটি সারির জন্য কেবল একটি স্কেলারের মান প্রয়োজন।

  • সামঞ্জস্যতা : value_rowids স্কিম value_rowids মতো ক্রিয়াকলাপগুলির দ্বারা ব্যবহৃত সেগমেন্টেশন ফর্ম্যাটটির সাথে tf.segment_sumrow_limits স্কিম row_limits মতো অপ্স দ্বারা ব্যবহৃত ফর্ম্যাটটির সাথে tf.sequence_mask

  • অভিন্ন মাত্রা : নীচে আলোচিত হিসাবে, ইউনিফর্ম_রো_ uniform_row_length এনকোডিংটি অভিন্ন মাত্রা সহ uniform_row_length এনকোড করতে ব্যবহৃত হয়।

একাধিক রাগযুক্ত মাত্রা

values RaggedTensor জন্য নেস্টেড RaggedTensor ব্যবহার করে একাধিক RaggedTensor মাত্রা সহ একটি RaggedTensor টেনসর এনকোড করা হয়। প্রতিটি নেস্টেড RaggedTensor একটি একক 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 তালিকা সরবরাহ করে:

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 বস্তুর RaggedTensor গভীরতা)। অন্তর্নিহিত values সেন্সরটি এর ফ্ল্যাট_ভ্যালু হিসাবে পরিচিত। নিম্নলিখিত উদাহরণে, conversations ragged_rank = 3 হয়েছে এবং এর flat_values 24 টি স্ট্রিং সহ 1 ডি 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)

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

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

ইউনিফর্ম_ইনার

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