tensorflow::ops::MatrixDiagV2

Trả về một tensor đường chéo được nhóm lại với các giá trị đường chéo được nhóm lại đã cho.

Bản tóm tắt

Trả về một tensor với nội dung trong diagonal là các đường chéo thứ k[0] đến k[1] của ma trận, với mọi thứ khác được đệm bằng padding . num_rows và num_cols chỉ định kích thước của ma trận trong cùng của đầu ra. Nếu cả hai không được chỉ định, op giả định ma trận trong cùng là ma trận 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 hai được chỉ định, op giả định giá trị không được chỉ định là giá trị nhỏ nhất có thể dựa trên các tiêu chí khác.

Giả sử diagonal có r chiều [I, J, ..., L, M, N] . Tensor đầu ra có hạng r+1 với hình dạng [I, J, ..., L, M, num_rows, num_cols] khi chỉ có một đường chéo được cung cấp ( k là một số nguyên hoặc k[0] == k[1] ). Ngược lại, nó có hạng r với hình dạng [I, J, ..., L, num_rows, num_cols] .

Chiều trong cùng thứ hai của diagonal có ý nghĩa kép. Khi k là một số 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

Ngược lại, M được coi là số lượng đườ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

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

Luận điểm:

• phạm vi: Một đối tượng Phạm vi
• đường chéo: Hạng r , trong đó r >= 1
• k: Độ lệch đường chéo. Giá trị dương biểu thị đường chéo trên, 0 biểu thị đường chéo chính, và giá trị âm biểu thị các đường chéo dưới. k có thể là một số nguyên đơn (cho một đường chéo) hoặc một cặp số nguyên chỉ định các đầu 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 không được cung cấp, toán tử sẽ giả định ma trận đầu ra là ma trận vuông và suy ra kích thước ma trận từ k và chiều trong cùng của diagonal .
• num_cols: Số cột của ma trận đầu ra. Nếu không được cung cấp, toán tử sẽ giả định ma trận đầu ra là ma trận vuông và suy ra kích thước ma trận từ k và chiều trong cùng của diagonal .
• padding_value: Số dùng để lấp đầy vùng bên ngoài dải chéo được chỉ định. Mặc định là 0.

Trả về:

• Output : Có hạng r+1 khi k là số nguyên hoặc k[0] == k[1] , hạng r trong các trường hợp khác.

Thuộc tính công khai

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