सहायता Kaggle पर TensorFlow साथ ग्रेट बैरियर रीफ की रक्षा चैलेंज में शामिल हों

टेंसरफ़्लो :: ऑप्स :: MatrixDiagV2

#include <array_ops.h>

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

सारांश

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

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
    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
जहाँ d = n - m

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

# 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: आउटपुट मैट्रिक्स की पंक्तियों की संख्या। यदि यह प्रदान नहीं किया जाता है, तो op मानता है कि आउटपुट मैट्रिक्स एक वर्गाकार मैट्रिक्स है और k से मैट्रिक्स का आकार और diagonal के अंतरतम आयाम को diagonal
  • num_cols: आउटपुट मैट्रिक्स के कॉलम की संख्या। यदि यह प्रदान नहीं किया जाता है, तो op मानता है कि आउटपुट मैट्रिक्स एक वर्गाकार मैट्रिक्स है और k से मैट्रिक्स का आकार और diagonal के अंतरतम आयाम को diagonal
  • padding_value: निर्दिष्ट विकर्ण बैंड के बाहर के क्षेत्र को भरने के लिए संख्या। डिफ़ॉल्ट 0 है।

रिटर्न:

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

कंस्ट्रक्टर और डिस्ट्रक्टर्स

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

सार्वजनिक विशेषताएँ

operation
output

सार्वजनिक कार्य

node () const
::tensorflow::Node *
operator::tensorflow::Input () const
operator::tensorflow::Output () const

सार्वजनिक विशेषताएँ

ऑपरेशन

Operation operation

उत्पादन

::tensorflow::Output output

सार्वजनिक कार्य

MatrixDiagV2

 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