MatrixDiagV3

lớp cuối cùng công khai MatrixDiagV3

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] - d`, và `index_in_diag = n - max(d, 0) + offset`.

`offset` bằng 0 ngoại trừ khi căn chỉnh của đường chéo ở bên phải.

offset = max_diag_len - diag_len(d) ; if (`align` in {RIGHT_LEFT, RIGHT_RIGHT
                                            and `d >= 0`) or
                                          (`align` in {LEFT_RIGHT, RIGHT_RIGHT}
                                            and `d <= 0`)
          0                          ; otherwise
 }
trong đó `diag_len(d) = min(cols - max(d, 0), row + min(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 tridiagonal band (per batch).
 diagonals = np.array([[[0, 8, 9],  # Input shape: (2, 2, 3)
                        [1, 2, 3],
                        [4, 5, 0]],
                       [[0, 2, 3],
                        [6, 7, 9],
                        [9, 1, 0]]])
 tf.matrix_diag(diagonals, k = (-1, 1))
   ==> [[[1, 8, 0],  # Output shape: (2, 3, 3)
         [4, 2, 9],
         [0, 5, 3]],
        [[6, 2, 0],
         [9, 7, 3],
         [0, 1, 9]]]
 
 # LEFT_RIGHT alignment.
 diagonals = np.array([[[8, 9, 0],  # Input shape: (2, 2, 3)
                        [1, 2, 3],
                        [0, 4, 5]],
                       [[2, 3, 0],
                        [6, 7, 9],
                        [0, 9, 1]]])
 tf.matrix_diag(diagonals, k = (-1, 1), align="LEFT_RIGHT")
   ==> [[[1, 8, 0],  # Output shape: (2, 3, 3)
         [4, 2, 9],
         [0, 5, 3]],
        [[6, 2, 0],
         [9, 7, 3],
         [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]]
 
 

Các lớp lồng nhau

lớp học MatrixDiagV3.Options Thuộc tính tùy chọn cho MatrixDiagV3

Hằng số

Sợi dây OP_NAME Tên của op này, được biết đến bởi công cụ lõi TensorFlow

Phương pháp công cộng

MatrixDiagV3.Options tĩnh
căn chỉnh (Căn chỉnh chuỗi)
Đầu ra <T>
asOutput ()
Trả về tay cầm tượng trưng của tensor.
tĩnh <T mở rộng TType > MatrixDiagV3 <T>
tạo ( Phạm vi phạm vi, Đường chéo toán hạng <T>, Toán hạng < TInt32 > k, Toán hạng < TInt32 > numRows, Toán hạng < TInt32 > numCols, Toán hạng <T> đệmValue, Tùy chọn... tùy chọn)
Phương thức xuất xưởng để tạo một lớp bao bọc một thao tác MatrixDiagV3 mới.
Đầu ra <T>
đầu ra ()
Có thứ hạng `r+1` khi `k` là số nguyên hoặc `k[0] == k[1]`, nếu không thì xếp hạng `r`.

Phương pháp kế thừa

Hằng số

Chuỗi cuối cùng tĩnh công khai OP_NAME

Tên của op này, được biết đến bởi công cụ lõi TensorFlow

Giá trị không đổi: "MatrixDiagV3"

Phương pháp công cộng

public static MatrixDiagV3.Options căn chỉnh (Căn chỉnh chuỗi)

Thông số
căn chỉnh Một số đường chéo ngắn hơn `max_diag_len` và cần được đệm. `align` là một chuỗi chỉ định cách căn chỉnh các đường chéo siêu và đường chéo phụ tương ứng. Có bốn cách sắp xếp có thể có: "RIGHT_LEFT" (mặc định), "LEFT_RIGHT", "LEFT_LEFT" và "RIGHT_RIGHT". "RIGHT_LEFT" căn chỉnh các đường chéo siêu sang phải ( Đệm bên trái hàng) và các đường chéo phụ về bên trái ( Đệm bên phải hàng). Đây là định dạng đóng gói mà LAPACK sử dụng. cuSPARSE sử dụng "LEFT_RIGHT", đây là cách căn chỉnh ngược lại.

Đầu ra công khai <T> asOutput ()

Trả về tay cầm tượng trưng của tensor.

Đầu vào của các hoạt động TensorFlow là đầu ra của một hoạt động TensorFlow khác. Phương pháp này được sử dụng để thu được một thẻ điều khiển mang tính biểu tượng đại diện cho việc tính toán đầu vào.

public static MatrixDiagV3 <T> tạo ( Phạm vi phạm vi, Đường chéo toán hạng <T>, Toán hạng < TInt32 > k, Toán hạng < TInt32 > numRows, Toán hạng < TInt32 > numCols, Toán hạng <T> đệmValue, Tùy chọn... tùy chọn)

Phương thức gốc để tạo một lớp bao bọc một thao tác MatrixDiagV3 mới.

Thông số
phạm vi phạm vi hiện tại
đườ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à siêu đường chéo, 0 dùng để chỉ đườ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 chỉ đị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]`.
số hàng Số hàng của ma trận đầu ra. Nếu nó không được cung cấp, op 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 `đường chéo`.
sốCols Số cột của ma trận đầu ra. Nếu nó không được cung cấp, op 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 `đường chéo`.
giá trị đệm Số để lấp đầy khu vực bên ngoài dải chéo được chỉ định. Mặc định là 0.
tùy chọn mang các giá trị thuộc tính tùy chọn
Trả lại
  • một phiên bản mới của MatrixDiagV3

Đầu ra công khai đầu ra <T> ()

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