MatrixDiagV3

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

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

`विकर्ण` में सामग्री के साथ मैट्रिक्स के `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] - d`, और `index_in_diag = n - max(d, 0) + offset`।

`ऑफ़सेट` शून्य है, सिवाय इसके कि जब विकर्ण का संरेखण दाईं ओर हो।

offset = max_diag_len - diag_len(d) ; if (`align` in {RIGHT_LEFT, RIGHT_RIGHT}
                                            and `d >= 0`) or
                                          (`align` in {LEFT_RIGHT, RIGHT_RIGHT}
                                            and `d <= 0`)
          0                          ; otherwise
जहां `diag_len(d) = min(cols - max(d, 0), rows + min(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 tridiagonal band (per batch).
 diagonals = np.array([[[0, 8, 9],  # Input shape: (2, 2, 3)
                        [1, 2, 3],
                        [4, 5, 0]],
                       [[0, 2, 3],
                        [6, 7, 9],
                        [9, 1, 0]]])
 tf.matrix_diag(diagonals, k = (-1, 1))
   ==> [[[1, 8, 0],  # Output shape: (2, 3, 3)
         [4, 2, 9],
         [0, 5, 3]],
        [[6, 2, 0],
         [9, 7, 3],
         [0, 1, 9]]]
 
 # LEFT_RIGHT alignment.
 diagonals = np.array([[[8, 9, 0],  # Input shape: (2, 2, 3)
                        [1, 2, 3],
                        [0, 4, 5]],
                       [[2, 3, 0],
                        [6, 7, 9],
                        [0, 9, 1]]])
 tf.matrix_diag(diagonals, k = (-1, 1), align="LEFT_RIGHT")
   ==> [[[1, 8, 0],  # Output shape: (2, 3, 3)
         [4, 2, 9],
         [0, 5, 3]],
        [[6, 2, 0],
         [9, 7, 3],
         [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]]

नेस्टेड क्लासेस

कक्षा मैट्रिक्सडायगV3.विकल्प MatrixDiagV3 के लिए वैकल्पिक विशेषताएँ

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

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

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

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

सार्वजनिक स्थैतिक MatrixDiagV3. विकल्प संरेखित करें (स्ट्रिंग संरेखित करें)

पैरामीटर
संरेखित कुछ विकर्ण `max_diag_len` से छोटे हैं और उन्हें गद्देदार बनाने की आवश्यकता है। `संरेखण` एक स्ट्रिंग है जो निर्दिष्ट करती है कि क्रमशः सुपरडायगोनल और सबडायगोनल को कैसे संरेखित किया जाना चाहिए। चार संभावित संरेखण हैं: "RIGHT_LEFT" (डिफ़ॉल्ट), "LEFT_RIGHT", "LEFT_LEFT", और "RIGHT_RIGHT"। "RIGHT_LEFT" सुपरडायगोनल्स को दाईं ओर (बाएं-पैड पंक्ति को) और उपविकर्णों को बाईं ओर (राइट-पैड पंक्ति को) संरेखित करता है। यह वह पैकिंग प्रारूप है जिसका उपयोग LAPACK करता है। cuSPARSE "LEFT_RIGHT" का उपयोग करता है, जो विपरीत संरेखण है।

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

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

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

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

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

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

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

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