tensorflow::ops::MatrixDiagV2

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

Résumé

Renvoie un tenseur dont les éléments diagonal correspondent aux éléments de la diagonale k[0] à k[1] d'une matrice, le reste étant complété par padding . Les paramètres num_rows et num_cols spécifient la dimension de la matrice interne du résultat. Si les deux ne sont pas spécifiés, l'opération considère que la matrice interne est carrée et déduit sa taille à partir de k et de la dimension de la diagonal interne. Si un seul de ces paramètres est spécifié, l'opération considère que la valeur non spécifiée est la plus petite possible selon d'autres critères.

Soit diagonal de dimension r [I, J, ..., L, M, N] . Le tenseur de sortie est de rang r+1 et de 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 est de rang r et de forme [I, J, ..., L, num_rows, num_cols] .

La deuxième dimension la plus interne de la diagonal a une double signification. Lorsque k est un 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 de 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

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

Arguments :

• portée : un objet Scope
• diagonale : Rang r , où r >= 1
• k : Décalage(s) diagonal(s). Une valeur positive correspond à la diagonale supérieure, 0 à la diagonale principale et une valeur négative aux sous-diagonales. k peut être un entier unique (pour une seule diagonale) ou une paire d’entiers spécifiant les limites inférieure et supérieure d’une bande de la matrice. k[0] ne doit pas être supérieur à k[1] .
• num_rows : Le nombre de lignes de la matrice de sortie. Si cette valeur n’est pas fournie, l’opérateur suppose que la matrice de sortie est une matrice carrée et déduit la taille de la matrice à partir de k et de la dimension la plus interne de la diagonal .
• num_cols : Nombre de colonnes de la matrice de sortie. Si cette valeur n’est pas fournie, l’opérateur suppose que la matrice de sortie est carrée et déduit sa taille à partir de k et de la dimension la plus interne de diagonal .
• padding_value : nombre à utiliser pour remplir la zone située en dehors de la bande diagonale spécifiée. La valeur par défaut est 0.

Retours :

• Output : A le rang r+1 lorsque k est un entier ou k[0] == k[1] , rang r sinon.

attributs publics

Operation operation

::tensorflow::Output output

 MatrixDiagV2(
  const ::tensorflow::Scope & scope,
  ::tensorflow::Input diagonal,
  ::tensorflow::Input k,
  ::tensorflow::Input num_rows,
  ::tensorflow::Input num_cols,
  ::tensorflow::Input padding_value
)

::tensorflow::Node * node() const 

 operator::tensorflow::Input() const 

 operator::tensorflow::Output() const