dòng chảy căng:: ôi:: Ma TrậnDiagV2

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

Bản tóm tắt

Trả về một tenxơ có nội dung theo 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 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ả 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 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 diagonal có r kích thước [I, J, ..., L, M, N] . Tenxơ đầu ra có 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ó 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à 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à tenxơ đầ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à tenxơ đầ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]]

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) khoảng lệch chéo. Giá trị dương có nghĩa là đường chéo lớn, 0 là đường chéo chính và giá trị âm có nghĩa là đường chéo phụ. k có thể là một số nguyên đơn (đối với một đường chéo) hoặc một cặp số nguyên xác định đầu dưới và đầu cao của 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à chiều 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à chiều trong cùng của diagonal .
• đệm_value: Số để lấp đầy khu vực bên ngoài dải chéo được chỉ định. Mặc định là 0.

Trả về:

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

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