Les fonctions suivantes sont disponibles dans le monde entier.
Renvoie la perte L1 entre les prédictions et les attentes.
Déclaration
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func l1Loss<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
Paramètres
predicted
Sorties prévues d'un réseau de neurones.
expected
Les valeurs attendues, c'est-à-dire les cibles, qui correspondent à la sortie correcte.
Renvoie la perte L2 entre les prédictions et les attentes.
Déclaration
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func l2Loss<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
Paramètres
predicted
Sorties prévues d'un réseau de neurones.
expected
Les valeurs attendues, c'est-à-dire les cibles, qui correspondent à la sortie correcte.
Renvoie la perte de charnière entre les prédictions et les attentes.
Déclaration
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func hingeLoss<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
Paramètres
predicted
Sorties prévues d'un réseau de neurones.
expected
Les valeurs attendues, c'est-à-dire les cibles, qui correspondent à la sortie correcte.
Renvoie la perte de charnière au carré entre les prédictions et les attentes.
Déclaration
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func squaredHingeLoss<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
Paramètres
predicted
Sorties prévues d'un réseau de neurones.
expected
Les valeurs attendues, c'est-à-dire les cibles, qui correspondent à la sortie correcte.
Renvoie la perte de charnière catégorique entre les prédictions et les attentes.
Déclaration
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func categoricalHingeLoss<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
Paramètres
predicted
Sorties prévues d'un réseau de neurones.
expected
Les valeurs attendues, c'est-à-dire les cibles, qui correspondent à la sortie correcte.
Renvoie le logarithme du cosinus hyperbolique de l'erreur entre les prédictions et les attentes.
Déclaration
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func logCoshLoss<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
Paramètres
predicted
Sorties prévues d'un réseau de neurones.
expected
Les valeurs attendues, c'est-à-dire les cibles, qui correspondent à la sortie correcte.
Renvoie la perte de Poisson entre les prédictions et les attentes.
Déclaration
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func poissonLoss<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
Paramètres
predicted
Sorties prévues d'un réseau de neurones.
expected
Les valeurs attendues, c'est-à-dire les cibles, qui correspondent à la sortie correcte.
Renvoie la divergence de Kullback-Leibler (divergence KL) entre les attentes et les prédictions. Compte tenu de deux distributions
p
etq
, la divergence KL calculep * log(p / q)
.Déclaration
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func kullbackLeiblerDivergence<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
Paramètres
predicted
Sorties prévues d'un réseau de neurones.
expected
Les valeurs attendues, c'est-à-dire les cibles, qui correspondent à la sortie correcte.
Renvoie l'entropie croisée softmax (entropie croisée catégorique) entre les logits et les étiquettes.
Déclaration
@differentiable(wrt: logits) public func softmaxCrossEntropy<Scalar: TensorFlowFloatingPoint>( logits: Tensor<Scalar>, probabilities: Tensor<Scalar> ) -> Tensor<Scalar>
Paramètres
logits
Sorties codées à chaud d'un réseau de neurones.
labels
Indices (indexés à zéro) des sorties correctes.
Renvoie l'entropie croisée sigmoïde (entropie croisée binaire) entre les logits et les étiquettes.
Déclaration
@differentiable(wrt: logits) @differentiable(wrt: (logits, labels) public func sigmoidCrossEntropy<Scalar: TensorFlowFloatingPoint>( logits: Tensor<Scalar>, labels: Tensor<Scalar> ) -> Tensor<Scalar>
Paramètres
logits
La sortie non mise à l'échelle d'un réseau de neurones.
labels
Valeurs entières qui correspondent à la sortie correcte.
Renvoie un tenseur avec la même forme et les mêmes scalaires que le tenseur spécifié.
Déclaration
@differentiable public func identity<Scalar>(_ x: Tensor<Scalar>) -> Tensor<Scalar> where Scalar : TensorFlowScalar
Appelle la fermeture donnée dans un contexte qui a tout identique au contexte actuel à l'exception de la phase d'apprentissage donnée.
Déclaration
public func withContext<R>(_ context: Context, _ body: () throws -> R) rethrows -> R
Paramètres
context
Un contexte qui sera défini avant que la fermeture ne soit appelée et restaurée après le retour de la fermeture.
body
Une fermeture nulle. Si la fermeture a une valeur de retour, cette valeur est également utilisée comme valeur de retour de la
withContext(_:_:)
fonction.Valeur de retour
La valeur de retour, le cas échéant, de l'
body
de fermeture.Appelle la fermeture donnée dans un contexte qui a tout identique au contexte actuel à l'exception de la phase d'apprentissage donnée.
Déclaration
public func withLearningPhase<R>( _ learningPhase: LearningPhase, _ body: () throws -> R ) rethrows -> R
Paramètres
learningPhase
Une phase d'apprentissage qui sera définie avant que la fermeture ne soit appelée et restaurée après le retour de la fermeture.
body
Une fermeture nulle. Si la fermeture a une valeur de retour, cette valeur est également utilisée comme valeur de retour de la
withLearningPhase(_:_:)
fonction.Valeur de retour
La valeur de retour, le cas échéant, de l'
body
de fermeture.Appelle la fermeture donnée dans un contexte qui a tout identique au contexte actuel à l'exception de la graine aléatoire donnée.
Déclaration
public func withRandomSeedForTensorFlow<R>( _ randomSeed: TensorFlowSeed, _ body: () throws -> R ) rethrows -> R
Paramètres
randomSeed
Une graine aléatoire qui sera définie avant que la fermeture ne soit appelée et restaurée après le retour de la fermeture.
body
Une fermeture nulle. Si la fermeture a une valeur de retour, cette valeur est également utilisée comme valeur de retour de la
withRandomSeedForTensorFlow(_:_:)
fonction.Valeur de retour
La valeur de retour, le cas échéant, de l'
body
de fermeture.Appelle la fermeture donnée dans un contexte qui a tout identique au contexte actuel, à l'exception du générateur de nombres aléatoires donné.
Déclaration
public func withRandomNumberGeneratorForTensorFlow<G: RandomNumberGenerator, R>( _ randomNumberGenerator: inout G, _ body: () throws -> R ) rethrows -> R
Paramètres
randomNumberGenerator
Un générateur de nombres aléatoires qui sera défini avant l'appel de la fermeture et restauré après le retour de la fermeture.
body
Une fermeture nulle. Si la fermeture a une valeur de retour, cette valeur est également utilisée comme valeur de retour de la
withRandomNumberGeneratorForTensorFlow(_:_:)
fonction.Valeur de retour
La valeur de retour, le cas échéant, de l'
body
de fermeture.Déclaration
public func zip<T: TensorGroup, U: TensorGroup>( _ dataset1: Dataset<T>, _ dataset2: Dataset<U> ) -> Dataset<Zip2TensorGroup<T, U>>
LazyTensorBarrier garantit que tous les tenseurs en direct (sur l'appareil si fourni) sont planifiés et en cours d'exécution. Si wait est défini sur true, cet appel se bloque jusqu'à ce que le calcul soit terminé.
Déclaration
public func valueWithGradient<T, R>( at x: T, in f: @differentiable (T) -> Tensor<R> ) -> (value: Tensor<R>, gradient: T.TangentVector) where T: Differentiable, R: TensorFlowFloatingPoint
Déclaration
public func valueWithGradient<T, U, R>( at x: T, _ y: U, in f: @differentiable (T, U) -> Tensor<R> ) -> (value: Tensor<R>, gradient: (T.TangentVector, U.TangentVector)) where T: Differentiable, U: Differentiable, R: TensorFlowFloatingPoint
Déclaration
public func valueWithGradient<T, U, V, R>( at x: T, _ y: U, _ z: V, in f: @differentiable (T, U, V) -> Tensor<R> ) -> (value: Tensor<R>, gradient: (T.TangentVector, U.TangentVector, V.TangentVector)) where T: Differentiable, U: Differentiable, V: Differentiable, R: TensorFlowFloatingPoint
Déclaration
public func valueWithGradient<T, R>( of f: @escaping @differentiable (T) -> Tensor<R> ) -> (T) -> (value: Tensor<R>, gradient: T.TangentVector) where T: Differentiable, R: TensorFlowFloatingPoint
Déclaration
public func valueWithGradient<T, U, R>( of f: @escaping @differentiable (T, U) -> Tensor<R> ) -> (T, U) -> (value: Tensor<R>, gradient: (T.TangentVector, U.TangentVector)) where T: Differentiable, U: Differentiable, R: TensorFlowFloatingPoint
Déclaration
public func valueWithGradient<T, U, V, R>( of f: @escaping @differentiable (T, U, V) -> Tensor<R> ) -> (T, U, V) -> ( value: Tensor<R>, gradient: (T.TangentVector, U.TangentVector, V.TangentVector) ) where T: Differentiable, U: Differentiable, V: Differentiable, R: TensorFlowFloatingPoint
Déclaration
public func gradient<T, R>( at x: T, in f: @differentiable (T) -> Tensor<R> ) -> T.TangentVector where T: Differentiable, R: TensorFlowFloatingPoint
Déclaration
public func gradient<T, U, R>( at x: T, _ y: U, in f: @differentiable (T, U) -> Tensor<R> ) -> (T.TangentVector, U.TangentVector) where T: Differentiable, U: Differentiable, R: TensorFlowFloatingPoint
Déclaration
public func gradient<T, U, V, R>( at x: T, _ y: U, _ z: V, in f: @differentiable (T, U, V) -> Tensor<R> ) -> (T.TangentVector, U.TangentVector, V.TangentVector) where T: Differentiable, U: Differentiable, V: Differentiable, R: TensorFlowFloatingPoint
Déclaration
public func gradient<T, R>( of f: @escaping @differentiable (T) -> Tensor<R> ) -> (T) -> T.TangentVector where T: Differentiable, R: TensorFlowFloatingPoint
Déclaration
public func gradient<T, U, R>( of f: @escaping @differentiable (T, U) -> Tensor<R> ) -> (T, U) -> (T.TangentVector, U.TangentVector) where T: Differentiable, U: Differentiable, R: TensorFlowFloatingPoint
Déclaration
public func gradient<T, U, V, R>( of f: @escaping @differentiable (T, U, V) -> Tensor<R> ) -> (T, U, V) -> (T.TangentVector, U.TangentVector, V.TangentVector) where T: Differentiable, U: Differentiable, V: Differentiable, R: TensorFlowFloatingPoint
Faire recalculer une fonction dans son pullback, appelé « checkpointing » dans la différenciation automatique traditionnelle.
Déclaration
public func withRecomputationInPullbacks<T, U>( _ body: @escaping @differentiable (T) -> U ) -> @differentiable (T) -> U where T : Differentiable, U : Differentiable
Créez une fonction différentiable à partir d'une fonction vecteur-produits jacobiens.
Déclaration
public func differentiableFunction<T : Differentiable, R : Differentiable>( from vjp: @escaping (T) -> (value: R, pullback: (R.TangentVector) -> T.TangentVector) ) -> @differentiable (T) -> R
Créez une fonction différentiable à partir d'une fonction vecteur-produits jacobiens.
Déclaration
public func differentiableFunction<T, U, R>( from vjp: @escaping (T, U) -> (value: R, pullback: (R.TangentVector) -> (T.TangentVector, U.TangentVector)) ) -> @differentiable (T, U) -> R
Retours
x
comme une fonction d'identité. Lorsqu'il est utilisé dans un contexte oùx
est en cours différenciée par rapport à, cette fonction ne produira aucun dérivé àx
.Déclaration
@_semantics("autodiff.nonvarying") public func withoutDerivative<T>(at x: T) -> T
Applique la fermeture donné
body
àx
. Lorsqu'il est utilisé dans un contexte oùx
est en cours différenciée par rapport à, cette fonction ne produira aucun dérivé àx
.Déclaration
@_semantics("autodiff.nonvarying") public func withoutDerivative<T, R>(at x: T, in body: (T) -> R) -> R
Exécute une fermeture, ce qui permet aux opérations TensorFlow de s'exécuter sur un type d'appareil spécifique.
Déclaration
public func withDevice<R>( _ kind: DeviceKind, _ index: UInt = 0, perform body: () throws -> R ) rethrows -> R
Paramètres
kind
Une sorte d'appareil sur lequel exécuter les opérations TensorFlow.
index
L'appareil sur lequel exécuter les opérations.
body
Fermeture dont les opérations TensorFlow doivent être exécutées sur le type d'appareil spécifié.
Exécute une fermeture, ce qui permet aux opérations TensorFlow de s'exécuter sur un appareil portant un nom spécifique.
Quelques exemples de noms d'appareils :
- "/device:CPU:0": Le CPU de votre machine.
- "/GPU:0" : notation abrégée pour le premier GPU de votre machine visible par TensorFlow
- "/job:localhost/replica:0/task:0/device:GPU:1" : nom complet du deuxième GPU de votre machine visible par TensorFlow.
Déclaration
public func withDevice<R>(named name: String, perform body: () throws -> R) rethrows -> R
Paramètres
name
Nom de l'appareil.
body
Fermeture dont les opérations TensorFlow doivent être exécutées sur le type d'appareil spécifié.
Exécute une fermeture, permettant à TensorFlow de placer des opérations TensorFlow sur n'importe quel appareil. Cela devrait restaurer le comportement de placement par défaut.
Déclaration
public func withDefaultDevice<R>(perform body: () throws -> R) rethrows -> R
Paramètres
body
Fermeture dont les opérations TensorFlow doivent être exécutées sur le type d'appareil spécifié.
Redimensionnez les images à la taille en utilisant la méthode spécifiée.
Condition préalable
Les images doivent avoir le rang3
ou4
.Condition préalable
La taille doit être positive.Déclaration
@differentiable(wrt: images) public func resize( images: Tensor<Float>, size: (newHeight: Int, newWidth: Int), method: ResizeMethod = .bilinear, antialias: Bool = false ) -> Tensor<Float>
Paramètres
images
4-D
Tensor
de forme[batch, height, width, channels]
laTensor
[height, width, channels]
[batch, height, width, channels]
la[batch, height, width, channels]
les[batch, height, width, channels]
ou 3-DTensor
de forme[height, width, channels]
la[height, width, channels]
des[height, width, channels]
.size
La nouvelle taille des images.
method
La méthode de redimensionnement. La valeur par défaut est
.bilinear
.antialias
Iff
true
, utiliser un filtre anti-repliement pour sous - échantillonner une image.Redimensionnez les images à la taille en utilisant l'interpolation de zone.
Condition préalable
Les images doivent avoir le rang3
ou4
.Condition préalable
La taille doit être positive.Déclaration
public func resizeArea<Scalar: TensorFlowNumeric>( images: Tensor<Scalar>, size: (newHeight: Int, newWidth: Int), alignCorners: Bool = false ) -> Tensor<Float>
Paramètres
images
4-D
Tensor
de forme[batch, height, width, channels]
laTensor
[height, width, channels]
[batch, height, width, channels]
la[batch, height, width, channels]
les[batch, height, width, channels]
ou 3-DTensor
de forme[height, width, channels]
la[height, width, channels]
des[height, width, channels]
.size
La nouvelle taille des images.
Renvoie une dilatation 2D avec l'entrée, le filtre, les foulées et le remplissage spécifiés.
Condition préalable
input
doit avoir le rang4
.Condition préalable
filter
doit avoir le rang3
.Déclaration
@differentiable(wrt: (input, filter) public func dilation2D<Scalar: TensorFlowFloatingPoint>( _ input: Tensor<Scalar>, filter: Tensor<Scalar>, strides: (Int, Int, Int, Int) = (1, 1, 1, 1), rates: (Int, Int, Int, Int) = (1, 1, 1, 1), padding: Padding = .valid ) -> Tensor<Scalar>
Paramètres
input
L'entrée.
filter
Le filtre de dilatation.
strides
Les foulées du filtre coulissant pour chaque dimension de l'entrée.
padding
Le rembourrage pour l'opération
rates
Les taux de dilatation pour chaque dimension de l'entrée.
Renvoie une érosion 2D avec l'entrée, le filtre, les foulées et le remplissage spécifiés.
Condition préalable
input
doit avoir le rang4
.Condition préalable
filter
doit avoir le rang 3.Déclaration
@differentiable(wrt: (input, filter) public func erosion2D<Scalar: TensorFlowFloatingPoint>( _ input: Tensor<Scalar>, filter: Tensor<Scalar>, strides: (Int, Int, Int, Int) = (1, 1, 1, 1), rates: (Int, Int, Int, Int) = (1, 1, 1, 1), padding: Padding = .valid ) -> Tensor<Scalar>
Paramètres
input
L'entrée.
filter
Le filtre d'érosion.
strides
Les foulées du filtre coulissant pour chaque dimension de l'entrée.
padding
Le rembourrage pour l'opération
rates
Les taux de dilatation pour chaque dimension de l'entrée.
Renvoie une fonction qui crée un tenseur en initialisant toutes ses valeurs à zéros.
Déclaration
public func zeros<Scalar>() -> ParameterInitializer<Scalar> where Scalar : TensorFlowFloatingPoint
Renvoie une fonction qui crée un tenseur en initialisant toutes ses valeurs à la valeur fournie.
Déclaration
public func constantInitializer<Scalar: TensorFlowFloatingPoint>( value: Scalar ) -> ParameterInitializer<Scalar>
Renvoie une fonction qui crée un tenseur en l'initialisant à la valeur fournie. Notez que la diffusion de la valeur fournie est pas pris en charge.
Déclaration
public func constantInitializer<Scalar: TensorFlowFloatingPoint>( value: Tensor<Scalar> ) -> ParameterInitializer<Scalar>
Renvoie une fonction qui crée un tenseur en effectuant Glorot (Xavier) initialisation uniforme de la forme spécifiée, échantillonnant de manière aléatoire des valeurs scalaires à partir d' une distribution uniforme entre
-limit
etlimit
, généré par le générateur par défaut du nombre aléatoire, où la limite estsqrt(6 / (fanIn + fanOut))
, etfanIn
/fanOut
représentent le nombre d'entrée et de sortie caractéristiques multipliés par le champ récepteur, si elle est présente.Déclaration
public func glorotUniform<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
Renvoie une fonction qui crée un tenseur en effectuant Glorot (Xavier) initialisation normale pour la forme spécifiée, échantillonnant de manière aléatoire des valeurs scalaires à partir d' une distribution normale tronquée centrée sur
0
avec un écart typesqrt(2 / (fanIn + fanOut))
, oùfanIn
/fanOut
représentent le nombre d'entités en entrée et en sortie multiplié par la taille du champ récepteur, le cas échéant.Déclaration
public func glorotNormal<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
Renvoie une fonction qui crée un tenseur en effectuant He (Kaiming) d'initialisation uniforme de la forme spécifiée, échantillonnant de manière aléatoire des valeurs scalaires à partir d' une distribution uniforme entre
-limit
etlimit
, généré par le générateur par défaut du nombre aléatoire, où la limite estsqrt(6 / fanIn)
, etfanIn
représente le nombre de fonctions d'entrée multiplié par le champ récepteur, si elle est présente.Déclaration
public func heUniform<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
Renvoie une fonction qui crée un tenseur en effectuant He (Kaiming) initialisation normale de la forme spécifiée, échantillonnant de manière aléatoire des valeurs scalaires à partir d' une distribution normale tronquée centrée sur
0
avec un écart typesqrt(2 / fanIn)
, oùfanIn
représente le nombre de fonctions d'entrée multiplié par la taille du champ récepteur, le cas échéant.Déclaration
public func heNormal<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
Renvoie une fonction qui crée un tenseur en effectuant l' initialisation LeCun uniforme de la forme spécifiée, échantillonnant de manière aléatoire des valeurs scalaires à partir d' une distribution uniforme entre
-limit
etlimit
, généré par le générateur de nombres aléatoires par défaut, où la limite estsqrt(3 / fanIn)
, etfanIn
représente le nombre de fonctions d'entrée multiplié par le champ récepteur, si elle est présente.Déclaration
public func leCunUniform<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
Renvoie une fonction qui crée un tenseur en effectuant LeCun initialisation normale pour la forme spécifiée, échantillonnant de manière aléatoire des valeurs scalaires à partir d' une distribution normale tronquée centrée sur
0
avec un écart typesqrt(1 / fanIn)
, oùfanIn
représente le nombre d'entités en entrée multipliée par le la taille du champ récepteur, si présent.Déclaration
public func leCunNormal<Scalar: TensorFlowFloatingPoint>( seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
Renvoie une fonction qui crée un tenseur en initialisant toutes ses valeurs de manière aléatoire à partir d'une distribution normale tronquée. Les valeurs générées suivent une loi normale de moyenne
mean
écart - type etstandardDeviation
, sauf que les valeurs dont l' amplitude est plus de deux écarts types de la moyenne sont supprimés et rééchantillonnées.Déclaration
public func truncatedNormalInitializer<Scalar: TensorFlowFloatingPoint>( mean: Tensor<Scalar> = Tensor<Scalar>(0), standardDeviation: Tensor<Scalar> = Tensor<Scalar>(1), seed: TensorFlowSeed = Context.local.randomSeed ) -> ParameterInitializer<Scalar>
Paramètres
mean
Moyenne de la distribution normale.
standardDeviation
Écart type de la distribution normale.
Valeur de retour
Une fonction d'initialisation de paramètre normale tronquée.
Déclaration
public func == (lhs: TFETensorHandle, rhs: TFETensorHandle) -> Bool
Renvoie une matrice d'identité ou un lot de matrices.
Déclaration
Paramètres
rowCount
Le nombre de lignes dans chaque matrice de lot.
columnCount
Le nombre de colonnes dans chaque matrice de lot.
batchShape
Dimensions du premier lot du tenseur renvoyé.
Calcule la trace d'une matrice éventuellement groupée. La trace est la somme le long de la diagonale principale de chaque matrice la plus interne.
L'entrée est un tenseur de forme
[..., M, N]
. La sortie est un tenseur avec la forme[...]
.Condition préalable
matrix
doit être un tenseur de forme[..., M, N]
.Déclaration
@differentiable(wrt: matrix) public func trace<T>(_ matrix: Tensor<T>) -> Tensor<T> where T : Numeric, T : TensorFlowScalar
Paramètres
matrix
Un tenseur de forme
[..., M, N]
.Renvoie la décomposition de Cholesky d'une ou plusieurs matrices carrées.
L'entrée est un tenseur de forme
[..., M, M]
, dont les dimensions 2 plus interne forment des matrices carrées.L'entrée doit être symétrique et définie positive. Seule la partie triangulaire inférieure de l'entrée sera utilisée pour cette opération. La partie triangulaire supérieure ne sera pas lue.
Le signal de sortie est un tenseur de la même forme que l'entrée contenant les décompositions de Cholesky pour toutes les sous - matrices d'entrée
[..., :, :]
.Déclaration
@differentiable public func cholesky<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Paramètres
input
Un tenseur de forme
[..., M, M]
.Les retours la solution
x
du système d'équations linéaires représentés parAx = b
.Condition préalable
matrix
doit être un tenseur avec la forme[..., M, M]
.Condition préalable
rhs
doit être un tenseur avec la forme[..., M, K]
.Déclaration
@differentiable public func triangularSolve<T: TensorFlowFloatingPoint>( matrix: Tensor<T>, rhs: Tensor<T>, lower: Bool = true, adjoint: Bool = false ) -> Tensor<T>
Paramètres
matrix
La matrice d' entrée coefficient triangulaire, représentant
A
àAx = b
.rhs
Les valeurs de droite, soit
b
dansAx = b
.lower
Si la
matrix
est triangulaire inférieure (true
) ou triangulaire supérieure (false
). La valeur par défaut esttrue
.adjoint
Si
true
, résoudre avec l'adjoint de lamatrix
au lieu de lamatrix
. La valeur par défaut estfalse
.Valeur de retour
La solution
x
au système d'équations linéaires représentés parAx = b
.x
a la même forme queb
.Calcule la perte L1 entre
expected
etpredicted
.loss = reduction(abs(expected - predicted))
Déclaration
Paramètres
predicted
Sorties prévues d'un réseau de neurones.
expected
Les valeurs attendues, c'est-à-dire les cibles, qui correspondent à la sortie correcte.
reduction
Réduction à appliquer sur les valeurs de perte par élément calculées.
Calcule la perte L2 entre
expected
etpredicted
.loss = reduction(square(expected - predicted))
Déclaration
Paramètres
predicted
Sorties prévues d'un réseau de neurones.
expected
Les valeurs attendues, c'est-à-dire les cibles, qui correspondent à la sortie correcte.
reduction
Réduction à appliquer sur les valeurs de perte par élément calculées.
Calcule la moyenne de la différence absolue entre les étiquettes et les prédictions.
loss = mean(abs(expected - predicted))
Déclaration
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func meanAbsoluteError<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
Paramètres
predicted
Sorties prévues d'un réseau de neurones.
expected
Les valeurs attendues, c'est-à-dire les cibles, qui correspondent à la sortie correcte.
Calcule la moyenne des carrés des erreurs entre les étiquettes et les prédictions.
loss = mean(square(expected - predicted))
Déclaration
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func meanSquaredError<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
Paramètres
predicted
Sorties prévues d'un réseau de neurones.
expected
Les valeurs attendues, c'est-à-dire les cibles, qui correspondent à la sortie correcte.
Calcule l'erreur quadratique moyenne logarithmique entre
predicted
etexpected
loss = square(log(expected) - log(predicted))
Noter
Les entrées de tenseur négatives seront bridées
0
pour éviter un comportement logarithmique non défini, commelog(_:)
est non défini pour les nombres réels négatifs.Déclaration
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func meanSquaredLogarithmicError<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
Paramètres
predicted
Sorties prévues d'un réseau de neurones.
expected
Les valeurs attendues, c'est-à-dire les cibles, qui correspondent à la sortie correcte.
Calcule l'erreur moyenne de pourcentage absolu entre
predicted
etexpected
.loss = 100 * mean(abs((expected - predicted) / abs(expected)))
Déclaration
@differentiable(wrt: predicted) @differentiable(wrt: (predicted, expected) public func meanAbsolutePercentageError<Scalar: TensorFlowFloatingPoint>( predicted: Tensor<Scalar>, expected: Tensor<Scalar> ) -> Tensor<Scalar>
Paramètres
predicted
Sorties prévues d'un réseau de neurones.
expected
Les valeurs attendues, c'est-à-dire les cibles, qui correspondent à la sortie correcte.
Calcule la perte de charnière entre
predicted
etexpected
.loss = reduction(max(0, 1 - predicted * expected))
deloss = reduction(max(0, 1 - predicted * expected))
expected
valeurs devraient être -1 ou 1.Déclaration
Paramètres
predicted
Sorties prévues d'un réseau de neurones.
expected
Les valeurs attendues, c'est-à-dire les cibles, qui correspondent à la sortie correcte.
reduction
Réduction à appliquer sur les valeurs de perte par élément calculées.
Calcule la perte de charnière au carré entre
predicted
etexpected
.loss = reduction(square(max(0, 1 - predicted * expected)))
deloss = reduction(square(max(0, 1 - predicted * expected)))
expected
valeurs devraient être -1 ou 1.Déclaration
Paramètres
predicted
Sorties prévues d'un réseau de neurones.
expected
Les valeurs attendues, c'est-à-dire les cibles, qui correspondent à la sortie correcte.
reduction
Réduction à appliquer sur les valeurs de perte par élément calculées.
Calcule la perte de charnière catégorique entre
predicted
etexpected
.loss = maximum(negative - positive + 1, 0)
oùnegative = max((1 - expected) * predicted)
etpositive = sum(predicted * expected)
Déclaration
Paramètres
predicted
Sorties prévues d'un réseau de neurones.
expected
Les valeurs attendues, c'est-à-dire les cibles, qui correspondent à la sortie correcte.
reduction
Réduction à appliquer sur les valeurs de perte par élément calculées.
Calcule le logarithme du cosinus hyperbolique de l'erreur de prédiction.
logcosh = log((exp(x) + exp(-x))/2)
, où x est l'erreurpredicted - expected
Déclaration
Paramètres
predicted
Sorties prévues d'un réseau de neurones.
expected
Les valeurs attendues, c'est-à-dire les cibles, qui correspondent à la sortie correcte.
reduction
Réduction à appliquer sur les valeurs de perte par élément calculées.
Calcule la perte de Poisson entre prévu et attendu La perte de Poisson est la moyenne des éléments du
Tensor
predicted - expected * log(predicted)
.Déclaration
Paramètres
predicted
Sorties prévues d'un réseau de neurones.
expected
Les valeurs attendues, c'est-à-dire les cibles, qui correspondent à la sortie correcte.
reduction
Réduction à appliquer sur les valeurs de perte par élément calculées.
Computes Kullback-Leibler entre la perte
expected
etpredicted
.loss = reduction(expected * log(expected / predicted))
Déclaration
Paramètres
predicted
Sorties prévues d'un réseau de neurones.
expected
Les valeurs attendues, c'est-à-dire les cibles, qui correspondent à la sortie correcte.
reduction
Réduction à appliquer sur les valeurs de perte par élément calculées.
Calcule l'entropie croisée softmax éparse (entropie croisée catégorique) entre les logits et les étiquettes. Utilisez cette fonction de perte d'entropie croisée lorsqu'il existe au moins deux classes d'étiquettes. Nous nous attendons à ce que les étiquettes soient fournies sous forme d'entiers. Il devrait y avoir
# classes
des valeurs à virgule flottante par fonction pourlogits
et une seule valeur à virgule flottante par fonction pourexpected
.Déclaration
Paramètres
logits
Sorties codées à chaud d'un réseau de neurones.
labels
Indices (indexés à zéro) des sorties correctes.
reduction
Réduction à appliquer sur les valeurs de perte par élément calculées.
Calcule l'entropie croisée softmax éparse (entropie croisée catégorique) entre les logits et les étiquettes. Utilisez cette fonction de perte d'entropie croisée lorsqu'il existe au moins deux classes d'étiquettes. Nous nous attendons à des étiquettes à fournir fournies dans une
one_hot
représentation. Il devrait y avoir# classes
des# classes
valeurs en virgule flottante par fonction.Déclaration
Paramètres
logits
Probabilités de journal non mises à l'échelle à partir d'un réseau de neurones.
probabilities
Valeurs de probabilité qui correspondent à la sortie correcte. Chaque ligne doit être une distribution de probabilité valide.
reduction
Réduction à appliquer sur les valeurs de perte par élément calculées.
Calcule l'entropie croisée sigmoïde (entropie croisée binaire) entre les logits et les étiquettes. Utilisez cette perte d'entropie croisée lorsqu'il n'y a que deux classes d'étiquettes (supposées être 0 et 1). Pour chaque exemple, il doit y avoir une seule valeur à virgule flottante par prédiction.
Déclaration
Paramètres
logits
La sortie non mise à l'échelle d'un réseau de neurones.
labels
Valeurs entières qui correspondent à la sortie correcte.
reduction
Réduction à appliquer sur les valeurs de perte par élément calculées.
Calcule la perte Huber entre
predicted
etexpected
.Pour chaque valeur
x
dans l'error = expected - predicted
:Déclaration
Paramètres
predicted
Sorties prévues d'un réseau de neurones.
expected
Les valeurs attendues, c'est-à-dire les cibles, qui correspondent à la sortie correcte.
delta
Un scalaire à virgule flottante représentant le point où la fonction de perte de Huber passe de quadratique à linéaire.
reduction
Réduction à appliquer sur les valeurs de perte par élément calculées.
Renvoie la valeur absolue du tenseur spécifié par élément.
Déclaration
@differentiable public func abs<T>(_ x: Tensor<T>) -> Tensor<T> where T : SignedNumeric, T : TensorFlowScalar
Renvoie le logarithme népérien du tenseur spécifié par élément.
Déclaration
@differentiable public func log<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Renvoie le logarithme en base deux du tenseur spécifié par élément.
Déclaration
@differentiable public func log2<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Renvoie le logarithme en base dix du tenseur spécifié par élément.
Déclaration
@differentiable public func log10<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Renvoie le logarithme de
1 + x
-élément par élément.Déclaration
@differentiable public func log1p<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retours
log(1 - exp(x))
en utilisant une approche stable numériquement.Noter
L'approche est illustrée dans l' équation 7: https://cran.r-project.org/web/packages/Rmpfr/vignettes/log1mexp-note.pdf .Déclaration
@differentiable public func log1mexp<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Renvoie le sinus du tenseur spécifié par élément.
Déclaration
@differentiable public func sin<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Renvoie le cosinus du tenseur spécifié par élément.
Déclaration
@differentiable public func cos<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Renvoie la tangente du tenseur spécifié par élément.
Déclaration
@differentiable public func tan<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Renvoie le sinus hyperbolique du tenseur spécifié par élément.
Déclaration
@differentiable public func sinh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Renvoie le cosinus hyperbolique du tenseur spécifié par élément.
Déclaration
@differentiable public func cosh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Renvoie la tangente hyperbolique du tenseur spécifié par élément.
Déclaration
@differentiable public func tanh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Renvoie le cosinus inverse du tenseur spécifié par élément.
Déclaration
@differentiable public func acos<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Renvoie le sinus inverse du tenseur spécifié élément par élément.
Déclaration
@differentiable public func asin<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Renvoie la tangente inverse du tenseur spécifié par élément.
Déclaration
@differentiable public func atan<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Renvoie le cosinus hyperbolique inverse du tenseur spécifié par élément.
Déclaration
@differentiable public func acosh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Renvoie le sinus hyperbolique inverse du tenseur spécifié par élément.
Déclaration
@differentiable public func asinh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Renvoie la tangente hyperbolique inverse du tenseur spécifié par élément.
Déclaration
@differentiable public func atanh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Renvoie la racine carrée du tenseur spécifié par élément.
Déclaration
@differentiable public func sqrt<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Renvoie la racine carrée inverse du tenseur spécifié par élément.
Déclaration
@differentiable public func rsqrt<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Renvoie l'exponentielle du tenseur spécifié élément par élément.
Déclaration
@differentiable public func exp<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Renvoie deux élevés à la puissance du tenseur spécifié par élément.
Déclaration
@differentiable public func exp2<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Renvoie dix élevé à la puissance du tenseur spécifié par élément.
Déclaration
@differentiable public func exp10<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Renvoie l'exponentielle de
x - 1
élément par élément.Déclaration
@differentiable public func expm1<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Renvoie les valeurs du tenseur spécifié arrondies à l'entier le plus proche, élément par élément.
Déclaration
@differentiable public func round<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Renvoie le plafond du tenseur spécifié par élément.
Déclaration
@differentiable public func ceil<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Renvoie le plancher du tenseur spécifié par élément.
Déclaration
@differentiable public func floor<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Renvoie une indication du signe du tenseur spécifié par élément. Plus précisément, calcule
y = sign(x) = -1
six < 0
; 0 six == 0
; 1 six > 0
.Déclaration
@differentiable public func sign<T>(_ x: Tensor<T>) -> Tensor<T> where T : Numeric, T : TensorFlowScalar
Renvoie le sigmoïde du tenseur spécifié par élément. Plus précisément, calcule
1 / (1 + exp(-x))
.Déclaration
@differentiable public func sigmoid<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Renvoie le log-sigmoïde du tenseur spécifié par élément. Plus précisément,
log(1 / (1 + exp(-x)))
. Pour la stabilité numérique, nous utilisons-softplus(-x)
.Déclaration
@differentiable public func logSigmoid<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Renvoie le softplus du tenseur spécifié par élément. Plus précisément, calcule
log(exp(features) + 1)
.Déclaration
@differentiable public func softplus<T>(_ features: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Renvoie le softsign du tenseur spécifié par élément. Plus précisément, calcule les
features/ (abs(features) + 1)
.Déclaration
@differentiable public func softsign<T>(_ features: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Renvoie la softmax du tenseur spécifié le long du dernier axe. Plus précisément, calcule
exp(x) / exp(x).sum(alongAxes: -1)
.Déclaration
@differentiable public func softmax<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Renvoie la softmax du tenseur spécifié le long de l'axe spécifié. Plus précisément, calcule
exp(x) / exp(x).sum(alongAxes: axis)
.Déclaration
@differentiable public func softmax<T>(_ x: Tensor<T>, alongAxis axis: Int) -> Tensor<T> where T : TensorFlowFloatingPoint
Renvoie le log-softmax du tenseur spécifié par élément.
Déclaration
@differentiable public func logSoftmax<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Renvoie un tenseur en appliquant une unité linéaire exponentielle. Plus précisément, calcule
exp(x) - 1
si <0,x
autrement. Voir réseau profond rapide et précis d' apprentissage par Exponentielle unités linéaires (ULA)Déclaration
@differentiable public func elu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Renvoie les activations de l'unité linéaire d'erreur gaussienne (GELU) du tenseur spécifié par élément.
Plus précisément,
gelu
se rapprochexP(X <= x)
, oùP(X <= x)
est la distribution cumulative gaussienne standard, en calculant: x * [0,5 * (1 + tanh [√ (2 / π) * (x + 0,044715 * x^3)])].Déclaration
@differentiable public func gelu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Renvoie un tenseur en appliquant la fonction d'activation ReLU au tenseur spécifié par élément. Plus précisément, calcule
max(0, x)
.Déclaration
@differentiable public func relu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retours un tenseur en appliquant la fonction d'activation de ReLU6, à savoir
min(max(0, x), 6)
.Déclaration
@differentiable public func relu6<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Renvoie un tenseur en appliquant la fonction d'activation de fuite ReLU au tenseur spécifié par élément. Plus précisément, calcule
max(x, x * alpha)
.Déclaration
@differentiable(wrt: x) public func leakyRelu<T: TensorFlowFloatingPoint>( _ x: Tensor<T>, alpha: Double = 0.2 ) -> Tensor<T>
Retours un tenseur en appliquant la fonction d'activation selu, à savoir
scale * alpha * (exp(x) - 1)
six < 0
, etscale * x
autrement.Noter
Ceci est conçu pour être utilisé avec les initialiseurs de couche de mise à l'échelle de la variance. S'il vous plaît se référer à Neural Networks auto-normalisant pour plus d' informations.Déclaration
@differentiable public func selu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Renvoie un tenseur en appliquant la fonction d'activation Swish, à savoir
x * sigmoid(x)
.Source: (. Ramachandran et al 2017) « Recherche de fonctions d' activation » https://arxiv.org/abs/1710.05941
Déclaration
@differentiable public func swish<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retours un tenseur en appliquant la fonction d'activation sigmoïde dur, à savoir
Relu6(x+3)/6
.Source: « Recherche d'MobileNetV3 » (. Howard et al 2019) https://arxiv.org/abs/1905.02244
Déclaration
@differentiable public func hardSigmoid<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Retours un tenseur en appliquant la fonction d'activation dure bruissement, à savoir
x * Relu6(x+3)/6
.Source: « Recherche d'MobileNetV3 » (. Howard et al 2019) https://arxiv.org/abs/1905.02244
Déclaration
@differentiable public func hardSwish<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Renvoie un tenseur en appliquant la fonction d'activation mish, à savoir
x * tanh(softplus(x))
.Source: « Mish: A Self régularisées non monotones Activation Neural Fonction » https://arxiv.org/abs/1908.08681
Déclaration
@differentiable public func mish<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Renvoie la puissance du premier tenseur au deuxième tenseur.
Déclaration
@differentiable public func pow<T>(_ lhs: Tensor<T>, _ rhs: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Renvoie la puissance du scalaire au tenseur, diffusant le scalaire.
Déclaration
@differentiable(wrt: rhs) public func pow<T>(_ lhs: T, _ rhs: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
Renvoie la puissance du tenseur au scalaire, diffusant le scalaire.
Déclaration
@differentiable(wrt: lhs) public func pow<T>(_ lhs: Tensor<T>, _ rhs: T) -> Tensor<T> where T : TensorFlowFloatingPoint
Renvoie la puissance du tenseur au scalaire, diffusant le scalaire.
Déclaration
@differentiable public func pow<T>(_ x: Tensor<T>, _ n: Int) -> Tensor<T> where T : TensorFlowFloatingPoint
Renvoie l'élément par élément
n
ième racine du tenseur.Déclaration
@differentiable public func root<T>(_ x: Tensor<T>, _ n: Int) -> Tensor<T> where T : TensorFlowFloatingPoint
Renvoie la différence au carré entre
x
ety
.Déclaration
@differentiable public func squaredDifference<T>(_ x: Tensor<T>, _ y: Tensor<T>) -> Tensor<T> where T : Numeric, T : TensorFlowScalar
Valeur de retour
(x - y) ^ 2
.Renvoie le maximum par élément de deux tenseurs.
Noter
max
diffusion de supports.Déclaration
@differentiable public func max<T>(_ lhs: Tensor<T>, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
Renvoie le maximum par élément du scalaire et du tenseur, diffusant le scalaire.
Déclaration
@differentiable(wrt: rhs) public func max<T>(_ lhs: T, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
Renvoie le maximum par élément du scalaire et du tenseur, diffusant le scalaire.
Déclaration
@differentiable(wrt: lhs) public func max<T>(_ lhs: Tensor<T>, _ rhs: T) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
Renvoie le minimum par élément de deux tenseurs.
Noter
min
supports de radiodiffusion.Déclaration
@differentiable public func min<T>(_ lhs: Tensor<T>, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
Renvoie le minimum élément par élément du scalaire et du tenseur, diffusant le scalaire.
Déclaration
@differentiable(wrt: rhs) public func min<T>(_ lhs: T, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
Renvoie le minimum élément par élément du scalaire et du tenseur, diffusant le scalaire.
Déclaration
@differentiable(wrt: lhs) public func min<T>(_ lhs: Tensor<T>, _ rhs: T) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
Renvoie la similarité cosinus entre
x
ety
.Déclaration
@differentiable public func cosineSimilarity<Scalar: TensorFlowFloatingPoint>( _ x: Tensor<Scalar>, _ y: Tensor<Scalar> ) -> Tensor<Scalar>
Renvoie la distance cosinus entre
x
ety
. Distance de cosinus est défini comme1 - cosineSimilarity(x, y)
.Déclaration
@differentiable public func cosineDistance<Scalar: TensorFlowFloatingPoint>( _ x: Tensor<Scalar>, _ y: Tensor<Scalar> ) -> Tensor<Scalar>
Renvoie une convolution 1D avec l'entrée, le filtre, la foulée et le remplissage spécifiés.
Condition préalable
input
doit avoir le rang3
.Condition préalable
filter
doit avoir le rang 3.Déclaration
@differentiable(wrt: (input, filter) public func conv1D<Scalar: TensorFlowFloatingPoint>( _ input: Tensor<Scalar>, filter: Tensor<Scalar>, stride: Int = 1, padding: Padding = .valid, dilation: Int = 1 ) -> Tensor<Scalar>
Paramètres
input
L'entrée.
filter
Le filtre à convolution.
stride
La foulée du filtre coulissant.
padding
Le rembourrage pour l'opération.
dilation
Le facteur de dilatation.
Renvoie une convolution 2D avec l'entrée, le filtre, les foulées et le remplissage spécifiés.
Condition préalable
input
doit avoir le rang4
.Condition préalable
filter
doit avoir le rang 4.Déclaration
@differentiable(wrt: (input, filter) public func conv2D<Scalar: TensorFlowFloatingPoint>( _ input: Tensor<Scalar>, filter: Tensor<Scalar>, strides: (Int, Int, Int, Int) = (1, 1, 1, 1), padding: Padding = .valid, dilations: (Int, Int, Int, Int) = (1, 1, 1, 1) ) -> Tensor<Scalar>
Paramètres
input
L'entrée.
filter
Le filtre à convolution.
strides
Les foulées du filtre coulissant pour chaque dimension de l'entrée.
padding
Le rembourrage pour l'opération
dilations
Le facteur de dilatation pour chaque dimension de l'entrée.
Renvoie une convolution transposée 2D avec l'entrée, le filtre, les foulées et le remplissage spécifiés.
Condition préalable
input
doit avoir le rang4
.Condition préalable
filter
doit avoir le rang 4.Déclaration
@differentiable(wrt: (input, filter) public func transposedConv2D<Scalar: TensorFlowFloatingPoint>( _ input: Tensor<Scalar>, shape: [Int64], filter: Tensor<Scalar>, strides: (Int, Int, Int, Int) = (1, 1, 1, 1), padding: Padding = .valid, dilations: (Int, Int, Int, Int) = (1, 1, 1, 1) ) -> Tensor<Scalar>
Paramètres
input
L'entrée.
shape
La forme de sortie de l'opération de déconvolution.
filter
Le filtre à convolution.
strides
Les foulées du filtre coulissant pour chaque dimension de l'entrée.
padding
Le rembourrage pour l'opération
dilations
Le facteur de dilatation pour chaque dimension de l'entrée.
Renvoie une convolution 3D avec l'entrée, le filtre, les foulées, le remplissage et les dilatations spécifiés.
Condition préalable
input
doit avoir le rang5
.Condition préalable
filter
doit avoir le rang 5.Déclaration
@differentiable(wrt: (input, filter) public func conv3D<Scalar: TensorFlowFloatingPoint>( _ input: Tensor<Scalar>, filter: Tensor<Scalar>, strides: (Int, Int, Int, Int, Int) = (1, 1, 1, 1, 1), padding: Padding = .valid, dilations: (Int, Int, Int, Int, Int) = (1, 1, 1, 1, 1) ) -> Tensor<Scalar>
Paramètres
input
L'entrée.
filter
Le filtre à convolution.
strides
Les foulées du filtre coulissant pour chaque dimension de l'entrée.
padding
Le rembourrage pour l'opération.
dilations
Le facteur de dilatation pour chaque dimension de l'entrée.
Renvoie une convolution en profondeur 2D avec l'entrée, le filtre, les foulées et le remplissage spécifiés.
Condition préalable
input
doit avoir le rang 4.Condition préalable
filter
doit avoir le rang 4.Déclaration
@differentiable(wrt: (input, filter) public func depthwiseConv2D<Scalar: TensorFlowFloatingPoint>( _ input: Tensor<Scalar>, filter: Tensor<Scalar>, strides: (Int, Int, Int, Int), padding: Padding ) -> Tensor<Scalar>
Paramètres
input
L'entrée.
filter
Le filtre à convolution en profondeur.
strides
Les foulées du filtre coulissant pour chaque dimension de l'entrée.
padding
Le rembourrage pour l'opération.
Renvoie un regroupement maximal 2D, avec les tailles de filtre, les foulées et le remplissage spécifiés.
Déclaration
@differentiable(wrt: input) public func maxPool2D<Scalar: TensorFlowFloatingPoint>( _ input: Tensor<Scalar>, filterSize: (Int, Int, Int, Int), strides: (Int, Int, Int, Int), padding: Padding ) -> Tensor<Scalar>
Paramètres
input
L'entrée.
filterSize
Les dimensions du noyau de mise en commun.
strides
Les foulées du filtre coulissant pour chaque dimension de l'entrée.
padding
Le rembourrage pour l'opération.
Renvoie un regroupement maximal en 3D, avec les tailles de filtre, les foulées et le remplissage spécifiés.
Déclaration
@differentiable(wrt: input) public func maxPool3D<Scalar: TensorFlowFloatingPoint>( _ input: Tensor<Scalar>, filterSize: (Int, Int, Int, Int, Int), strides: (Int, Int, Int, Int, Int), padding: Padding ) -> Tensor<Scalar>
Paramètres
input
L'entrée.
filterSize
Les dimensions du noyau de mise en commun.
strides
Les foulées du filtre coulissant pour chaque dimension de l'entrée.
padding
Le rembourrage pour l'opération.
Renvoie un pool moyen 2D, avec les tailles de filtre, les foulées et le remplissage spécifiés.
Déclaration
@differentiable(wrt: input) public func avgPool2D<Scalar: TensorFlowFloatingPoint>( _ input: Tensor<Scalar>, filterSize: (Int, Int, Int, Int), strides: (Int, Int, Int, Int), padding: Padding ) -> Tensor<Scalar>
Paramètres
input
L'entrée.
filterSize
Les dimensions du noyau de mise en commun.
strides
Les foulées du filtre coulissant pour chaque dimension de l'entrée.
padding
Le rembourrage pour l'opération.
Renvoie un pool moyen 3D, avec les tailles de filtre, les foulées et le remplissage spécifiés.
Déclaration
@differentiable(wrt: input) public func avgPool3D<Scalar: TensorFlowFloatingPoint>( _ input: Tensor<Scalar>, filterSize: (Int, Int, Int, Int, Int), strides: (Int, Int, Int, Int, Int), padding: Padding ) -> Tensor<Scalar>
Paramètres
input
L'entrée.
filterSize
Les dimensions du noyau de mise en commun.
strides
Les foulées du filtre coulissant pour chaque dimension de l'entrée.
padding
Le rembourrage pour l'opération.
Renvoie un regroupement maximal fractionnaire 2D, avec les ratios de regroupement spécifiés.
Note:
fractionalMaxPool
ne dispose pas d' une mise en œuvre XLA, et peut donc avoir des répercussions sur la performance.Déclaration
@differentiable(wrt: input) public func fractionalMaxPool2D<Scalar: TensorFlowFloatingPoint>( _ input: Tensor<Scalar>, poolingRatio: (Double, Double, Double, Double), pseudoRandom: Bool = false, overlapping: Bool = false, deterministic: Bool = false, seed: Int64 = 0, seed2: Int64 = 0 ) -> Tensor<Scalar>
Paramètres
input
Un Tenseur. 4-D avec la forme
[batch, height, width, channels]
la[batch, height, width, channels]
la[batch, height, width, channels]
les[batch, height, width, channels]
.poolingRatio
Une liste des
Doubles
. La mise en commun pour chaque rapport de dimensioninput
, supporte actuellement que la ligne et la dimension col et doit être> = 1,0.pseudoRandom
Une option
Bool
. Par défaut ,false
. Lorsqu'il est réglé surtrue
, génère la séquence de mise en commun d'une manière pseudo - aléatoire, par ailleurs, d'une manière aléatoire.overlapping
Une option
Bool
. Par défaut ,false
. Lorsqu'il est réglé surtrue
, cela signifie que lorsque la mise en commun, les valeurs à la limite des cellules adjacentes de mise en commun sont utilisées par les deux cellules.deterministic
Une option
Bool
. Lorsqu'il est réglé surtrue
, une région , mise en commun fixe sera utilisé lors de l' itération sur un noeud fractionalMaxPool2D dans le graphe de calcul.seed
Une option
Int64
. La valeur par défaut0
. S'il est défini sur une valeur non nulle, le générateur de nombres aléatoires est ensemencé par la graine donnée.seed2
Une option
Int64
. La valeur par défaut0
. Une deuxième graine pour éviter la collision de graines.Renvoie une copie de l'
input
, où les valeurs de la dimension de profondeur sont déplacés dans des blocs spatiaux à la hauteur et la largeur.Par exemple, étant donné une entrée de forme
[1, 2, 2, 1]
, data_format = « NHWC » et block_size = 2:x = [[[[1], [2]], [[3], [4]]]]
Cette opération de sortie volonté un tenseur de forme
[1, 1, 1, 4]
:[[[[1, 2, 3, 4]]]]
Ici, l'entrée a un lot de 1 et chaque élément de charge a la forme
[2, 2, 1]
, la sortie correspondante aura un seul élément (c. -à- largeur et la hauteur sont tous deux 1) et aura une profondeur de 4 canaux (1 * taille_bloc * taille_bloc). La forme de l' élément de sortie est[1, 1, 4]
.Pour un tenseur d'entrée avec une profondeur plus grande, ici de forme
[1, 2, 2, 3]
, par exemple ,x = [[[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]]]
Cette opération, pour block_size de 2, renvoie le tenseur suivante de la forme
[1, 1, 1, 12]
[[[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]]]]
De même, pour l'entrée suivante de la forme
[1 4 4 1]
, et une taille de bloc de 2:x = [[[[1], [2], [5], [6]], [[3], [4], [7], [8]], [[9], [10], [13], [14]], [[11], [12], [15], [16]]]]
l'opérateur retourne le tenseur suivante de la forme
[1 2 2 4]
:x = [[[[1, 2, 3, 4], [5, 6, 7, 8]], [[9, 10, 11, 12], [13, 14, 15, 16]]]]
Condition préalable
input.rank == 4 && b >= 2
.Condition préalable
Le nombre des caractéristiques doit être divisible par carré deb
.Déclaration
@differentiable(wrt: input) public func depthToSpace<Scalar>(_ input: Tensor<Scalar>, blockSize b: Int) -> Tensor<Scalar> where Scalar : TensorFlowScalar
Renvoie une copie de l'
input
, où les valeurs de la hauteur et la largeur sont déplacés à la dimension de profondeur.Par exemple, étant donné une entrée de forme
[1, 2, 2, 1]
, data_format = « NHWC » et block_size = 2:x = [[[[1], [2]], [[3], [4]]]]
Cette opération de sortie volonté un tenseur de forme
[1, 1, 1, 4]
:[[[[1, 2, 3, 4]]]]
Here, the input has a batch of 1 and each batch element has shape
[2, 2, 1]
, the corresponding output will have a single element (ie width and height are both 1) and will have a depth of 4 channels (1 * block_size * block_size). The output element shape is[1, 1, 4]
.For an input tensor with larger depth, here of shape
[1, 2, 2, 3]
, egx = [[[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]]]
This operation, for block_size of 2, will return the following tensor of shape
[1, 1, 1, 12]
[[[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]]]]
Similarly, for the following input of shape
[1 4 4 1]
, and a block size of 2:x = [[[[1], [2], [5], [6]], [[3], [4], [7], [8]], [[9], [10], [13], [14]], [[11], [12], [15], [16]]]]
the operator will return the following tensor of shape
[1 2 2 4]
:x = [[[[1, 2, 3, 4], [5, 6, 7, 8]], [[9, 10, 11, 12], [13, 14, 15, 16]]]]
Precondition
input.rank == 4 && b >= 2
.Precondition
The height of the input must be divisible byb
.Precondition
The width of the input must be divisible byb
.Déclaration
@differentiable(wrt: input) public func spaceToDepth<Scalar>(_ input: Tensor<Scalar>, blockSize b: Int) -> Tensor<Scalar> where Scalar : TensorFlowScalar
Builds a per-weight optimizer for LARS ( https://arxiv.org/pdf/1708.03888.pdf ).
Déclaration
public func makeLARS( learningRate: Float = 0.01, momentum: Float = 0.9, trustCoefficient: Float = 0.001, nesterov: Bool = false, epsilon: Float = 0.0, weightDecay: Float = 0.0 ) -> ParameterGroupOptimizer
Builds a SGD based per-weight optimizer.
Déclaration
public func makeSGD( learningRate: Float = 0.01, momentum: Float = 0, weightDecay: Float = 0, nesterov: Bool = false ) -> ParameterGroupOptimizer
Builds a per-weight optimizer for Adam with weight decay.
Déclaration
public func makeAdam( learningRate: Float = 0.01, beta1: Float = 0.9, beta2: Float = 0.999, weightDecayRate: Float = 0.01, epsilon: Float = 1e-6 ) -> ParameterGroupOptimizer
Generates a new random seed for TensorFlow.
Déclaration
public func randomSeedForTensorFlow(using seed: TensorFlowSeed? = nil) -> TensorFlowSeed
Concatenates two values.
Déclaration
@differentiable public func concatenate<T: Mergeable>( _ first: T, _ second: T ) -> T
Adds two values and produces their sum.
Déclaration
@differentiable public func sum<T: Mergeable>( _ first: T, _ second: T ) -> T
Averages two values.
Déclaration
@differentiable public func average<T: Mergeable>( _ first: T, _ second: T ) -> T
Multiplies two values.
Déclaration
@differentiable public func multiply<T: Mergeable>( _ first: T, _ second: T ) -> T
Stack two values.
Déclaration
@differentiable public func stack<T: Mergeable>( _ first: T, _ second: T ) -> T
Déclaration
public func PrintX10Metrics()
Creates a string summary of a list of training and testing stats.
Déclaration
public func formatStatistics(_ stats: (train: HostStatistics, test: HostStatistics)) -> String
Déclaration
public func formatStatistics(train trainStats: HostStatistics, test testStats: HostStatistics) -> String
Maps a function over n threads.
Déclaration
public func runOnNThreads<R>(_ nThreads: Int, _ body: @escaping (Int) -> R) -> [R]