MatrixSetDiagV3

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

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

`इनपुट` और `विकर्ण` को देखते हुए, यह ऑपरेशन अंतरतम मैट्रिक्स के निर्दिष्ट विकर्णों को छोड़कर, `इनपुट` के समान आकार और मान के साथ एक टेंसर लौटाता है। इन्हें 'विकर्ण' में मानों द्वारा अधिलेखित कर दिया जाएगा।

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

आउटपुट `k+1` रैंक का एक टेंसर है जिसका आयाम `[I, J, ..., L, M, N]` है। यदि `k` अदिश राशि है या `k[0] == k[1]`:

output[i, j, ..., l, m, n]
   = diagonal[i, j, ..., l, n-max(k[1], 0)] ; if n - m == k[1]
     input[i, j, ..., l, m, n]              ; otherwise
 
अन्यथा,
output[i, j, ..., l, m, n]
   = diagonal[i, j, ..., l, diag_index, index_in_diag] ; if k[0] <= d <= k[1]
     input[i, j, ..., l, m, n]                         ; otherwise
 
जहां `d = n - m`, `diag_index = k[1] - 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.
 input = np.array([[[7, 7, 7, 7],              # Input shape: (2, 3, 4)
                    [7, 7, 7, 7],
                    [7, 7, 7, 7]],
                   [[7, 7, 7, 7],
                    [7, 7, 7, 7],
                    [7, 7, 7, 7]]])
 diagonal = np.array([[1, 2, 3],               # Diagonal shape: (2, 3)
                      [4, 5, 6]])
 tf.matrix_set_diag(input, diagonal)
   ==> [[[1, 7, 7, 7],  # Output shape: (2, 3, 4)
         [7, 2, 7, 7],
         [7, 7, 3, 7]],
        [[4, 7, 7, 7],
         [7, 5, 7, 7],
         [7, 7, 6, 7]]]
 
 # A superdiagonal (per batch).
 tf.matrix_set_diag(input, diagonal, k = 1)
   ==> [[[7, 1, 7, 7],  # Output shape: (2, 3, 4)
         [7, 7, 2, 7],
         [7, 7, 7, 3]],
        [[7, 4, 7, 7],
         [7, 7, 5, 7],
         [7, 7, 7, 6]]]
 
 # A band of diagonals.
 diagonals = np.array([[[0, 9, 1],  # Diagonal shape: (2, 4, 3)
                        [6, 5, 8],
                        [1, 2, 3],
                        [4, 5, 0]],
                       [[0, 1, 2],
                        [5, 6, 4],
                        [6, 1, 2],
                        [3, 4, 0]]])
 tf.matrix_set_diag(input, diagonals, k = (-1, 2))
   ==> [[[1, 6, 9, 7],  # Output shape: (2, 3, 4)
         [4, 2, 5, 1],
         [7, 5, 3, 8]],
        [[6, 5, 1, 7],
         [3, 1, 6, 2],
         [7, 4, 2, 4]]]
 
 # LEFT_RIGHT alignment.
 diagonals = np.array([[[9, 1, 0],  # Diagonal shape: (2, 4, 3)
                        [6, 5, 8],
                        [1, 2, 3],
                        [0, 4, 5]],
                       [[1, 2, 0],
                        [5, 6, 4],
                        [6, 1, 2],
                        [0, 3, 4]]])
 tf.matrix_set_diag(input, diagonals, k = (-1, 2), align="LEFT_RIGHT")
   ==> [[[1, 6, 9, 7],  # Output shape: (2, 3, 4)
         [4, 2, 5, 1],
         [7, 5, 3, 8]],
        [[6, 5, 1, 7],
         [3, 1, 6, 2],
         [7, 4, 2, 4]]]
 
 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

रैंक `r+1`, `आउटपुट.शेप = इनपुट.शेप` के साथ।