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

MatrixDiagV3

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

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

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

माना `विकर्ण` का `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` अदिश है या` कश्मीर [0] == कश्मीर [1] `,` m` बैच का आकार [आई, जे, ..., एम] का हिस्सा है, और उत्पादन टेन्सर है:

output[i, j, ..., l, m, n]
   = diagonal[i, j, ..., l, n-max(d_upper, 0)] ; if n - m == d_upper
     padding_value                             ; otherwise
 
( `एम = कश्मीर [1] -k [0] + 1`) अन्यथा,` m` एक ही बैच में मैट्रिक्स के लिए विकर्ण की संख्या के रूप में व्यवहार किया जाता है, और उत्पादन टेन्सर है:
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 = 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 (घ) = मिनट (कॉलम - अधिकतम (घ, 0), पंक्तियों + मिनट (घ, 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]]
 
 

नेस्टेड कक्षाएं

कक्षा MatrixDiagV3.Options के लिए वैकल्पिक विशेषताओं MatrixDiagV3

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

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

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

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

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

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

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

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

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

सार्वजनिक स्थिर MatrixDiagV3 <टी> बनाने ( स्कोप गुंजाइश, ओपेरैंड <टी> विकर्ण, ओपेरैंड <पूर्णांक> कश्मीर, ओपेरैंड <पूर्णांक> numrows, ओपेरैंड <पूर्णांक> numCols, ओपेरैंड <टी> paddingValue, विकल्प ... विकल्प)

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

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

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

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