MatrixDiagV3

classe finale publique MatrixDiagV3

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] - d` et `index_in_diag = n - max(d, 0) + offset`.

`offset` est nul sauf lorsque l'alignement de la diagonale est vers la droite.

offset = max_diag_len - diag_len(d) ; if (`align` in {RIGHT_LEFT, RIGHT_RIGHT
                                            and `d >= 0`) or
                                          (`align` in {LEFT_RIGHT, RIGHT_RIGHT}
                                            and `d <= 0`)
          0                          ; otherwise
 }
 où `diag_len(d) = min(cols - max(d, 0), rows + min(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 tridiagonal band (per batch).
 diagonals = np.array([[[0, 8, 9],  # Input shape: (2, 2, 3)
                        [1, 2, 3],
                        [4, 5, 0]],
                       [[0, 2, 3],
                        [6, 7, 9],
                        [9, 1, 0]]])
 tf.matrix_diag(diagonals, k = (-1, 1))
   ==> [[[1, 8, 0],  # Output shape: (2, 3, 3)
         [4, 2, 9],
         [0, 5, 3]],
        [[6, 2, 0],
         [9, 7, 3],
         [0, 1, 9]]]
 
 # LEFT_RIGHT alignment.
 diagonals = np.array([[[8, 9, 0],  # Input shape: (2, 2, 3)
                        [1, 2, 3],
                        [0, 4, 5]],
                       [[2, 3, 0],
                        [6, 7, 9],
                        [0, 9, 1]]])
 tf.matrix_diag(diagonals, k = (-1, 1), align="LEFT_RIGHT")
   ==> [[[1, 8, 0],  # Output shape: (2, 3, 3)
         [4, 2, 9],
         [0, 5, 3]],
        [[6, 2, 0],
         [9, 7, 3],
         [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]]

Classes imbriquées

classe MatrixDiagV3.Options Attributs facultatifs pour MatrixDiagV3

Constantes

Chaîne OP_NAME Le nom de cette opération, tel que connu par le moteur principal TensorFlow

Méthodes publiques

statique MatrixDiagV3.Options
aligner (alignement de chaîne)
Sortie <T>
comme Sortie ()
Renvoie le handle symbolique du tenseur.
statique <T étend TType > MatrixDiagV3 <T>
créer ( Portée de portée, Opérande <T> diagonale, Opérande < TInt32 > k, Opérande < TInt32 > numRows, Opérande < TInt32 > numCols, Opérande <T> paddingValue, Options... options)
Méthode d'usine pour créer une classe encapsulant une nouvelle opération MatrixDiagV3.
Sortie <T>
sortir ()
A le rang « r+1 » lorsque « k » est un entier ou « k[0] == k[1] », rang « r » sinon.

Méthodes héritées

Constantes

chaîne finale statique publique OP_NAME

Le nom de cette opération, tel que connu par le moteur principal TensorFlow

Valeur constante : "MatrixDiagV3"

Méthodes publiques

public static MatrixDiagV3.Options aligner (alignement de chaînes)

Paramètres
aligner Certaines diagonales sont plus courtes que `max_diag_len` et doivent être complétées. `align` est une chaîne spécifiant comment les superdiagonales et les sous-diagonales doivent être alignées, respectivement. Il existe quatre alignements possibles : "RIGHT_LEFT" (par défaut), "LEFT_RIGHT", "LEFT_LEFT" et "RIGHT_RIGHT". "RIGHT_LEFT" aligne les superdiagonales vers la droite (remplit la ligne à gauche) et les sous-diagonales vers la gauche (remplit la ligne à droite). C'est le format d'emballage utilisé par LAPACK. cuSPARSE utilise "LEFT_RIGHT", qui est l'alignement opposé.

sortie publique <T> asOutput ()

Renvoie le handle symbolique du tenseur.

Les entrées des opérations TensorFlow sont les sorties d'une autre opération TensorFlow. Cette méthode est utilisée pour obtenir un handle symbolique qui représente le calcul de l’entrée.

public static MatrixDiagV3 <T> créer ( Portée de portée, Opérande <T> diagonale, Opérande < TInt32 > k, Opérande < TInt32 > numRows, Opérande < TInt32 > numCols, Opérande <T> paddingValue, Options... options)

Méthode d'usine pour créer une classe encapsulant une nouvelle opération MatrixDiagV3.

Paramètres
portée portée actuelle
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]`.
nombre de lignes 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 intérieure de « diagonale ».
numCols 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 intérieure de « diagonale ».
valeur de remplissage Le nombre avec lequel remplir la zone en dehors de la bande diagonale spécifiée. La valeur par défaut est 0.
choix porte des valeurs d'attributs facultatifs
Retours
  • une nouvelle instance de MatrixDiagV3

sortie publique <T> sortie ()

A le rang « r+1 » lorsque « k » est un entier ou « k[0] == k[1] », rang « r » sinon.