टेन्सरफ्लो::ऑप्स::मैट्रिक्सडायगवी2

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

सारांश

यह diagonal एक टेंसर लौटाता है जिसमें मैट्रिक्स के k[0] से k[1] विकर्णों तक की सामग्री होती है, और बाकी सभी मानों में 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] )। अन्यथा, इसका रैंक r है और उसका आकार [I, J, ..., L, num_rows, num_cols] ।

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
    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

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

# 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_value = 9.
tf.matrix_diag(diagonal, k = -1, num_rows = 3, padding_value = 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 के सबसे भीतरी आयाम से मैट्रिक्स का आकार निकालता है।
• padding_value: निर्दिष्ट विकर्ण पट्टी के बाहर के क्षेत्र को भरने के लिए उपयोग की जाने वाली संख्या। डिफ़ॉल्ट मान 0 है।

प्रतिफल:

• Output : k एक पूर्णांक होने पर या k[0] == k[1] पर रैंक r+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