GatherNd

सार्वजनिक अंतिम कक्षा इकट्ठा

`पैरम्स` से स्लाइस को `इंडेक्स` द्वारा निर्दिष्ट आकार के साथ एक टेंसर में इकट्ठा करें।

`इंडिस` एक के-आयामी पूर्णांक टेंसर है, जिसे (के -1) के रूप में सबसे अच्छा माना जाता है - सूचकांकों के टेन्सर को `पैरा` में, जहां प्रत्येक तत्व `परम्स` के एक टुकड़े को परिभाषित करता है:

आउटपुट [\\(i_0, ..., i_{K-2}\\)] = पैराम्स [सूचकांक [\\(i_0, ..., i_{K-2}\\)2]]

जबकि tf.gather में `इंडेक्स` स्लाइस को `पैरा` के `अक्ष` आयाम में परिभाषित करता है, tf.gather_nd में, `इंडिस` स्लाइस को `परम्स` के पहले `एन` आयामों में परिभाषित करता है, जहां `एन = इंडेक्स। आकार [-1] `.

`सूचकांक` का अंतिम आयाम `परम्स` के अधिकतम रैंक पर हो सकता है:

index.shape[-1] <= params.रैंक

'सूचकांक' का अंतिम आयाम तत्वों (यदि 'सूचकांक.आकार[-1] == params.रैंक') या स्लाइस (यदि 'सूचकांक.आकार[-1] < params.रैंक') के साथ-साथ आयाम 'सूचकांक' से मेल खाता है। आकार [-1] `परम्स` का। आउटपुट टेंसर का आकार होता है

index.shape[:-1] + params.shape[indices.shape[-1]:]

ध्यान दें कि सीपीयू पर, यदि एक आउट ऑफ बाउंड इंडेक्स पाया जाता है, तो एक त्रुटि वापस आ जाती है। GPU पर, यदि एक आउट ऑफ़ बाउंड इंडेक्स पाया जाता है, तो 0 को संबंधित आउटपुट मान में संग्रहीत किया जाता है।

नीचे कुछ उदाहरण।

मैट्रिक्स में सरल अनुक्रमण:

indices = [[0, 0], [1, 1]]
     params = [['a', 'b'], ['c', 'd']]
     output = ['a', 'd']
 
मैट्रिक्स में स्लाइस अनुक्रमणिका:
indices = [[1], [0]]
     params = [['a', 'b'], ['c', 'd']]
     output = [['c', 'd'], ['a', 'b']]
 
3-टेंसर में अनुक्रमण:
indices = [[1]]
     params = [[['a0', 'b0'], ['c0', 'd0']],
               [['a1', 'b1'], ['c1', 'd1']]]
     output = [[['a1', 'b1'], ['c1', 'd1']]]
 
 
     indices = [[0, 1], [1, 0]]
     params = [[['a0', 'b0'], ['c0', 'd0']],
               [['a1', 'b1'], ['c1', 'd1']]]
     output = [['c0', 'd0'], ['a1', 'b1']]
 
 
     indices = [[0, 0, 1], [1, 0, 1]]
     params = [[['a0', 'b0'], ['c0', 'd0']],
               [['a1', 'b1'], ['c1', 'd1']]]
     output = ['b0', 'b1']
 
-placeholder5 मैट्रिक्स में बैच अनुक्रमण:
indices = [[[0, 0]], [[0, 1]]]
     params = [['a', 'b'], ['c', 'd']]
     output = [['a'], ['b']]
 
मैट्रिक्स में बैच अनुक्रमण स्लाइस:
indices = [[[1]], [[0]]]
     params = [['a', 'b'], ['c', 'd']]
     output = [[['c', 'd']], [['a', 'b']]]
 
बैच अनुक्रमण में a 3-टेंसर:
indices = [[[1]], [[0]]]
     params = [[['a0', 'b0'], ['c0', 'd0']],
               [['a1', 'b1'], ['c1', 'd1']]]
     output = [[[['a1', 'b1'], ['c1', 'd1']]],
               [[['a0', 'b0'], ['c0', 'd0']]]]
 
     indices = [[[0, 1], [1, 0]], [[0, 0], [1, 1]]]
     params = [[['a0', 'b0'], ['c0', 'd0']],
               [['a1', 'b1'], ['c1', 'd1']]]
     output = [[['c0', 'd0'], ['a1', 'b1']],
               [['a0', 'b0'], ['c1', 'd1']]]
 
 
     indices = [[[0, 0, 1], [1, 0, 1]], [[0, 1, 1], [1, 1, 0]]]
     params = [[['a0', 'b0'], ['c0', 'd0']],
               [['a1', 'b1'], ['c1', 'd1']]]
     output = [['b0', 'b1'], ['d0', 'c1']]
 
tf.gather और `tf.batch_gather` भी देखें।

सार्वजनिक तरीके

आउटपुट <टी>
आउटपुट के रूप में ()
टेंसर का प्रतीकात्मक हैंडल लौटाता है।
स्थिर <टी, यू संख्या बढ़ाता है> इकट्ठा करें <टी>
create ( स्कोप स्कोप, ऑपरेंड <T> पैराम्स, ऑपरेंड <U> इंडेक्स)
एक नया GatherNd ऑपरेशन रैपिंग क्लास बनाने के लिए फ़ैक्टरी विधि।
आउटपुट <टी>
आउटपुट ()
आकार `indices.shape[:-1] + params.shape[indices.shape[-1]:]` के साथ, `index` द्वारा दिए गए इंडेक्स से एकत्रित `params` के मान।

विरासत में मिली विधियां

सार्वजनिक तरीके

सार्वजनिक आउटपुट <T> आउटपुट के रूप में ()

टेंसर का प्रतीकात्मक हैंडल लौटाता है।

TensorFlow संचालन के लिए इनपुट एक अन्य TensorFlow ऑपरेशन के आउटपुट हैं। इस पद्धति का उपयोग एक प्रतीकात्मक हैंडल प्राप्त करने के लिए किया जाता है जो इनपुट की गणना का प्रतिनिधित्व करता है।

पब्लिक स्टैटिक गैदरएनडी <टी> क्रिएट ( स्कोप स्कोप, ऑपरेंड <टी> पैराम्स, ऑपरेंड <यू> इंडेक्स)

एक नया GatherNd ऑपरेशन रैपिंग क्लास बनाने के लिए फ़ैक्टरी विधि।

मापदंडों
दायरा वर्तमान दायरा
पैरामीटर वह टेंसर जिससे मान इकट्ठा करना है।
सूचकांक सूचकांक टेंसर।
रिटर्न
  • GatherNd . का एक नया उदाहरण

सार्वजनिक आउटपुट <टी> आउटपुट ()

आकार `indices.shape[:-1] + params.shape[indices.shape[-1]:]` के साथ, `index` द्वारा दिए गए इंडेक्स से एकत्रित `params` के मान।