Résout des systèmes d'équations linéaires avec des matrices triangulaires supérieures ou inférieures par rétrosubstitution.
`matrix` est un tenseur de forme `[..., M, M]` dont les 2 dimensions les plus intérieures forment des matrices carrées. Si « inférieur » est « Vrai », alors la partie triangulaire strictement supérieure de chaque matrice la plus interne est supposée être nulle et non accessible. Si « inférieur » est faux, alors la partie triangulaire strictement inférieure de chaque matrice la plus interne est supposée être nulle et non accessible. `rhs` est un tenseur de forme `[..., M, N]`.
La sortie est un tenseur de forme `[..., M, N]`. Si `adjoint` est `True` alors les matrices les plus internes de `output` satisfont aux équations matricielles `matrix[..., :, :] * output[..., :, :] = rhs[..., :, :]`. Si `adjoint` est `False` alors strictement alors les matrices les plus internes de `output` satisfont les équations matricielles `adjoint(matrix[..., i, k]) * output[..., k, j] = rhs[ ..., je, j]`.
Notez que les formes de lots pour les entrées doivent uniquement être diffusées.
Exemple:
a = tf.constant([[3, 0, 0, 0],
[2, 1, 0, 0],
[1, 0, 1, 0],
[1, 1, 1, 1]], dtype=tf.float32)
b = tf.constant([[4],
[2],
[4],
[2]], dtype=tf.float32)
x = tf.linalg.triangular_solve(a, b, lower=True)
x
# <tf.Tensor: shape=(4, 1), dtype=float32, numpy=
# array([[ 1.3333334 ],
# [-0.66666675],
# [ 2.6666665 ],
# [-1.3333331 ]], dtype=float32)>
# in python3 one can use `a@x`
tf.matmul(a, x)
# <tf.Tensor: shape=(4, 1), dtype=float32, numpy=
# array([[4. ],
# [2. ],
# [4. ],
# [1.9999999]], dtype=float32)>
Classes imbriquées
| classe | TriangularSolve.Options | Attributs facultatifs pour TriangularSolve | |
Constantes
| Chaîne | OP_NAME | Le nom de cette opération, tel que connu par le moteur principal TensorFlow |
Méthodes publiques
| TriangularSolve.Options statique | adjoint (booléen adjoint) |
| Sortie <T> | comme Sortie () Renvoie le handle symbolique du tenseur. |
| statique <T étend TType > TriangularSolve <T> | créer ( Scope scope, Opérande <T> matrice, Opérande <T> rhs, Options... options) Méthode d'usine pour créer une classe encapsulant une nouvelle opération TriangularSolve. |
| TriangularSolve.Options statique | inférieur (booléen inférieur) |
| Sortie <T> | sortir () La forme est `[..., M, K]`. |
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
Méthodes publiques
public static TriangularSolve.Options adjoint (booléen adjoint)
Paramètres
| adjoint | Booléen indiquant s'il faut résoudre avec « matrice » ou son adjoint (par bloc). |
|---|
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 TriangularSolve <T> créer ( portée de portée, matrice d'opérande <T>, opérande <T> rhs, options... options)
Méthode d'usine pour créer une classe encapsulant une nouvelle opération TriangularSolve.
Paramètres
| portée | portée actuelle |
|---|---|
| matrice | La forme est `[..., M, M]`. |
| rhs | La forme est `[..., M, K]`. |
| choix | porte des valeurs d'attributs facultatifs |
Retours
- une nouvelle instance de TriangularSolve
public statique TriangularSolve.Options inférieur (booléen inférieur)
Paramètres
| inférieur | Booléen indiquant si les matrices les plus internes de « matrice » sont triangulaires inférieures ou supérieures. |
|---|