MatrixDiagV2

सार्वजनिक अंतिम वर्ग MatrixDiagV2

दिए गए बैच विकर्ण मानों के साथ एक बैच विकर्ण टेंसर लौटाता है।

`विकर्ण` में सामग्री के साथ मैट्रिक्स के `k[0]`-वें से `k[1]`-वें विकर्णों के साथ एक टेंसर लौटाता है, बाकी सब कुछ `पैडिंग` के साथ गद्देदार होता है। `num_rows` और `num_cols` आउटपुट के आंतरिक मैट्रिक्स के आयाम को निर्दिष्ट करते हैं। यदि दोनों निर्दिष्ट नहीं हैं, तो ऑप मानता है कि अंतरतम मैट्रिक्स वर्गाकार है और इसका आकार `k` और `विकर्ण` के अंतरतम आयाम से अनुमान लगाता है। यदि उनमें से केवल एक निर्दिष्ट है, तो ऑप मानता है कि अनिर्दिष्ट मान अन्य मानदंडों के आधार पर सबसे छोटा संभव है।

मान लीजिए `विकर्ण` के `r` आयाम `[I, J, ..., L, M, N]` हैं। आउटपुट टेंसर की रैंक `r+1` है जिसका आकार `[I, J, ..., L, M, num_rows, num_cols]` है, जब केवल एक विकर्ण दिया गया है (`k` एक पूर्णांक है या `k[0] == के[1]`). अन्यथा, इसकी रैंक `r` है जिसका आकार `[I, J, ..., L, num_rows, num_cols]` है।

'विकर्ण' के दूसरे सबसे भीतरी आयाम का दोहरा अर्थ है। जब `k` अदिश राशि है या `k[0] == k[1]`, `M` बैच आकार [I, J, ..., M] का हिस्सा है, और आउटपुट टेंसर है:

output[i, j, ..., l, m, n]
   = diagonal[i, j, ..., l, n-max(d_upper, 0)] ; if n - m == d_upper
     padding_value                             ; otherwise
 

अन्यथा, `M` को उसी बैच में मैट्रिक्स के विकर्णों की संख्या के रूप में माना जाता है (`M = k[1]-k[0]+1`), और आउटपुट टेंसर है:

output[i, j, ..., l, m, n]
   = diagonal[i, j, ..., l, diag_index, index_in_diag] ; if k[0] <= d <= k[1]
     padding_value                                     ; otherwise
 

जहां `d = n - m`, `diag_index = k[1] - d`, और `index_in_diag = n - max(d, 0)`।

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

# The main diagonal.
 diagonal = np.array([[1, 2, 3, 4],            # Input shape: (2, 4)
                      [5, 6, 7, 8]])
 tf.matrix_diag(diagonal) ==> [[[1, 0, 0, 0],  # Output shape: (2, 4, 4)
                                [0, 2, 0, 0],
                                [0, 0, 3, 0],
                                [0, 0, 0, 4]],
                               [[5, 0, 0, 0],
                                [0, 6, 0, 0],
                                [0, 0, 7, 0],
                                [0, 0, 0, 8]]]
 
 # A superdiagonal (per batch).
 diagonal = np.array([[1, 2, 3],  # Input shape: (2, 3)
                      [4, 5, 6]])
 tf.matrix_diag(diagonal, k = 1)
   ==> [[[0, 1, 0, 0],  # Output shape: (2, 4, 4)
         [0, 0, 2, 0],
         [0, 0, 0, 3],
         [0, 0, 0, 0]],
        [[0, 4, 0, 0],
         [0, 0, 5, 0],
         [0, 0, 0, 6],
         [0, 0, 0, 0]]]
 
 # A band of diagonals.
 diagonals = np.array([[[1, 2, 3],  # Input shape: (2, 2, 3)
                        [4, 5, 0]],
                       [[6, 7, 9],
                        [9, 1, 0]]])
 tf.matrix_diag(diagonals, k = (-1, 0))
   ==> [[[1, 0, 0],  # Output shape: (2, 3, 3)
         [4, 2, 0],
         [0, 5, 3]],
        [[6, 0, 0],
         [9, 7, 0],
         [0, 1, 9]]]
 
 # Rectangular matrix.
 diagonal = np.array([1, 2])  # Input shape: (2)
 tf.matrix_diag(diagonal, k = -1, num_rows = 3, num_cols = 4)
   ==> [[0, 0, 0, 0],  # Output shape: (3, 4)
        [1, 0, 0, 0],
        [0, 2, 0, 0]]
 
 # Rectangular matrix with inferred num_cols and padding_value = 9.
 tf.matrix_diag(diagonal, k = -1, num_rows = 3, padding_value = 9)
   ==> [[9, 9],  # Output shape: (3, 2)
        [1, 9],
        [9, 2]]
 

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

आउटपुट <T>	आउटपुट के रूप में () टेंसर का प्रतीकात्मक हैंडल लौटाता है।
स्थिर <टी> मैट्रिक्सडिआगवी2 <टी>	बनाएं ( स्कोप स्कोप, ऑपरेंड <T> विकर्ण, ऑपरेंड <Integer> k, ऑपरेंड <Integer> numRows, ऑपरेंड <Integer> numCols, ऑपरेंड <T> पैडिंगवैल्यू) एक नए मैट्रिक्सडिआगवी2 ऑपरेशन को लपेटकर एक क्लास बनाने की फ़ैक्टरी विधि।
आउटपुट <T>	आउटपुट () रैंक `r+1` है जब `k` एक पूर्णांक है या `k[0] == k[1]`, अन्यथा रैंक `r` है।

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

कक्षा org.tensorflow.op.PrimitiveOp से

अंतिम बूलियन	बराबर (वस्तु obj)
अंतिम पूर्णांक	हैश कोड ()
संचालन	ऑप () अंतर्निहित Operation लौटाता है
अंतिम स्ट्रिंग	स्ट्रिंग ()

कक्षा java.lang.Object से

बूलियन	बराबर (ऑब्जेक्ट arg0)
अंतिम कक्षा<?>	गेटक्लास ()
int यहाँ	हैश कोड ()
अंतिम शून्य	सूचित करें ()
अंतिम शून्य	सभी को सूचित करें ()
डोरी	स्ट्रिंग ()
अंतिम शून्य	प्रतीक्षा करें (लंबा arg0, int arg1)
अंतिम शून्य	प्रतीक्षा करें (लंबा arg0)
अंतिम शून्य	इंतज़ार ()

इंटरफ़ेस org.tensorflow.Operand से

सार आउटपुट <टी>

आउटपुट के रूप में () टेंसर का प्रतीकात्मक हैंडल लौटाता है।

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

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

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

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

सार्वजनिक स्थैतिक MatrixDiagV2 <T> बनाएं ( स्कोप स्कोप, ऑपरेंड <T> विकर्ण, ऑपरेंड <Integer> k, ऑपरेंड <Integer> numRows, ऑपरेंड <Integer> numCols, ऑपरेंड <T> पैडिंगवैल्यू)

एक नए मैट्रिक्सडिआगवी2 ऑपरेशन को लपेटकर एक क्लास बनाने की फ़ैक्टरी विधि।

पैरामीटर

दायरा	वर्तमान दायरा
विकर्ण	रैंक `r`, जहां `r >= 1`
क	विकर्ण ऑफसेट। सकारात्मक मान का अर्थ है सुपरविकर्ण, 0 मुख्य विकर्ण को संदर्भित करता है, और नकारात्मक मान का अर्थ है उपविकर्ण। `k` एक एकल पूर्णांक (एकल विकर्ण के लिए) या मैट्रिक्स बैंड के निम्न और उच्च सिरों को निर्दिष्ट करने वाले पूर्णांकों की एक जोड़ी हो सकता है। `k[0]` `k[1]` से बड़ा नहीं होना चाहिए।
संख्यापंक्तियाँ	आउटपुट मैट्रिक्स की पंक्तियों की संख्या. यदि यह प्रदान नहीं किया गया है, तो ऑप मानता है कि आउटपुट मैट्रिक्स एक वर्ग मैट्रिक्स है और k से मैट्रिक्स आकार और `विकर्ण` के अंतरतम आयाम का अनुमान लगाता है।
numCols	आउटपुट मैट्रिक्स के स्तंभों की संख्या. यदि यह प्रदान नहीं किया गया है, तो ऑप मानता है कि आउटपुट मैट्रिक्स एक वर्ग मैट्रिक्स है और k से मैट्रिक्स आकार और `विकर्ण` के अंतरतम आयाम का अनुमान लगाता है।
पैडिंगवैल्यू	निर्दिष्ट विकर्ण बैंड के बाहर के क्षेत्र को भरने की संख्या। डिफ़ॉल्ट 0 है.

रिटर्न

• MatrixDiagV2 का एक नया उदाहरण

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

रैंक `r+1` है जब `k` एक पूर्णांक है या `k[0] == k[1]`, अन्यथा रैंक `r` है।