7 दिसंबर को महिला एमएल संगोष्ठी में भाग लें अभी पंजीकरण करें

टेंसर स्लाइसिंग का परिचय

संग्रह की मदद से व्यवस्थित रहें अपनी प्राथमिकताओं के आधार पर, कॉन्टेंट को सेव करें और कैटगरी में बांटें.

TensorFlow.org पर देखें Google Colab में चलाएं GitHub पर स्रोत देखें नोटबुक डाउनलोड करें

ऑब्जेक्ट डिटेक्शन और एनएलपी जैसे एमएल एप्लिकेशन पर काम करते समय, कभी-कभी टेंसर के सब-सेक्शन (स्लाइस) के साथ काम करना आवश्यक होता है। उदाहरण के लिए, यदि आपके मॉडल आर्किटेक्चर में रूटिंग शामिल है, जहां एक परत नियंत्रित कर सकती है कि कौन सा प्रशिक्षण उदाहरण अगली परत पर रूट किया जाए। इस मामले में, आप टेंसर को विभाजित करने के लिए टेंसर स्लाइसिंग ऑप्स का उपयोग कर सकते हैं और उन्हें सही क्रम में वापस एक साथ रख सकते हैं।

एनएलपी अनुप्रयोगों में, आप प्रशिक्षण के दौरान शब्द मास्किंग करने के लिए टेंसर स्लाइसिंग का उपयोग कर सकते हैं। उदाहरण के लिए, आप प्रत्येक वाक्य में मास्क के लिए एक शब्द अनुक्रमणिका चुनकर, शब्द को एक लेबल के रूप में निकालकर, और फिर चुने हुए शब्द को मास्क टोकन के साथ बदलकर वाक्यों की सूची से प्रशिक्षण डेटा उत्पन्न कर सकते हैं।

इस गाइड में, आप सीखेंगे कि TensorFlow API का उपयोग कैसे करें:

  • टेंसर से स्लाइस निकालें
  • टेंसर में विशिष्ट सूचकांकों पर डेटा डालें

यह मार्गदर्शिका टेंसर इंडेक्सिंग से परिचित होने की बात करती है। इस गाइड को शुरू करने से पहले 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)
प्लेसहोल्डर17

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 जैसे तरीके जिनके लिए शून्य-आरंभिक टेंसर की आवश्यकता होती है, वे विरल टेंसर इनिशियलाइज़र के समान होते हैं। विरल टेंसर ऑप्स के व्यवहार की नकल करने के लिए आप 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)
35 एल10एन-प्लेसहोल्डर
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)

आगे पढ़ने और संसाधन

इस गाइड में, आपने सीखा कि अपने टेंसर में तत्वों पर बेहतर नियंत्रण करने के लिए TensorFlow के साथ उपलब्ध टेंसर स्लाइसिंग ऑप्स का उपयोग कैसे करें।