चेतावनी: यह एपीआई हटा दिया गया है और प्रतिस्थापन के स्थिर होने के बाद TensorFlow के भविष्य के संस्करण में हटा दिया जाएगा।

ParallelDynamicStitch

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

'डेटा' टेंसर के मानों को एक टेंसर में इंटरलीव करें।

एक मर्ज किए गए टेंसर को इस तरह बनाता है कि

merged[indices[m][i, ..., j], ...] = data[m][i, ..., j, ...]
 
उदाहरण के लिए, यदि प्रत्येक `सूचकांक [m]` अदिश या सदिश है, तो हमारे पास
# Scalar indices:
     merged[indices[m], ...] = data[m][...]
 
     # Vector indices:
     merged[indices[m][i], ...] = data[m][i, ...]
 
प्रत्येक `डेटा [i] .shape` संबंधित `सूचकांक [i] से शुरू होना चाहिए। आकार', और शेष 'डेटा [i]. आकार' निरंतर wrt `i` होना चाहिए। यानी हमारे पास `डेटा [i] आकार = सूचकांक [i] आकार + स्थिरांक होना चाहिए। इस `स्थिर` के संदर्भ में, आउटपुट आकार है

मर्ज किए गए आकार = [अधिकतम (सूचकांक)] + स्थिरांक

मानों को समानांतर में मर्ज किया जा सकता है, इसलिए यदि कोई अनुक्रमणिका `सूचकांक[m][i]` और `सूचकांक[n][j]` दोनों में दिखाई देती है, तो परिणाम अमान्य हो सकता है। यह सामान्य डायनेमिकस्टिच ऑपरेटर से अलग है जो उस मामले में व्यवहार को परिभाषित करता है।

उदाहरण के लिए:

indices[0] = 6
     indices[1] = [4, 1]
     indices[2] = [[5, 2], [0, 3]]
     data[0] = [61, 62]
     data[1] = [[41, 42], [11, 12]]
     data[2] = [[[51, 52], [21, 22]], [[1, 2], [31, 32]]]
     merged = [[1, 2], [11, 12], [21, 22], [31, 32], [41, 42],
               [51, 52], [61, 62]]
 
इस विधि का उपयोग `डायनामिक_पार्टिशन` द्वारा बनाए गए विभाजनों को मर्ज करने के लिए किया जा सकता है जैसा कि निम्नलिखित उदाहरण में दिखाया गया है:
# Apply function (increments x_i) on elements for which a certain condition
     # apply (x_i != -1 in this example).
     x=tf.constant([0.1, -1., 5.2, 4.3, -1., 7.4])
     condition_mask=tf.not_equal(x,tf.constant(-1.))
     partitioned_data = tf.dynamic_partition(
         x, tf.cast(condition_mask, tf.int32) , 2)
     partitioned_data[1] = partitioned_data[1] + 1.0
     condition_indices = tf.dynamic_partition(
         tf.range(tf.shape(x)[0]), tf.cast(condition_mask, tf.int32) , 2)
     x = tf.dynamic_stitch(condition_indices, partitioned_data)
     # Here x=[1.1, -1., 6.2, 5.3, -1, 8.4], the -1. values remain
     # unchanged.
 

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

आउटपुट <टी>
आउटपुट के रूप में ()
टेंसर का प्रतीकात्मक हैंडल लौटाता है।
स्थिर <टी> समानांतर गतिशील सिलाई <टी>
create ( स्कोप स्कोप, Iterable< ऑपरेंड <इंटीजर>> इंडेक्स, Iterable< ऑपरेंड <T>> डेटा)
एक नया ParallelDynamicStitch ऑपरेशन रैपिंग क्लास बनाने के लिए फ़ैक्टरी विधि।
आउटपुट <टी>

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

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

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

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

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

सार्वजनिक स्थैतिक समानांतर गतिशील सिलाई <टी> बनाएं ( स्कोप स्कोप, इटरेबल < ऑपरेंड <इंटीजर>> इंडेक्स, इटरेबल < ऑपरेंड <टी>> डेटा)

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

मापदंडों
दायरा वर्तमान दायरा
रिटर्न
  • ParallelDynamicStitch का एक नया उदाहरण

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