`सूचकांकों` के अनुसार `अपडेट्स` को एक नए टेंसर में बिखेरें।
सूचकांकों के अनुसार दिए गए `आकार` के टेंसर (प्रारंभ में संख्यात्मक के लिए शून्य, स्ट्रिंग के लिए खाली) के भीतर अलग-अलग मानों या स्लाइसों पर विरल `अपडेट` लागू करके एक नया टेंसर बनाता है। यह ऑपरेटर `tf.gather_nd` ऑपरेटर का उलटा है जो किसी दिए गए टेंसर से मान या स्लाइस निकालता है।
यह ऑपरेशन Tensor_scatter_add के समान है, सिवाय इसके कि टेंसर शून्य-प्रारंभिक है। `tf.scatter_nd(indices, values, size)` को कॉल करना `tensor_scatter_add(tf.zeros(shape, values.dtype), indices, values)` के समान है
यदि `सूचकांक` में डुप्लिकेट हैं, तो उनके अपडेट संचित (संक्षेपित) किए जाते हैं।
चेतावनी : जिस क्रम में अद्यतन लागू किए जाते हैं वह गैर-नियतात्मक है, इसलिए यदि `सूचकांक` में डुप्लिकेट हैं तो आउटपुट गैर-नियतात्मक होगा - कुछ संख्यात्मक सन्निकटन मुद्दों के कारण, अलग-अलग क्रम में संख्याओं को जोड़ने पर अलग-अलग परिणाम मिल सकते हैं।
`सूचकांक` एक पूर्णांक टेंसर है जिसमें सूचकांक `आकार` के एक नए टेंसर में समाहित होते हैं। `सूचकांकों` का अंतिम आयाम अधिकतम `आकार` की रैंक हो सकता है:
सूचकांक.आकार[-1] <= आकार.रैंक
`सूचकांक` का अंतिम आयाम तत्वों में सूचकांक से मेल खाता है (यदि `सूचकांक.आकार[-1] = आकार.रैंक`) या स्लाइस (यदि `सूचकांक.आकार[-1] <आकार.रैंक`) आयाम `सूचकांकों के साथ .shape[-1]` का `shape`। `अपडेट` आकार वाला एक टेंसर है
सूचकांक.आकार[:-1] + आकार[सूचकांक.आकार[-1]:]
स्कैटर का सबसे सरल रूप सूचकांक द्वारा व्यक्तिगत तत्वों को टेंसर में सम्मिलित करना है। उदाहरण के लिए, मान लें कि हम 8 तत्वों वाले रैंक-1 टेंसर में 4 बिखरे हुए तत्व सम्मिलित करना चाहते हैं।
पायथन में, यह स्कैटर ऑपरेशन इस तरह दिखेगा:
indices = tf.constant([[4], [3], [1], [7]])
updates = tf.constant([9, 10, 11, 12])
shape = tf.constant([8])
scatter = tf.scatter_nd(indices, updates, shape)
print(scatter)
[0, 11, 0, 10, 9, 0, 0, 12]
हम एक उच्च रैंक टेंसर के पूरे स्लाइस को एक साथ भी सम्मिलित कर सकते हैं। उदाहरण के लिए, यदि हम रैंक-3 टेंसर के पहले आयाम में नए मानों के दो मैट्रिक्स के साथ दो स्लाइस सम्मिलित करना चाहते हैं।
पायथन में, यह स्कैटर ऑपरेशन इस तरह दिखेगा:
indices = tf.constant([[0], [2]])
updates = tf.constant([[[5, 5, 5, 5], [6, 6, 6, 6],
[7, 7, 7, 7], [8, 8, 8, 8]],
[[5, 5, 5, 5], [6, 6, 6, 6],
[7, 7, 7, 7], [8, 8, 8, 8]]])
shape = tf.constant([4, 4, 4])
scatter = tf.scatter_nd(indices, updates, shape)
print(scatter)
[[[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]], [[0, 0, 0 , 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], [[5, 5, 5, 5], [6, 6 , 6, 6], [7, 7, 7, 7], [8, 8, 8, 8]], [[0, 0, 0, 0], [0, 0, 0, 0], [0 , 0, 0, 0], [0, 0, 0, 0]]]
ध्यान दें कि सीपीयू पर, यदि कोई आउट ऑफ बाउंड इंडेक्स पाया जाता है, तो एक त्रुटि वापस आ जाती है। जीपीयू पर, यदि कोई आउट ऑफ बाउंड इंडेक्स पाया जाता है, तो इंडेक्स को नजरअंदाज कर दिया जाता है।
सार्वजनिक तरीके
| आउटपुट <यू> | आउटपुट के रूप में () टेंसर का प्रतीकात्मक हैंडल लौटाता है। |
| स्थिर <यू, टी संख्या> स्कैटरएनडी <यू> का विस्तार करता है | |
| आउटपुट <यू> | आउटपुट () सूचकांकों के अनुसार दिए गए आकार और अपडेट के साथ एक नया टेंसर लागू किया गया। |
विरासत में मिली विधियाँ
सार्वजनिक तरीके
सार्वजनिक आउटपुट <यू> आउटपुट के रूप में ()
टेंसर का प्रतीकात्मक हैंडल लौटाता है।
TensorFlow संचालन के इनपुट किसी अन्य TensorFlow ऑपरेशन के आउटपुट हैं। इस पद्धति का उपयोग एक प्रतीकात्मक हैंडल प्राप्त करने के लिए किया जाता है जो इनपुट की गणना का प्रतिनिधित्व करता है।
सार्वजनिक स्थैतिक स्कैटरएनडी <यू> बनाएं ( स्कोप स्कोप, ऑपरेंड <टी> सूचकांक, ऑपरेंड <यू> अपडेट, ऑपरेंड <टी> आकार)
एक नए स्कैटरएनडी ऑपरेशन को लपेटकर एक क्लास बनाने की फ़ैक्टरी विधि।
पैरामीटर
| दायरा | वर्तमान दायरा |
|---|---|
| सूचकांक | सूचकांक टेंसर. |
| अपडेट | आउटपुट में बिखरने के लिए अद्यतन। |
| आकार | 1-डी. परिणामी टेंसर का आकार. |
रिटर्न
- स्कैटरएनडी का एक नया उदाहरण
सार्वजनिक आउटपुट <यू> आउटपुट ()
सूचकांकों के अनुसार दिए गए आकार और अपडेट के साथ एक नया टेंसर लागू किया गया।