Restituisce un tensore diagonale raggruppato con determinati valori diagonali raggruppati.
Restituisce un tensore con il contenuto in "diagonale" come diagonali da "k[0]" a "k[1]"-esima 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'operazione presuppone che la matrice più interna sia quadrata e ne deduce la dimensione da "k" e dalla dimensione più interna di "diagonale". Se ne viene specificato solo uno, l'operazione presuppone che il valore non specificato sia il più piccolo possibile in base ad altri criteri.
Sia "diagonale" avere 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
output[i, j, ..., l, m, n]
= diagonal[i, j, ..., l, diag_index, index_in_diag] ; if k[0] <= d <= k[1]
padding_value ; otherwise
Per 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 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]]
Costanti
| Corda | OP_NAME | Il nome di questa operazione, come noto al motore principale di TensorFlow |
Metodi pubblici
| Uscita <T> | comeuscita () Restituisce l'handle simbolico del tensore. |
| statico <T estende TType > MatrixDiag <T> | |
| Uscita <T> | produzione () Ha rango `r+1` quando `k` è un numero intero o `k[0] == k[1]`, rango `r` altrimenti. |
Metodi ereditati
| booleano finale | è uguale a (Oggetto oggetto) |
| finale int | codicehash () |
| Operazione | |
| stringa finale | aStringa () |
| booleano | è uguale a (Oggetto arg0) |
| Classe finale<?> | getClass () |
| int | codicehash () |
| vuoto finale | avvisare () |
| vuoto finale | notificaTutti () |
| Corda | aStringa () |
| vuoto finale | attendere (lungo arg0, int arg1) |
| vuoto finale | aspetta (lungo arg0) |
| vuoto finale | Aspettare () |
| ambiente di esecuzione astratto | ambiente () Restituisce l'ambiente di esecuzione in cui è stata creata questa operazione. |
| Operazione astratta |
| risultato astratto <T> | comeuscita () Restituisce l'handle simbolico del tensore. |
| astratto T | come tensore () Restituisce il tensore in questo operando. |
| forma astratta | |
| Classe astratta<T> | tipo () Restituisce il tipo tensore di questo operando |
Costanti
Stringa finale statica pubblica OP_NAME
Il nome di questa operazione, come noto al motore principale di TensorFlow
Metodi pubblici
Uscita pubblica <T> asOutput ()
Restituisce l'handle simbolico del 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 MatrixDiag <T> create ( scope scope, Operando <T> diagonal, Operando < TInt32 > k, Operando < TInt32 > numRows, Operando < TInt32 > numCols, Operando <T> paddingValue)
Metodo factory per creare una classe che racchiude una nuova operazione MatrixDiag.
Parametri
| ambito | ambito attuale |
|---|---|
| diagonale | Rango `r`, dove `r >= 1` |
| k | Offset diagonale(i). Il valore positivo significa superdiagonale, 0 si riferisce alla diagonale principale e il valore negativo significa subdiagonali. "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]". |
| numRighe | Il numero di righe della matrice di output. Se non viene fornita, l'operazione presuppone che la matrice di output sia una matrice quadrata e deduce la dimensione della matrice da k e la dimensione più interna di "diagonale". |
| numCol | Il numero di colonne della matrice di output. Se non viene fornita, l'operazione presuppone che la matrice di output sia una matrice quadrata e deduce la dimensione della matrice da k e la dimensione più interna di "diagonale". |
| valoreimbottitura | Il numero con cui riempire l'area all'esterno della banda diagonale specificata. L'impostazione predefinita è 0. |
Ritorni
- una nuova istanza di MatrixDiag
Uscita pubblica <T> uscita ()
Ha rango `r+1` quando `k` è un numero intero o `k[0] == k[1]`, rango `r` altrimenti.