MatrixDiag

Renvoie un tenseur diagonal par lots avec des valeurs diagonales par lots données.

Renvoie un tenseur avec le contenu en « diagonale » comme « k[0] »-ième à « k[1] »-ième diagonales d'une matrice, avec tout le reste complété par « padding ». `num_rows` et `num_cols` spécifient la dimension de la matrice la plus interne de la sortie. Si les deux ne sont pas spécifiés, l'opération suppose que la matrice la plus interne est carrée et déduit sa taille à partir de « k » et de la dimension la plus interne de « diagonale ». Si un seul d'entre eux est spécifié, l'opération suppose que la valeur non spécifiée est la plus petite possible en fonction d'autres critères.

Soit `diagonale` avoir des dimensions `r` `[I, J, ..., L, M, N]`. Le tenseur de sortie a le rang `r+1` avec la forme `[I, J, ..., L, M, num_rows, num_cols]` lorsqu'une seule diagonale est donnée (`k` est un entier ou `k[0] == k[1]`). Sinon, il a le rang `r` avec la forme `[I, J, ..., L, num_rows, num_cols]`.

La deuxième dimension la plus interne de « diagonale » a un double sens. Lorsque `k` est scalaire ou `k[0] == k[1]`, `M` fait partie de la taille du lot [I, J, ..., M] et le tenseur de sortie est :

output[i, j, ..., l, m, n]
   = diagonal[i, j, ..., l, n-max(d_upper, 0)] ; if n - m == d_upper
     padding_value                             ; otherwise
 

Sinon, `M` est traité comme le nombre de diagonales pour la matrice dans le même lot (`M = k[1]-k[0]+1`), et le tenseur de sortie est :

output[i, j, ..., l, m, n]
   = diagonal[i, j, ..., l, diag_index, index_in_diag] ; if k[0] <= d <= k[1]
     padding_value                                     ; otherwise
 

où `d = n - m`, `diag_index = k[1] - d` et `index_in_diag = n - max(d, 0)`.

Par exemple :

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