MatrixDiag

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 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` viene 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[1] - d` e `index_in_diag = n - max(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 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]]