dòng chảy :: hoạt động :: MatrixDiagV2

#include <array_ops.h>

Trả về tensor đường chéo theo lô với các giá trị đường chéo theo lô đã cho.

Tóm lược

Trả về một tensor có nội dung diagonal là k[0] -th đến k[1] -th đường chéo của ma trận, với mọi thứ khác được đệm bằng khoảng padding . num_rows và num_cols xác định kích thước của ma trận trong cùng của đầu ra. Nếu cả hai đều không được chỉ định, op giả sử ma trận trong cùng là hình vuông và suy ra kích thước của nó từ k và kích thước trong cùng của diagonal . Nếu chỉ một trong số chúng được chỉ định, op giả định giá trị không xác định là giá trị nhỏ nhất có thể dựa trên các tiêu chí khác.

Cho diagonal có r kích thước [I, J, ..., L, M, N] . Tensor đầu ra có thứ hạng r+1 với hình dạng [I, J, ..., L, M, num_rows, num_cols] khi chỉ cho một đường chéo ( k là số nguyên hoặc k[0] == k[1] ) . Nếu không, nó có thứ hạng r với hình dạng [I, J, ..., L, num_rows, num_cols] .

Kích thước trong cùng thứ hai của diagonal có ý nghĩa kép. Khi k là vô hướng hoặc k[0] == k[1] , M là một phần của kích thước lô [I, J, ..., M] và tensor đầu ra là:

output[i, j, ..., l, m, n]
  = diagonal[i, j, ..., l, n-max(d_upper, 0)] ; if n - m == d_upper
    padding_value                             ; otherwise

Nếu không, M được coi là số đường chéo của ma trận trong cùng một lô ( M = k[1]-k[0]+1 ), và tensor đầu ra là:

output[i, j, ..., l, m, n]
  = diagonal[i, j, ..., l, diag_index, index_in_diag] ; if k[0] <= d <= k[1]
    padding_value                                     ; otherwise

trong đó d = n - m , diag_index = k[1] - d và index_in_diag = n - max(d, 0) .

Ví dụ:

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

Tranh luận:

• phạm vi: Một đối tượng Phạm vi
• đường chéo: Xếp hạng r , trong đó r >= 1
• k: (Các) độ lệch đường chéo. Giá trị dương có nghĩa là siêu cạnh, 0 là đường chéo chính và giá trị âm có nghĩa là hình con. k có thể là một số nguyên duy nhất (đối với một đường chéo duy nhất) hoặc một cặp số nguyên xác định các đầu cuối thấp và cao của một dải ma trận. k[0] không được lớn hơn k[1] .
• num_rows: Số hàng của ma trận đầu ra. Nếu nó không được cung cấp, op giả sử ma trận đầu ra là ma trận vuông và suy ra kích thước ma trận từ k và kích thước trong cùng của diagonal .
• num_cols: Số cột của ma trận đầu ra. Nếu nó không được cung cấp, op giả sử ma trận đầu ra là ma trận vuông và suy ra kích thước ma trận từ k và kích thước trong cùng của diagonal .
• padding_value: Số để lấp đầy vùng bên ngoài dải chéo được chỉ định. Mặc định là 0.

Lợi nhuận:

• Output : Có thứ hạng r+1 khi k là số nguyên hoặc k[0] == k[1] , xếp hạng r ngược lại.

Người xây dựng và Người phá hủy
MatrixDiagV2 (const :: tensorflow::Scope & scope, :: tensorflow::Input diagonal, :: tensorflow::Input k, :: tensorflow::Input num_rows, :: tensorflow::Input num_cols, :: tensorflow::Input padding_value)

Thuộc tính công khai
operation	Operation
output	:: tensorflow::Output

Chức năng công cộng
node () const	::tensorflow::Node *
operator::tensorflow::Input () const
operator::tensorflow::Output () const

Thuộc tính công khai

hoạt động

Operation operation

đầu ra

::tensorflow::Output output

Chức năng công cộng

MatrixDiagV2

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

nút

::tensorflow::Node * node() const 

toán tử :: tensorflow :: Đầu vào

 operator::tensorflow::Input() const 

toán tử :: tensorflow :: Đầu ra

 operator::tensorflow::Output() const