tensorflow
टेंसर अनुक्रमण

परिचय

एक टेंसर से एक टुकड़ा निकालें

विस्तृत जानकारी के लिए tf.slice(input, begin, size) प्रलेखन देखें।

तर्क:

• input : टेन्सर
• begin : input प्रत्येक आयाम के लिए स्थान शुरू begin
• size : input प्रत्येक आयाम के लिए तत्वों की संख्या -1 का उपयोग करते हुए सभी शेष तत्व शामिल हैं

गांठदार-जैसे कटा हुआ:

# x has shape [2, 3, 2]
x = tf.constant([[[1., 2.], [3., 4. ], [5. , 6. ]],
                 [[7., 8.], [9., 10.], [11., 12.]]])

# Extracts x[0, 1:2, :] == [[[ 3.,  4.]]]
res = tf.slice(x, [0, 1, 0], [1, 1, -1])

तीसरे आयाम में अंतिम तत्व प्राप्त करने के लिए, नकारात्मक अनुक्रमण का उपयोग करना:

# Extracts x[0, :, -1:] == [[[2.], [4.], [6.]]]
last_indice = x.get_shape().as_list()[2] - 1
res = tf.slice(x, [0, 1, last_indice], [1, -1, -1])

किसी टेंसर के पहले आयाम से गैर-सन्निहित स्लाइस निकालें

आम तौर पर tf.gather आपको एक टेंसर के पहले आयाम में तत्वों तक पहुंच प्रदान करता है (जैसे कि 2-आयामी टेन्सर में पंक्तियाँ 1, 3 और 7)। यदि आपको पहले वाले की तुलना में किसी अन्य आयाम तक पहुंच की आवश्यकता है, या यदि आपको पूरे स्लाइस की आवश्यकता नहीं है, लेकिन उदाहरण के लिए 1, 3 और 7 वीं पंक्ति में केवल 5 वीं प्रविष्टि है, तो आप tf.gather_nd का उपयोग करके बेहतर हैं (आगामी देखें) इसके लिए उदाहरण)।

tf.gather तर्क:

• params : एक टेंसर जिसे आप मान निकालना चाहते हैं।
• indices : एक दशांश सूचक जो params में इंगित करता है

विस्तृत जानकारी के लिए tf.gather (params, सूचकांक) प्रलेखन देखें।

हम 2-आयामी टेंसर में पहली और चौथी पंक्ति को निकालना चाहते हैं।

# data is [[0, 1, 2, 3, 4, 5],
#          [6, 7, 8, 9, 10, 11],
#          ...
#          [24, 25, 26, 27, 28, 29]]
data = np.reshape(np.arange(30), [5, 6])
params = tf.constant(data)
indices = tf.constant([0, 3])
selected = tf.gather(params, indices)

selected का आकार [2, 6] और इसका मूल्य मुद्रण देता है

[[ 0  1  2  3  4  5]
 [18 19 20 21 22 23]]

indices केवल एक अदिश राशि हो सकते हैं (लेकिन नकारात्मक सूचकांक नहीं हो सकते)। उपरोक्त उदाहरण में:

tf.gather(params, tf.constant(3))

छपता था

[18 19 20 21 22 23]

ध्यान दें कि indices किसी भी आकार हो सकता है, लेकिन में संग्रहीत तत्वों indices हमेशा ही की पहली आयाम का उल्लेख params । उदाहरण के लिए, यदि आप एक ही समय में पहली और तीसरी पंक्ति और दूसरी और चौथी पंक्ति दोनों प्राप्त करना चाहते हैं, तो आप यह कर सकते हैं:

indices = tf.constant([[0, 2], [1, 3]])
selected = tf.gather(params, indices)

अब selected का आकार [2, 2, 6] और इसकी सामग्री पढ़ी जाएगी:

[[[ 0  1  2  3  4  5]
  [12 13 14 15 16 17]]

 [[ 6  7  8  9 10 11]
  [18 19 20 21 22 23]]]

आप क्रमपरिवर्तन की गणना करने के लिए tf.gather का उपयोग कर सकते हैं। उदाहरण के लिए, निम्न में से सभी पंक्तियों को उलट देता params :

indices = tf.constant(list(range(4, -1, -1)))
selected = tf.gather(params, indices)

अब selected है

[[24 25 26 27 28 29]
 [18 19 20 21 22 23]
 [12 13 14 15 16 17]
 [ 6  7  8  9 10 11]
 [ 0  1  2  3  4  5]]

यदि आपको पहले आयाम के अलावा किसी अन्य तक पहुंच की आवश्यकता है, तो आप tf.transpose का उपयोग करके चारों ओर काम कर सकते हैं: उदाहरण के लिए हमारे उदाहरण में पंक्तियों के बजाय कॉलम इकट्ठा करने के लिए, आप ऐसा कर सकते हैं:

indices = tf.constant([0, 2])
selected = tf.gather(tf.transpose(params, [1, 0]), indices)
selected_t = tf.transpose(selected, [1, 0]) 

selected_t आकार का है [5, 2] और पढ़ता है:

[[ 0  2]
 [ 6  8]
 [12 14]
 [18 20]
 [24 26]]

हालाँकि, tf.transpose बल्कि महंगा है, इसलिए इस उपयोग के मामले के लिए tf.gather_nd का उपयोग करना बेहतर हो सकता है।

टेंपरेचर का उपयोग करते हुए नम्पी जैसा अनुक्रमण

यह उदाहरण इस पोस्ट पर आधारित है: TensorFlow - numpy- जैसे टेंसर अनुक्रमण ।

Numpy में आप सरणी में इंडेक्स करने के लिए सरणियों का उपयोग कर सकते हैं। उदाहरण के लिए (1, 2) और (3, 2) में तत्वों को 2-आयामी सरणी में चुनने के लिए, आप यह कर सकते हैं:

# data is [[0, 1, 2, 3, 4, 5],
#          [6, 7, 8, 9, 10, 11],
#          [12 13 14 15 16 17],
#          [18 19 20 21 22 23],
#          [24, 25, 26, 27, 28, 29]]
data = np.reshape(np.arange(30), [5, 6])
a = [1, 3]
b = [2, 2]
selected = data[a, b]
print(selected)

यह प्रिंट करेगा:

[ 8 20]

Tensorflow में समान व्यवहार प्राप्त करने के लिए, आप उपयोग कर सकते tf.gather_nd , जिनमें से एक विस्तार है tf.gather । उपरोक्त उदाहरण को इस तरह लिखा जा सकता है:

x = tf.constant(data)
idx1 = tf.constant(a)
idx2 = tf.constant(b)
result = tf.gather_nd(x, tf.stack((idx1, idx2), -1))
        
with tf.Session() as sess:
    print(sess.run(result))

यह प्रिंट करेगा:

[ 8 20]

tf.stack के बराबर है np.asarray और इस मामले में पिछले आयाम में दो सूचकांक वैक्टर (जो इस मामले में 1 है) का निर्माण करने के स्टैक्स:

[[1 2]
 [3 2]]

Tf.gather_nd का उपयोग कैसे करें

tf.gather_nd इस अर्थ में tf.gather विस्तार है कि यह आपको न केवल एक टेंसर के 1 आयाम का उपयोग करने की अनुमति देता है, बल्कि संभवतः उन सभी को भी।

तर्क:

• params : दसियों का प्रतिनिधित्व करने वाले T को रैंक करने वाले P का एक Tensor
• indices : रैंक के एक टेन्सर Q में सूचकांक का प्रतिनिधित्व params हम पहुँच करना चाहते हैं

फ़ंक्शन का आउटपुट indices के आकार पर निर्भर करता है। यदि indices के अंतरतम आयाम की लंबाई P , तो हम params से एकल तत्व एकत्र कर रहे हैं। यदि यह P से कम है, तो हम tf.gather तरह ही स्लाइस जमा कर रहे हैं, लेकिन इस प्रतिबंध के बिना कि हम केवल 1 आयाम का उपयोग कर सकते हैं।

रैंक 2 के एक टेंसर से तत्वों को इकट्ठा करना

मैट्रिक्स में तत्व (1, 2) तक पहुंचने के लिए, हम उपयोग कर सकते हैं:

# data is [[0, 1, 2, 3, 4, 5],
#          [6, 7, 8, 9, 10, 11],
#          [12 13 14 15 16 17],
#          [18 19 20 21 22 23],
#          [24, 25, 26, 27, 28, 29]]
data = np.reshape(np.arange(30), [5, 6])
x = tf.constant(data)
result = tf.gather_nd(x, [1, 2])

जहां result उम्मीद के मुताबिक सिर्फ 8 होगा। ध्यान दें कि यह tf.gather से कैसे भिन्न है: tf.gather(x, [1, 2]) को दिए गए समान सूचक data से दूसरी और तीसरी पंक्ति के रूप में दिए गए होंगे।

यदि आप एक ही समय में एक से अधिक तत्वों को पुनः प्राप्त करना चाहते हैं, तो बस इंडेक्स जोड़े की एक सूची पास करें:

result = tf.gather_nd(x, [[1, 2], [4, 3], [2, 5]])

जो लौटेगा [ 8 27 17] will [ 8 27 17]

रैंक 2 के एक टेंसर से पंक्तियों को इकट्ठा करना

यदि उपरोक्त उदाहरण में आप तत्वों के बजाय पंक्तियों (यानी स्लाइस) को इकट्ठा करना चाहते हैं, तो indices पैरामीटर को निम्नानुसार समायोजित करें:

data = np.reshape(np.arange(30), [5, 6])
x = tf.constant(data)
result = tf.gather_nd(x, [[1], [3]])

इससे आपको दूसरी और चौथी पंक्ति का data मिलेगा, अर्थात

[[ 6  7  8  9 10 11]
 [18 19 20 21 22 23]]

रैंक 3 के एक टेंसर से तत्वों को एकत्रित करना

रैंक -2 टेनसर्स तक पहुंचने की अवधारणा सीधे उच्च आयामी टेंसरों में बदल जाती है। इसलिए, रैंक -3 टेंसर में तत्वों को एक्सेस करने के लिए, indices के अंतरतम आयाम की लंबाई 3 होनी चाहिए।

# data is [[[ 0  1]
#          [ 2  3]
#          [ 4  5]]
#
#         [[ 6  7]
#          [ 8  9]
#          [10 11]]]
data = np.reshape(np.arange(12), [2, 3, 2])
x = tf.constant(data)
result = tf.gather_nd(x, [[0, 0, 0], [1, 2, 1]])

result अब इस तरह दिखेगा: [ 0 11]

रैंक 3 के एक टेंसर से बैच वाली पंक्तियों को इकट्ठा करना

चलो एक रैंक -3 टेंसर के बारे में सोचते हैं, जो आकार के बैचों (batch_size, m, n) बैच के रूप में है। यदि आप बैच में प्रत्येक तत्व के लिए पहली और दूसरी पंक्ति एकत्र करना चाहते हैं, तो आप इसका उपयोग कर सकते हैं:

# data is [[[ 0  1]
#          [ 2  3]
#          [ 4  5]]
#
#         [[ 6  7]
#          [ 8  9]
#          [10 11]]]
data = np.reshape(np.arange(12), [2, 3, 2])
x = tf.constant(data)
result = tf.gather_nd(x, [[[0, 0], [0, 1]], [[1, 0], [1, 1]]])

जो इस में परिणाम होगा:

[[[0 1]
  [2 3]]

 [[6 7]
  [8 9]]]

ध्यान दें कि indices का आकार आउटपुट टेंसर के आकार को कैसे प्रभावित करता है। यदि हम indices तर्क के लिए रैंक -2 टेंसर का उपयोग करते हैं:

result = tf.gather_nd(x, [[0, 0], [0, 1], [1, 0], [1, 1]])

आउटपुट होता

[[0 1]
 [2 3]
 [6 7]
 [8 9]]