MatrixDiagV3

public final class MatrixDiagV3

Restituisce un tensore diagonale in batch con valori diagonali in batch dati.

Restituisce un tensore con il contenuto in `diagonal` come` k [0] `-th a` k [1] `-th diagonali di una matrice, con tutto il resto riempito con` padding`. `num_rows` e` num_cols` specificano la dimensione della matrice più interna dell'output. Se entrambi non sono specificati, l'op assume che la matrice più interna sia quadrata e deduce la sua dimensione da "k" e la dimensione più interna di "diagonale". Se viene specificato solo uno di essi, l'op assume che il valore non specificato sia il più piccolo possibile in base ad altri criteri.

Lascia che "diagonale" abbia dimensioni "r" "[I, J, ..., L, M, N]". Il tensore di output ha rango "r + 1" con forma "[I, J, ..., L, M, num_rows, num_cols]" quando viene fornita una sola diagonale ("k" è un numero intero o "k [0] == k [1] "). Altrimenti, ha rango "r" con forma "[I, J, ..., L, num_rows, num_cols]".

La seconda dimensione più interna di "diagonale" ha un doppio significato. Quando "k" è scalare o "k [0] == k [1]", "M" fa parte della dimensione del batch [I, J, ..., M] e il tensore di output è:

output[i, j, ..., l, m, n]
   = diagonal[i, j, ..., l, n-max(d_upper, 0)] ; if n - m == d_upper
     padding_value                             ; otherwise
 
Altrimenti, "M" è trattato come il numero di diagonali per la matrice nello stesso batch ("M = k [1] -k [0] + 1") e il tensore di output è:
output[i, j, ..., l, m, n]
   = diagonal[i, j, ..., l, diag_index, index_in_diag] ; if k[0] <= d <= k[1]
     padding_value                                     ; otherwise
 
dove "d = n - m" , `diag_index = [k] - d` e` index_in_diag = n - max (d, 0) + offset`.

"offset" è zero tranne quando l'allineamento della diagonale è a destra.

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
 }
dove "diag_len (d) = min (cols - max (d, 0), righe + min (d, 0))".

Ad esempio:

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

Classi annidate

classe MatrixDiagV3.Options Attributi opzionali per MatrixDiagV3

Metodi pubblici

statico MatrixDiagV3.Options
align (String allinea)
Uscita <T>
asOutput ()
Restituisce la maniglia simbolica di un tensore.
statico <T> MatrixDiagV3 <T>
create ( ambito ambito, operando <T> diagonale, operando <Integer> k, operando <Integer> numRows, operando <Integer> numCols, operando <T> paddingValue, opzioni ...
Metodo Factory per creare una classe che avvolge una nuova operazione MatrixDiagV3.
Uscita <T>
output ()
Ha rango "r + 1" quando "k" è un numero intero o "k [0] == k [1]", altrimenti rango "r".

Metodi ereditati

Metodi pubblici

public static MatrixDiagV3.Options align (String align)

Parametri
allineare Alcune diagonali sono più corte di "max_diag_len" e devono essere riempite. `align` è una stringa che specifica come devono essere allineate rispettivamente le superdiagonali e le sottodiagonali. Sono disponibili quattro allineamenti possibili: "RIGHT_LEFT" (predefinito), "LEFT_RIGHT", "LEFT_LEFT" e "RIGHT_RIGHT". "RIGHT_LEFT" allinea le superdiagonali a destra (a sinistra della riga) e le sottodiagonali a sinistra (a destra della riga). È il formato di imballaggio utilizzato da LAPACK. cuSPARSE utilizza "LEFT_RIGHT", che è l'allineamento opposto.

output pubblico <T> asOutput ()

Restituisce la maniglia simbolica di un tensore.

Gli input per le operazioni TensorFlow sono output di un'altra operazione TensorFlow. Questo metodo viene utilizzato per ottenere un handle simbolico che rappresenta il calcolo dell'input.

public static MatrixDiagV3 <T> create ( Scope scope, Operand <T> diagonal, Operand <Integer> k, Operand <Integer> numRows, Operand <Integer> numCols, Operand <T> paddingValue, Options ... options)

Metodo Factory per creare una classe che avvolge una nuova operazione MatrixDiagV3.

Parametri
scopo ambito attuale
diagonale Rango "r", dove "r> = 1"
K Offset diagonale. Un valore positivo significa superdiagonale, 0 si riferisce alla diagonale principale e un valore negativo significa sottodiagonale. "k" può essere un singolo numero intero (per una singola diagonale) o una coppia di numeri interi che specificano le estremità inferiore e superiore di una banda di matrice. "k [0]" non deve essere maggiore di "k [1]".
numRows Il numero di righe della matrice di output. Se non è fornito, op assume che la matrice di output sia una matrice quadrata e deduce la dimensione della matrice da k e la dimensione più interna di "diagonale".
numCols Il numero di colonne della matrice di output. Se non è fornito, l'op assume che la matrice di output sia una matrice quadrata e deduce la dimensione della matrice da k e la dimensione più interna di "diagonale".
paddingValue Il numero con cui riempire l'area al di fuori della banda diagonale specificata. L'impostazione predefinita è 0.
opzioni trasporta valori di attributi opzionali
ritorna
  • una nuova istanza di MatrixDiagV3

output pubblico <T> output ()

Ha rango "r + 1" quando "k" è un numero intero o "k [0] == k [1]", altrimenti rango "r".