टेंसरफ़्लो:: ऑप्स:: मैट्रिक्सडायगV2

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

सारांश

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

माना diagonal r आयाम हैं [I, J, ..., L, M, N] । आउटपुट टेंसर की रैंक r+1 होती है जिसका आकार [I, J, ..., L, M, num_rows, num_cols] जब केवल एक विकर्ण दिया जाता है ( k एक पूर्णांक है या k[0] == k[1] ) . अन्यथा, इसका आकार [I, J, ..., L, num_rows, num_cols] के साथ रैंक r है।

diagonal का दूसरा अंतरतम आयाम दोहरा अर्थ रखता है। जब 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
    output[i, j, ..., l, m, n]                ; otherwise

अन्यथा, M उसी बैच में मैट्रिक्स के विकर्णों की संख्या के रूप में माना जाता है ( M = k[1]-k[0]+1 ), और आउटपुट टेंसर है:

output[i, j, ..., l, m, n]
  = diagonal[i, j, ..., l, k[1]-d, n-max(d, 0)] ; if d_lower <= d <= d_upper
    input[i, j, ..., l, m, n]                   ; otherwise

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

# 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 = 9.
tf.matrix_diag(diagonal, k = -1, num_rows = 3, padding = 9)
  ==> [[9, 9],  # Output shape: (3, 2)
       [1, 9],
       [9, 2]]

तर्क:

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

रिटर्न:

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

सार्वजनिक गुण

Operation operation

::tensorflow::Output output

 MatrixDiagV2(
  const ::tensorflow::Scope & scope,
  ::tensorflow::Input diagonal,
  ::tensorflow::Input k,
  ::tensorflow::Input num_rows,
  ::tensorflow::Input num_cols,
  ::tensorflow::Input padding_value
)

::tensorflow::Node * node() const 

 operator::tensorflow::Input() const 

 operator::tensorflow::Output() const