Peringatan: API ini tidak digunakan lagi dan akan dihapus di versi TensorFlow mendatang setelah penggantinya stabil.

MatrixDiagV3

public class akhir MatrixDiagV3

Mengembalikan tensor diagonal batch dengan nilai diagonal batch yang diberikan.

Mengembalikan tensor dengan konten dalam `diagonal` sebagai `k[0]`-th ke `k[1]`-th diagonal matriks, dengan segala sesuatu yang lain diisi dengan `padding`. `num_rows` dan `num_cols` menentukan dimensi matriks terdalam dari output. Jika keduanya tidak ditentukan, op mengasumsikan matriks terdalam adalah persegi dan menyimpulkan ukurannya dari `k` dan dimensi terdalam dari `diagonal`. Jika hanya satu yang ditentukan, op mengasumsikan nilai yang tidak ditentukan adalah yang terkecil yang mungkin berdasarkan kriteria lainnya.

Misalkan `diagonal` memiliki dimensi `r` `[I, J, ..., L, M, N]`. Tensor keluaran memiliki rank `r+1` dengan bentuk `[I, J, ..., L, M, num_rows, num_cols]` ketika hanya satu diagonal yang diberikan (`k` adalah bilangan bulat atau `k[0] == k[1]`). Jika tidak, ia memiliki peringkat `r` dengan bentuk `[I, J, ..., L, num_rows, num_cols]`.

Dimensi terdalam kedua dari `diagonal` memiliki makna ganda. Ketika `k` adalah skalar atau` k [0] == k [1] `,` m` merupakan bagian dari ukuran bets [I, J, ..., M], dan output tensor adalah:

output[i, j, ..., l, m, n]
   = diagonal[i, j, ..., l, n-max(d_upper, 0)] ; if n - m == d_upper
     padding_value                             ; otherwise
 
Jika tidak, `m` diperlakukan sebagai jumlah diagonal untuk matriks dalam batch yang sama (` M = k [1] -k [0] + 1`), dan output tensor adalah:
output[i, j, ..., l, m, n]
   = diagonal[i, j, ..., l, diag_index, index_in_diag] ; if k[0] <= d <= k[1]
     padding_value                                     ; otherwise
 
mana `d = n - m`, `diag_index = [k] - d`, dan `index_in_diag = n - max(d, 0) + offset`.

`offset` adalah nol kecuali jika penjajaran diagonal ke kanan.

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
 }
mana `diag_len (d) = min (cols - max (d, 0), baris + min (d, 0))`.

Sebagai contoh:

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

Kelas Bersarang

kelas MatrixDiagV3.Options Atribut opsional untuk MatrixDiagV3

Metode Publik

statis MatrixDiagV3.Options
menyelaraskan (String menyelaraskan)
Output <T>
asOutput ()
Mengembalikan pegangan simbolis tensor.
statis <T> MatrixDiagV3 <T>
membuat ( Lingkup lingkup, Operan <T> diagonal, Operan <Integer> k, Operan <Integer> numRows, Operan <Integer> numCols, Operan <T> paddingValue, Options ... pilihan)
Metode pabrik untuk membuat kelas yang membungkus operasi MatrixDiagV3 baru.
Output <T>
Output ()
Memiliki peringkat `r+1` ketika `k` adalah bilangan bulat atau `k[0] == k[1]`, peringkat `r` jika tidak.

Metode yang Diwarisi

Metode Publik

public static MatrixDiagV3.Options menyelaraskan (String menyelaraskan)

Parameter
meluruskan Beberapa diagonal lebih pendek dari `max_diag_len` dan perlu diberi bantalan. `align` adalah string yang menentukan bagaimana superdiagonal dan subdiagonal harus disejajarkan, masing-masing. Ada empat kemungkinan penyelarasan: "RIGHT_LEFT" (default), "LEFT_RIGHT", "LEFT_LEFT", dan "RIGHT_RIGHT". "RIGHT_LEFT" menyejajarkan superdiagonal ke kanan (mengisi kiri baris) dan subdiagonal ke kiri (mengisi baris kanan). Ini adalah format kemasan yang digunakan LAPACK. cuSPARSE menggunakan "LEFT_RIGHT", yang merupakan kesejajaran yang berlawanan.

publik Keluaran <T> asOutput ()

Mengembalikan pegangan simbolis tensor.

Input ke operasi TensorFlow adalah output dari operasi TensorFlow lainnya. Metode ini digunakan untuk mendapatkan pegangan simbolis yang mewakili perhitungan input.

public static MatrixDiagV3 <T> membuat ( Lingkup lingkup, Operan <T> diagonal, Operan <Integer> k, Operan <Integer> numRows, Operan <Integer> numCols, Operan <T> paddingValue, Options ... pilihan)

Metode pabrik untuk membuat kelas yang membungkus operasi MatrixDiagV3 baru.

Parameter
cakupan lingkup saat ini
diagonal Peringkat `r`, di mana `r >= 1`
k Offset diagonal. Nilai positif berarti superdiagonal, 0 mengacu pada diagonal utama, dan nilai negatif berarti subdiagonal. `k` dapat berupa bilangan bulat tunggal (untuk diagonal tunggal) atau sepasang bilangan bulat yang menentukan ujung rendah dan tinggi pita matriks. `k[0]` tidak boleh lebih besar dari `k[1]`.
jumlahBaris Jumlah baris matriks keluaran. Jika tidak tersedia, op mengasumsikan matriks keluaran adalah matriks persegi dan menyimpulkan ukuran matriks dari k dan dimensi terdalam dari `diagonal`.
jumlahKol Jumlah kolom dari matriks keluaran. Jika tidak tersedia, op mengasumsikan matriks keluaran adalah matriks persegi dan menyimpulkan ukuran matriks dari k dan dimensi terdalam dari `diagonal`.
nilai padding Angka untuk mengisi area di luar pita diagonal yang ditentukan. Standarnya adalah 0.
pilihan membawa nilai atribut opsional
Kembali
  • contoh baru MatrixDiagV3

publik Keluaran <T> Output ()

Memiliki peringkat `r+1` ketika `k` adalah bilangan bulat atau `k[0] == k[1]`, peringkat `r` jika tidak.