Ma TrậnDiagV2

Trả về một tenxơ chéo theo bó với các giá trị đường chéo đã cho theo bó.

Trả về một tenxơ có nội dung trong `đường chéo` là đường chéo thứ `k[0]`-th đến `k[1]`-th của ma trận, với mọi thứ khác được đệm bằng `padding`. `num_rows` và `num_cols` chỉ định thứ nguyên 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à hình vuông và suy ra kích thước của nó từ `k` và chiều trong cùng của `đường chéo`. Nếu chỉ một trong số chúng được chỉ định, op sẽ 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 `đường chéo` có kích thước `r` `[I, J, ..., L, M, N]`. Tenxor đầ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]`). Ngược lại, nó có thứ hạng `r` với hình dạng `[I, J, ..., L, num_rows, num_cols]`.

Chiều thứ hai trong cùng của `đường chéo` 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
 

Mặt khác, `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]]