flux tensoriel : : opérations : : MatriceDiagV2

#include <array_ops.h>

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

Résumé

Renvoie un tenseur avec le contenu en diagonal comme k[0] -th à k[1] -th 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 de k et de la dimension la plus interne de diagonal . 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 diagonal avoir r dimensions [I, J, ..., L, M, N] . Le tenseur de sortie a le rang r+1 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 a le rang r avec la forme [I, J, ..., L, num_rows, num_cols] .

La deuxième dimension la plus intérieure de la diagonal a une double signification. 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
    output[i, j, ..., l, m, n]                ; 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, k[1]-d, n-max(d, 0)] ; if d_lower <= d <= d_upper
    input[i, j, ..., l, m, n]                   ; otherwise
 où d = n - m

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 = 9.
tf.matrix_diag(diagonal, k = -1, num_rows = 3, padding = 9)
  ==> [[9, 9],  # Output shape: (3, 2)
       [1, 9],
       [9, 2]]

Arguments :

  • scope : un objet Scope
  • diagonale : Rang r , où r >= 1
  • k : Décalage(s) diagonal(s). Une valeur positive signifie une superdiagonale, 0 fait référence à la diagonale principale et une valeur négative signifie des sous-diagonales. k peut être un seul entier (pour une seule diagonale) ou une paire d'entiers spécifiant les extrémités inférieure et supérieure d'une bande matricielle. k[0] ne doit pas être supérieur à k[1] .
  • num_rows : Le nombre de lignes de la matrice de sortie. Si cela n'est pas fourni, l'opération 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 diagonal .
  • num_cols : Le nombre de colonnes de la matrice de sortie. Si cela n'est pas fourni, l'opération 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 diagonal .
  • padding_value : le nombre avec lequel remplir la zone 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] , le rang r sinon.

Constructeurs et Destructeurs

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

Attributs publics

operation
output

Fonctions publiques

node () const
::tensorflow::Node *
operator::tensorflow::Input () const
operator::tensorflow::Output () const

Attributs publics

opération 

Operation operation

sortir 

::tensorflow::Output output

Fonctions publiques

MatriceDiagV2 

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

nœud 

::tensorflow::Node * node() const

opérateur :: tensorflow :: Entrée 

 operator::tensorflow::Input() const

opérateur :: tensorflow :: Sortie 

 operator::tensorflow::Output() const