MatrixDiagV2

kelas akhir publik MatrixDiagV2

Mengembalikan tensor diagonal kumpulan dengan nilai diagonal kumpulan tertentu.

Mengembalikan tensor dengan konten dalam `diagonal` sebagai diagonal ke-`k[0]` hingga `k[1]`-diagonal matriks, dengan semua yang lain diisi dengan `padding`. `num_rows` dan `num_cols` menentukan dimensi matriks keluaran yang paling dalam. Jika keduanya tidak ditentukan, operasi mengasumsikan matriks terdalam berbentuk persegi dan menyimpulkan ukurannya dari `k` dan dimensi terdalam dari `diagonal`. Jika hanya salah satu saja yang ditentukan, operasi mengasumsikan nilai yang tidak ditentukan adalah yang terkecil berdasarkan kriteria lainnya.

Misalkan `diagonal` mempunyai dimensi `r` `[I, J, ..., L, M, N]`. Tensor keluaran memiliki peringkat `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. Jika `k` adalah skalar atau `k[0] == k[1]`, `M` adalah bagian dari ukuran batch [I, J, ..., M], dan tensor keluarannya 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` dianggap sebagai jumlah diagonal matriks dalam kumpulan yang sama (`M = k[1]-k[0]+1`), dan tensor keluarannya 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
dengan `d = n - m`, `diag_index = k[1] - d`, dan `index_in_diag = n - max(d, 0)`.

Misalnya: 

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

Metode Publik

Keluaran <T>
sebagai Keluaran ()
Mengembalikan pegangan simbolik tensor.
statis <T> MatrixDiagV2 <T>
buat ( Lingkup lingkup, Operand <T> diagonal, Operand <Integer> k, Operand <Integer> numRows, Operand <Integer> numCols, Operand <T> paddingValue)
Metode pabrik untuk membuat kelas yang membungkus operasi MatrixDiagV2 baru.
Keluaran <T>
keluaran ()
Memiliki peringkat `r+1` ketika `k` adalah bilangan bulat atau `k[0] == k[1]`, peringkat `r` sebaliknya.

Metode Warisan

Metode Publik

Keluaran publik <T> sebagai Keluaran ()

Mengembalikan pegangan simbolik tensor.

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

public static MatrixDiagV2 <T> buat ( Ruang lingkup, Operan <T> diagonal, Operan <Integer> k, Operan <Integer> numRows, Operan <Integer> numCols, Operan <T> paddingValue)

Metode pabrik untuk membuat kelas yang membungkus operasi MatrixDiagV2 baru.

Parameter
cakupan ruang 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 satu diagonal) atau sepasang bilangan bulat yang menentukan ujung rendah dan tinggi dari pita matriks. `k[0]` tidak boleh lebih besar dari `k[1]`.
nomor baris Jumlah baris matriks keluaran. Jika tidak tersedia, operasi mengasumsikan matriks keluaran adalah matriks persegi dan menyimpulkan ukuran matriks dari k dan dimensi terdalam dari `diagonal`.
nomorKolom Jumlah kolom matriks keluaran. Jika tidak tersedia, operasi mengasumsikan matriks keluaran adalah matriks persegi dan menyimpulkan ukuran matriks dari k dan dimensi terdalam dari `diagonal`.
paddingValue Nomor untuk mengisi area di luar pita diagonal yang ditentukan. Standarnya adalah 0.
Kembali
  • contoh baru dari MatrixDiagV2

Keluaran publik <T> keluaran ()

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