MatrixDiagPartV3

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

बैच किए गए टेंसर का बैच विकर्ण भाग लौटाता है।

बैच किए गए `इनपुट` के `k[0]`-वें से `k[1]`-वें विकर्ण के साथ एक टेंसर लौटाता है।

मान लें कि `इनपुट` में `r` आयाम `[I, J, ..., L, M, N]` हैं। मान लीजिए `max_diag_len` निकाले जाने वाले सभी विकर्णों के बीच अधिकतम लंबाई है, `max_diag_len = min(M + min(k[1], 0), N + min(-k[0], 0))` मान लीजिए `num_diags` निकालने के लिए विकर्णों की संख्या हो, `num_diags = k[1] - k[0] + 1`.

यदि `num_diags == 1`, आउटपुट टेंसर `r - 1` रैंक का है जिसका आकार `[I, J, ..., L, max_diag_len]` और मान हैं:

diagonal[i, j, ..., l, n]
   = input[i, j, ..., l, n+y, n+x] ; if 0 <= n+y < M and 0 <= n+x < N,
     padding_value                 ; otherwise.
जहां `y = max(-k[1], 0)`, `x = max(k[1], 0)`.

अन्यथा, आउटपुट टेंसर की रैंक `r` आयाम `[I, J, ..., L, num_diags, max_diag_len]` मानों के साथ है:

diagonal[i, j, ..., l, m, n]
   = input[i, j, ..., l, n+y, n+x] ; if 0 <= n+y < M and 0 <= n+x < N,
     padding_value                 ; otherwise.
जहां `d = k[1] - m`, `y = max(-d, 0) - offset`, और `x = 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))`।

इनपुट कम से कम एक मैट्रिक्स होना चाहिए.

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

input = np.array([[[1, 2, 3, 4],  # Input shape: (2, 3, 4)
                    [5, 6, 7, 8],
                    [9, 8, 7, 6]],
                   [[5, 4, 3, 2],
                    [1, 2, 3, 4],
                    [5, 6, 7, 8]]])
 
 # A main diagonal from each batch.
 tf.matrix_diag_part(input) ==> [[1, 6, 7],  # Output shape: (2, 3)
                                 [5, 2, 7]]
 
 # A superdiagonal from each batch.
 tf.matrix_diag_part(input, k = 1)
   ==> [[2, 7, 6],  # Output shape: (2, 3)
        [4, 3, 8]]
 
 # A band from each batch.
 tf.matrix_diag_part(input, k = (-1, 2))
   ==> [[[0, 3, 8],  # Output shape: (2, 4, 3)
         [2, 7, 6],
         [1, 6, 7],
         [5, 8, 0]],
        [[0, 3, 4],
         [4, 3, 8],
         [5, 2, 7],
         [1, 6, 0]]]
 
 # LEFT_RIGHT alignment.
 tf.matrix_diag_part(input, k = (-1, 2), align="LEFT_RIGHT")
   ==> [[[3, 8, 0],  # Output shape: (2, 4, 3)
         [2, 7, 6],
         [1, 6, 7],
         [0, 5, 8]],
        [[3, 4, 0],
         [4, 3, 8],
         [5, 2, 7],
         [0, 1, 6]]]
 
 # max_diag_len can be shorter than the main diagonal.
 tf.matrix_diag_part(input, k = (-2, -1))
   ==> [[[5, 8],
         [9, 0]],
        [[1, 6],
         [5, 0]]]
 
 # padding_value = 9
 tf.matrix_diag_part(input, k = (1, 3), padding_value = 9)
   ==> [[[9, 9, 4],  # Output shape: (2, 3, 3)
         [9, 3, 8],
         [2, 7, 6]],
        [[9, 9, 2],
         [9, 3, 4],
         [4, 3, 8]]]

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

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

स्थिरांक

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

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

स्थिर मैट्रिक्सडिआगपार्टV3. विकल्प
संरेखित करें (स्ट्रिंग संरेखित करें)
आउटपुट <T>
आउटपुट के रूप में ()
टेंसर का प्रतीकात्मक हैंडल लौटाता है।
स्थिर <T, TType > MatrixDiagPartV3 <T> का विस्तार करता है
बनाएं ( स्कोप स्कोप, ऑपरेंड <T> इनपुट, ऑपरेंड < TInt32 > k, ऑपरेंड <T> पैडिंगवैल्यू, विकल्प... विकल्प)
नए MatrixDiagPartV3 ऑपरेशन को लपेटकर एक क्लास बनाने की फ़ैक्टरी विधि।
आउटपुट <T>
विकर्ण ()
निकाले गए विकर्ण.

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

स्थिरांक

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

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

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

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

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

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

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

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

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

सार्वजनिक स्थैतिक MatrixDiagPartV3 <T> बनाएं ( स्कोप स्कोप, ऑपरेंड <T> इनपुट, ऑपरेंड < TInt32 > k, ऑपरेंड <T> पैडिंगवैल्यू, विकल्प... विकल्प)

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

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

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

निकाले गए विकर्ण.