MatrixDiag

सार्वजनिक अंतिम कक्षा मैट्रिक्सडिआग

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

`विकर्ण` में सामग्री के साथ मैट्रिक्स के `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]]
 

स्थिरांक

डोरी OP_NAME इस ऑप का नाम, जैसा कि TensorFlow कोर इंजन द्वारा जाना जाता है

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

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

विरासत में मिले तरीके

स्थिरांक

सार्वजनिक स्थैतिक अंतिम स्ट्रिंग OP_NAME

इस ऑप का नाम, जैसा कि TensorFlow कोर इंजन द्वारा जाना जाता है

स्थिर मान: "MatrixDiagV2"

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

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

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

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

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

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

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

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

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