সাহায্য Kaggle উপর TensorFlow সঙ্গে গ্রেট বেরিয়ার রিফ রক্ষা চ্যালেঞ্জ যোগদান

টেন্সর স্লাইসিং এর ভূমিকা

TensorFlow.org-এ দেখুন Google Colab-এ চালান GitHub-এ উৎস দেখুন নোটবুক ডাউনলোড করুন

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

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

এই নির্দেশিকাটিতে, আপনি কীভাবে টেনসরফ্লো এপিআই ব্যবহার করবেন তা শিখবেন:

  • একটি টেনসর থেকে স্লাইস বের করুন
  • একটি টেনসরে নির্দিষ্ট সূচকে ডেটা সন্নিবেশ করান

এই নির্দেশিকা টেনসর ইন্ডেক্সিংয়ের সাথে পরিচিতি অনুমান করে। এই নির্দেশিকা দিয়ে শুরু করার আগে Tensor এবং TensorFlow NumPy গাইডের ইন্ডেক্সিং বিভাগগুলি পড়ুন।

সেটআপ

import tensorflow as tf
import numpy as np

টেনসর স্লাইস নিষ্কাশন

tf.slice ব্যবহার করে tf.slice মতো টেনসর স্লাইসিং সম্পাদন করুন।

t1 = tf.constant([0, 1, 2, 3, 4, 5, 6, 7])

print(tf.slice(t1,
               begin=[1],
               size=[3]))
tf.Tensor([1 2 3], shape=(3,), dtype=int32)

বিকল্পভাবে, আপনি আরও পাইথনিক সিনট্যাক্স ব্যবহার করতে পারেন। নোট করুন যে টেনসর স্লাইসগুলি একটি স্টার্ট-স্টপ পরিসরে সমানভাবে ব্যবধানে রয়েছে।

print(t1[1:4])
tf.Tensor([1 2 3], shape=(3,), dtype=int32)

print(t1[-3:])
tf.Tensor([5 6 7], shape=(3,), dtype=int32)

2-মাত্রিক টেনসরের জন্য, আপনি এমন কিছু ব্যবহার করতে পারেন:

t2 = tf.constant([[0, 1, 2, 3, 4],
                  [5, 6, 7, 8, 9],
                  [10, 11, 12, 13, 14],
                  [15, 16, 17, 18, 19]])

print(t2[:-1, 1:3])
tf.Tensor(
[[ 1  2]
 [ 6  7]
 [11 12]], shape=(3, 2), dtype=int32)

আপনি tf.slice ব্যবহার করতে পারেন।

t3 = tf.constant([[[1, 3, 5, 7],
                   [9, 11, 13, 15]],
                  [[17, 19, 21, 23],
                   [25, 27, 29, 31]]
                  ])

print(tf.slice(t3,
               begin=[1, 1, 0],
               size=[1, 1, 2]))
tf.Tensor([[[25 27]]], shape=(1, 1, 2), dtype=int32)

এছাড়াও আপনি টেনসরের মাত্রার উপর 'স্ট্রাইডিং' করে টেনসরের স্লাইস বের করতে tf.strided_slice ব্যবহার করতে পারেন।

একটি টেনসরের একক অক্ষ থেকে নির্দিষ্ট সূচকগুলি বের করতে tf.gather ব্যবহার করুন।

print(tf.gather(t1,
                indices=[0, 3, 6]))

# This is similar to doing

t1[::3]
tf.Tensor([0 3 6], shape=(3,), dtype=int32)
<tf.Tensor: shape=(3,), dtype=int32, numpy=array([0, 3, 6], dtype=int32)>

tf.gather এর জন্য সূচকগুলিকে সমানভাবে ব্যবধানে রাখতে হবে না।

alphabet = tf.constant(list('abcdefghijklmnopqrstuvwxyz'))

print(tf.gather(alphabet,
                indices=[2, 0, 19, 18]))
tf.Tensor([b'c' b'a' b't' b's'], shape=(4,), dtype=string)

একটি টেনসরের একাধিক অক্ষ থেকে স্লাইস বের করতে, tf.gather_nd ব্যবহার করুন। এটি দরকারী যখন আপনি একটি ম্যাট্রিক্সের উপাদানগুলিকে শুধুমাত্র এর সারি বা কলামের বিপরীতে সংগ্রহ করতে চান।

t4 = tf.constant([[0, 5],
                  [1, 6],
                  [2, 7],
                  [3, 8],
                  [4, 9]])

print(tf.gather_nd(t4,
                   indices=[[2], [3], [0]]))
tf.Tensor(
[[2 7]
 [3 8]
 [0 5]], shape=(3, 2), dtype=int32)

t5 = np.reshape(np.arange(18), [2, 3, 3])

print(tf.gather_nd(t5,
                   indices=[[0, 0, 0], [1, 2, 1]]))
tf.Tensor([ 0 16], shape=(2,), dtype=int64)
# Return a list of two matrices

print(tf.gather_nd(t5,
                   indices=[[[0, 0], [0, 2]], [[1, 0], [1, 2]]]))
tf.Tensor(
[[[ 0  1  2]
  [ 6  7  8]]

 [[ 9 10 11]
  [15 16 17]]], shape=(2, 2, 3), dtype=int64)
# Return one matrix

print(tf.gather_nd(t5,
                   indices=[[0, 0], [0, 2], [1, 0], [1, 2]]))
tf.Tensor(
[[ 0  1  2]
 [ 6  7  8]
 [ 9 10 11]
 [15 16 17]], shape=(4, 3), dtype=int64)

টেনসরগুলিতে ডেটা সন্নিবেশ করান

একটি টেনসরের নির্দিষ্ট স্লাইস/সূচকে ডেটা সন্নিবেশ করতে tf.scatter_nd ব্যবহার করুন। মনে রাখবেন যে টেনসরের মধ্যে আপনি মান সন্নিবেশ করান তা শূন্য-প্রবর্তিত।

t6 = tf.constant([10])
indices = tf.constant([[1], [3], [5], [7], [9]])
data = tf.constant([2, 4, 6, 8, 10])

print(tf.scatter_nd(indices=indices,
                    updates=data,
                    shape=t6))
tf.Tensor([ 0  2  0  4  0  6  0  8  0 10], shape=(10,), dtype=int32)

tf.scatter_nd এর মত পদ্ধতি যার জন্য জিরো-ইনিশিয়ালাইজড টেনসর প্রয়োজন হয় স্পার্স টেনসর ইনিশিয়ালাইজারের মত। আপনি sparse tensor ops এর আচরণ অনুকরণ করতে tf.gather_nd এবং tf.scatter_nd ব্যবহার করতে পারেন।

একটি উদাহরণ বিবেচনা করুন যেখানে আপনি একযোগে এই দুটি পদ্ধতি ব্যবহার করে একটি স্পার্স টেনসর তৈরি করেন।

# Gather values from one tensor by specifying indices

new_indices = tf.constant([[0, 2], [2, 1], [3, 3]])
t7 = tf.gather_nd(t2, indices=new_indices)

# Add these values into a new tensor

t8 = tf.scatter_nd(indices=new_indices, updates=t7, shape=tf.constant([4, 5]))

print(t8)
tf.Tensor(
[[ 0  0  2  0  0]
 [ 0  0  0  0  0]
 [ 0 11  0  0  0]
 [ 0  0  0 18  0]], shape=(4, 5), dtype=int32)

এটি অনুরূপ:

t9 = tf.SparseTensor(indices=[[0, 2], [2, 1], [3, 3]],
                     values=[2, 11, 18],
                     dense_shape=[4, 5])

print(t9)
SparseTensor(indices=tf.Tensor(
[[0 2]
 [2 1]
 [3 3]], shape=(3, 2), dtype=int64), values=tf.Tensor([ 2 11 18], shape=(3,), dtype=int32), dense_shape=tf.Tensor([4 5], shape=(2,), dtype=int64))
# Convert the sparse tensor into a dense tensor

t10 = tf.sparse.to_dense(t9)

print(t10)
tf.Tensor(
[[ 0  0  2  0  0]
 [ 0  0  0  0  0]
 [ 0 11  0  0  0]
 [ 0  0  0 18  0]], shape=(4, 5), dtype=int32)

প্রাক-বিদ্যমান মান সহ একটি টেনসরে ডেটা সন্নিবেশ করতে, tf.tensor_scatter_nd_add ব্যবহার করুন।

t11 = tf.constant([[2, 7, 0],
                   [9, 0, 1],
                   [0, 3, 8]])

# Convert the tensor into a magic square by inserting numbers at appropriate indices

t12 = tf.tensor_scatter_nd_add(t11,
                               indices=[[0, 2], [1, 1], [2, 0]],
                               updates=[6, 5, 4])

print(t12)
tf.Tensor(
[[2 7 6]
 [9 5 1]
 [4 3 8]], shape=(3, 3), dtype=int32)

একইভাবে, আগে থেকে বিদ্যমান মান সহ একটি টেনসর থেকে মান বিয়োগ করতে tf.tensor_scatter_nd_sub ব্যবহার করুন।

# Convert the tensor into an identity matrix

t13 = tf.tensor_scatter_nd_sub(t11,
                               indices=[[0, 0], [0, 1], [1, 0], [1, 1], [1, 2], [2, 1], [2, 2]],
                               updates=[1, 7, 9, -1, 1, 3, 7])

print(t13)
tf.Tensor(
[[1 0 0]
 [0 1 0]
 [0 0 1]], shape=(3, 3), dtype=int32)

একটি টেনসর থেকে অন্য টেনসরে উপাদান-ভিত্তিক ন্যূনতম মান অনুলিপি করতে tf.tensor_scatter_nd_min ব্যবহার করুন।

t14 = tf.constant([[-2, -7, 0],
                   [-9, 0, 1],
                   [0, -3, -8]])

t15 = tf.tensor_scatter_nd_min(t14,
                               indices=[[0, 2], [1, 1], [2, 0]],
                               updates=[-6, -5, -4])

print(t15)
tf.Tensor(
[[-2 -7 -6]
 [-9 -5  1]
 [-4 -3 -8]], shape=(3, 3), dtype=int32)

একইভাবে, একটি টেনসর থেকে অন্য টেনসরে উপাদান-ভিত্তিক সর্বাধিক মান অনুলিপি করতে tf.tensor_scatter_nd_max ব্যবহার করুন।

t16 = tf.tensor_scatter_nd_max(t14,
                               indices=[[0, 2], [1, 1], [2, 0]],
                               updates=[6, 5, 4])

print(t16)
tf.Tensor(
[[-2 -7  6]
 [-9  5  1]
 [ 4 -3 -8]], shape=(3, 3), dtype=int32)

আরও পড়া এবং সম্পদ

এই নির্দেশিকাটিতে, আপনি শিখেছেন কীভাবে আপনার টেনসরের উপাদানগুলির উপর সূক্ষ্ম নিয়ন্ত্রণ প্রয়োগ করতে টেনসরফ্লো-এর সাথে উপলব্ধ টেনসর স্লাইসিং অপ্সগুলি ব্যবহার করতে হয়।