Fonctions

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 neuronal.

    expected

    Valeurs attendues, c'est-à-dire cibles, qui correspondent au résultat correct.

  • 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 neuronal.

    expected

    Valeurs attendues, c'est-à-dire cibles, qui correspondent au résultat correct.

  • 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 neuronal.

    expected

    Valeurs attendues, c'est-à-dire cibles, qui correspondent au résultat correct.

  • Renvoie la perte de charnière carrée 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 neuronal.

    expected

    Valeurs attendues, c'est-à-dire cibles, qui correspondent au résultat correct.

  • Renvoie la perte de charnière catégorielle 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 neuronal.

    expected

    Valeurs attendues, c'est-à-dire cibles, qui correspondent au résultat correct.

  • 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 neuronal.

    expected

    Valeurs attendues, c'est-à-dire cibles, qui correspondent au résultat correct.

  • 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 neuronal.

    expected

    Valeurs attendues, c'est-à-dire cibles, qui correspondent au résultat correct.

  • Renvoie la divergence Kullback-Leibler (divergence KL) entre les attentes et les prédictions. Étant donné deux distributions p et q , la divergence KL calcule p * 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 neuronal.

    expected

    Valeurs attendues, c'est-à-dire cibles, qui correspondent au résultat correct.

  • Renvoie l'entropie croisée softmax (entropie croisée catégorielle) 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 neuronal.

    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 neuronal.

    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 ce qui est 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é 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 fonction withContext(_:_:) .

    Valeur de retour

    La valeur de retour, le cas échéant, de la fermeture body .

  • Appelle la fermeture donnée dans un contexte qui a tout ce qui est 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 l'appel de la fermeture 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 fonction withLearningPhase(_:_:) .

    Valeur de retour

    La valeur de retour, le cas échéant, de la fermeture body .

  • Appelle la fermeture donnée dans un contexte qui a tout ce qui est 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 fonction withRandomSeedForTensorFlow(_:_:) .

    Valeur de retour

    La valeur de retour, le cas échéant, de la fermeture body .

  • Appelle la fermeture donnée dans un contexte qui a tout ce qui est 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 que la fermeture ne soit appelée 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 fonction withRandomNumberGeneratorForTensorFlow(_:_:) .

    Valeur de retour

    La valeur de retour, le cas échéant, de la fermeture body .

  • 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 s'il est fourni) sont planifiés et exécutés. Si wait est défini sur true, cet appel se bloque jusqu'à ce que le calcul soit terminé.

    Déclaration 

    public func LazyTensorBarrier(on device: Device? = nil, devices: [Device] = [], wait: Bool = false)

  • 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 en sorte qu'une fonction soit recalculée lors de son retrait, connu sous le nom de « point de contrôle » 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 de produits vectoriels-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 de produits vectoriels-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

  • Renvoie x comme une fonction d'identité. Lorsqu'elle est utilisée dans un contexte où x est différencié par rapport à, cette fonction ne produira aucune dérivée en x .

    Déclaration 

    @_semantics("autodiff.nonvarying")
public func withoutDerivative<T>(at x: T) -> T

  • Applique le body de fermeture donné à x . Lorsqu'elle est utilisée dans un contexte où x est différencié par rapport à, cette fonction ne produira aucune dérivée en x .

    Déclaration 

    @_semantics("autodiff.nonvarying")
public func withoutDerivative<T, R>(at x: T, in body: (T) -> R) -> R

  • Exécute une fermeture, exécutant les opérations TensorFlow sur un type spécifique d'appareil.

    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 des 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, exécutant les opérations TensorFlow sur un appareil portant un nom spécifique.

    Quelques exemples de noms d'appareils :

    • « /device:CPU:0 » : Le processeur 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 à leur taille en utilisant la méthode spécifiée.

    Condition préalable

    Les images doivent avoir le rang 3 ou 4 .

    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

    Tensor de forme 4-D [batch, height, width, channels] ou Tensor de forme 3-D [height, width, channels] .

    size

    La nouvelle taille des images.

    method

    La méthode de redimensionnement. La valeur par défaut est .bilinear .

    antialias

    Si c'est true , utilisez un filtre anti-aliasing lors du sous-échantillonnage d'une image.

  • Redimensionnez les images à leur taille à l'aide de l'interpolation de zone.

    Condition préalable

    Les images doivent avoir le rang 3 ou 4 .

    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

    Tensor de forme 4-D [batch, height, width, channels] ou Tensor de forme 3-D [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 rang 4 .

    Condition préalable

    filter doit avoir le rang 3 .

    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 rang 4 .

    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 à des 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 n'est pas prise en charge.

    Déclaration 

    public func constantInitializer<Scalar: TensorFlowFloatingPoint>(
  value: Tensor<Scalar>
) -> ParameterInitializer<Scalar>

  • Renvoie une fonction qui crée un tenseur en effectuant une initialisation uniforme Glorot (Xavier) pour la forme spécifiée, en échantillonnant aléatoirement les valeurs scalaires à partir d'une distribution uniforme entre -limit et limit , générée par le générateur de nombres aléatoires par défaut, où limit est sqrt(6 / (fanIn + fanOut)) et fanIn / fanOut représentent le nombre de fonctionnalités d'entrée et de sortie multiplié par le champ récepteur, le cas échéant.

    Déclaration 

    public func glorotUniform<Scalar: TensorFlowFloatingPoint>(
  seed: TensorFlowSeed = Context.local.randomSeed
) -> ParameterInitializer<Scalar>

  • Renvoie une fonction qui crée un tenseur en effectuant une initialisation normale Glorot (Xavier) pour la forme spécifiée, en échantillonnant aléatoirement les valeurs scalaires d'une distribution normale tronquée centrée sur 0 avec l'écart type sqrt(2 / (fanIn + fanOut)) , où fanIn / fanOut représentent le nombre d’entités d’entrée et de 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 une initialisation uniforme He (Kaiming) pour la forme spécifiée, en échantillonnant aléatoirement les valeurs scalaires à partir d'une distribution uniforme entre -limit et limit , générée par le générateur de nombres aléatoires par défaut, où limit est sqrt(6 / fanIn) , et fanIn représente le nombre d'entités d'entrée multiplié par le champ récepteur, le cas échéant.

    Déclaration 

    public func heUniform<Scalar: TensorFlowFloatingPoint>(
  seed: TensorFlowSeed = Context.local.randomSeed
) -> ParameterInitializer<Scalar>

  • Renvoie une fonction qui crée un tenseur en effectuant une initialisation normale He (Kaiming) pour la forme spécifiée, en échantillonnant aléatoirement les valeurs scalaires d'une distribution normale tronquée centrée sur 0 avec l'écart type sqrt(2 / fanIn) , où fanIn représente le nombre d'entités 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 une initialisation uniforme LeCun pour la forme spécifiée, en échantillonnant aléatoirement les valeurs scalaires à partir d'une distribution uniforme entre -limit et limit , générée par le générateur de nombres aléatoires par défaut, où limit est sqrt(3 / fanIn) , et fanIn représente le nombre d'entités d'entrée multiplié par le champ récepteur, le cas échéant.

    Déclaration 

    public func leCunUniform<Scalar: TensorFlowFloatingPoint>(
  seed: TensorFlowSeed = Context.local.randomSeed
) -> ParameterInitializer<Scalar>

  • Renvoie une fonction qui crée un tenseur en effectuant une initialisation normale LeCun pour la forme spécifiée, en échantillonnant aléatoirement les valeurs scalaires d'une distribution normale tronquée centrée sur 0 avec l'écart type sqrt(1 / fanIn) , où fanIn représente le nombre d'entités d'entrée multiplié par le taille du champ récepteur, le cas échéant.

    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 distribution normale avec une mean et un écart type standardDeviation , sauf que les valeurs dont l'ampleur est supérieure à deux écarts types par rapport à la moyenne sont supprimées 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 normal tronquée.

  • Déclaration 

    public func == (lhs: TFETensorHandle, rhs: TFETensorHandle) -> Bool

  • Renvoie une matrice d'identité ou un lot de matrices.

    Déclaration 

    public func eye<Scalar: Numeric>(
  rowCount: Int,
  columnCount: Int? = nil,
  batchShape: [Int] = [],
  on device: Device = .default
) -> Tensor<Scalar>

    Paramètres

    rowCount

    Le nombre de lignes dans chaque matrice de lots.

    columnCount

    Le nombre de colonnes dans chaque matrice de lots.

    batchShape

    Les principales dimensions du 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 de 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 2 dimensions les plus intérieures 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.

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

  • Renvoie la solution x au système d'équations linéaires représenté par Ax = b .

    Condition préalable

    matrix doit être un tenseur de forme [..., M, M] .

    Condition préalable

    rhs doit être un tenseur de 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 de coefficients triangulaires d'entrée, représentant A dans Ax = b .

    rhs

    Valeurs du côté droit, représentant b dans Ax = b .

    lower

    Si matrix est triangulaire inférieure ( true ) ou triangulaire supérieure ( false ). La valeur par défaut est true .

    adjoint

    Si true , résolvez avec l'adjoint de matrix au lieu de matrix . La valeur par défaut est false .

    Valeur de retour

    La solution x au système d'équations linéaires représenté par Ax = b . x a la même forme que b .

  • Calcule la perte L1 entre expected et predicted . loss = reduction(abs(expected - predicted))

    Déclaration 

    @differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func l1Loss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _sum
) -> Tensor<Scalar>

    Paramètres

    predicted

    Sorties prévues d'un réseau neuronal.

    expected

    Valeurs attendues, c'est-à-dire cibles, qui correspondent au résultat correct.

    reduction

    Réduction à appliquer sur les valeurs de perte calculées par élément.

  • Calcule la perte L2 entre expected et predicted . loss = reduction(square(expected - predicted))

    Déclaration 

    @differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func l2Loss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _sum
) -> Tensor<Scalar>

    Paramètres

    predicted

    Sorties prévues d'un réseau neuronal.

    expected

    Valeurs attendues, c'est-à-dire cibles, qui correspondent au résultat correct.

    reduction

    Réduction à appliquer sur les valeurs de perte calculées par élément.

  • 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 neuronal.

    expected

    Valeurs attendues, c'est-à-dire cibles, qui correspondent au résultat correct.

  • Calcule la moyenne des carrés d'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 neuronal.

    expected

    Valeurs attendues, c'est-à-dire cibles, qui correspondent au résultat correct.

  • Calcule l'erreur logarithmique quadratique moyenne entre la perte predicted et expected loss = square(log(expected) - log(predicted))

    Note

    Les entrées tensorielles négatives seront limitées à 0 pour éviter un comportement logarithmique indéfini, car log(_:) n'est pas défini pour les 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 neuronal.

    expected

    Valeurs attendues, c'est-à-dire cibles, qui correspondent au résultat correct.

  • Calcule le pourcentage d'erreur absolu moyen entre les predicted et expected . 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 neuronal.

    expected

    Valeurs attendues, c'est-à-dire cibles, qui correspondent au résultat correct.

  • Calcule la perte charnière entre predicted et expected . loss = reduction(max(0, 1 - predicted * expected)) les valeurs expected devraient être de -1 ou 1.

    Déclaration 

    @differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func hingeLoss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
) -> Tensor<Scalar>

    Paramètres

    predicted

    Sorties prévues d'un réseau neuronal.

    expected

    Valeurs attendues, c'est-à-dire cibles, qui correspondent au résultat correct.

    reduction

    Réduction à appliquer sur les valeurs de perte calculées par élément.

  • Calcule la perte de charnière carrée entre predicted et expected . loss = reduction(square(max(0, 1 - predicted * expected))) les valeurs expected devraient être -1 ou 1.

    Déclaration 

    @differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func squaredHingeLoss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
) -> Tensor<Scalar>

    Paramètres

    predicted

    Sorties prévues d'un réseau neuronal.

    expected

    Valeurs attendues, c'est-à-dire cibles, qui correspondent au résultat correct.

    reduction

    Réduction à appliquer sur les valeurs de perte calculées par élément.

  • Calcule la perte de charnière catégorielle entre predicted et expected . loss = maximum(negative - positive + 1, 0) où negative = max((1 - expected) * predicted) et positive = sum(predicted * expected)

    Déclaration 

    @differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func categoricalHingeLoss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
) -> Tensor<Scalar>

    Paramètres

    predicted

    Sorties prévues d'un réseau neuronal.

    expected

    Valeurs attendues, c'est-à-dire cibles, qui correspondent au résultat correct.

    reduction

    Réduction à appliquer sur les valeurs de perte calculées par élément.

  • Calcule le logarithme du cosinus hyperbolique de l'erreur de prédiction. logcosh = log((exp(x) + exp(-x))/2) , où x est l'erreur predicted - expected

    Déclaration 

    @differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func logCoshLoss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
) -> Tensor<Scalar>

    Paramètres

    predicted

    Sorties prévues d'un réseau neuronal.

    expected

    Valeurs attendues, c'est-à-dire cibles, qui correspondent au résultat correct.

    reduction

    Réduction à appliquer sur les valeurs de perte calculées par élément.

  • Calcule la perte de Poisson entre prédite et attendue La perte de Poisson est la moyenne des éléments du Tensor predicted - expected * log(predicted) .

    Déclaration 

    @differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func poissonLoss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
) -> Tensor<Scalar>

    Paramètres

    predicted

    Sorties prévues d'un réseau neuronal.

    expected

    Valeurs attendues, c'est-à-dire cibles, qui correspondent au résultat correct.

    reduction

    Réduction à appliquer sur les valeurs de perte calculées par élément.

  • Calcule la perte de divergence Kullback-Leibler entre expected et predicted . loss = reduction(expected * log(expected / predicted))

    Déclaration 

    @differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func kullbackLeiblerDivergence<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _sum
) -> Tensor<Scalar>

    Paramètres

    predicted

    Sorties prévues d'un réseau neuronal.

    expected

    Valeurs attendues, c'est-à-dire cibles, qui correspondent au résultat correct.

    reduction

    Réduction à appliquer sur les valeurs de perte calculées par élément.

  • Calcule l'entropie croisée softmax clairsemée (entropie croisée catégorielle) entre les logits et les étiquettes. Utilisez cette fonction de perte d'entropie croisée lorsqu'il existe deux classes d'étiquettes ou plus. Nous nous attendons à ce que les étiquettes soient fournies sous forme d’entiers. Il devrait y avoir # classes de valeurs à virgule flottante par fonctionnalité pour logits et une seule valeur à virgule flottante par fonctionnalité pour expected .

    Déclaration 

    @differentiable(wrt: logits)
public func softmaxCrossEntropy<Scalar: TensorFlowFloatingPoint>(
  logits: Tensor<Scalar>,
  labels: Tensor<Int32>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
) -> Tensor<Scalar>

    Paramètres

    logits

    Sorties codées à chaud d'un réseau neuronal.

    labels

    Indices (indexés à zéro) des sorties correctes.

    reduction

    Réduction à appliquer sur les valeurs de perte calculées par élément.

  • Calcule l'entropie croisée softmax clairsemée (entropie croisée catégorielle) entre les logits et les étiquettes. Utilisez cette fonction de perte d'entropie croisée lorsqu'il existe deux classes d'étiquettes ou plus. Nous nous attendons à ce que les étiquettes soient fournies dans une représentation one_hot . Il devrait y avoir # classes de valeurs à virgule flottante par fonctionnalité.

    Déclaration 

    @differentiable(wrt: logits)
public func softmaxCrossEntropy<Scalar: TensorFlowFloatingPoint>(
  logits: Tensor<Scalar>,
  probabilities: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
) -> Tensor<Scalar>

    Paramètres

    logits

    Probabilités de journalisation non mises à l'échelle à partir d'un réseau neuronal.

    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 calculées par élément.

  • 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 

    @differentiable(wrt: logits)
@differentiable(wrt: (logits, labels)
public func sigmoidCrossEntropy<Scalar: TensorFlowFloatingPoint>(
  logits: Tensor<Scalar>,
  labels: Tensor<Scalar>,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _mean
) -> Tensor<Scalar>

    Paramètres

    logits

    La sortie non mise à l'échelle d'un réseau neuronal.

    labels

    Valeurs entières qui correspondent à la sortie correcte.

    reduction

    Réduction à appliquer sur les valeurs de perte calculées par élément.

  • Calcule la perte de Huber entre predicted et expected .

    Pour chaque valeur x en error = expected - predicted :

    • 0.5 * x^2 si |x| <= δ .

    • 0.5 * δ^2 + δ * (|x| - δ) sinon.

    • Source : Article Wikipédia .

    Déclaration 

    @differentiable(wrt: predicted)
@differentiable(wrt: (predicted, expected)
public func huberLoss<Scalar: TensorFlowFloatingPoint>(
  predicted: Tensor<Scalar>,
  expected: Tensor<Scalar>,
  delta: Scalar,
  reduction: @differentiable (Tensor<Scalar>) -> Tensor<Scalar> = _sum
) -> Tensor<Scalar>

    Paramètres

    predicted

    Sorties prévues d'un réseau neuronal.

    expected

    Valeurs attendues, c'est-à-dire cibles, qui correspondent au résultat correct.

    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 calculées par élément.

  • 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

  • Renvoie log(1 - exp(x)) en utilisant une approche numériquement stable.

    Note

    L'approche est présentée dans l'équation 7 de : 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é 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é 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 si x < 0 ; 0 si x == 0 ; 1 si x > 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 features/ (abs(features) + 1) .

    Déclaration 

    @differentiable
public func softsign<T>(_ features: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • Renvoie le 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 le 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 sinon. Voir Apprentissage réseau approfondi rapide et précis par unités linéaires exponentielles (ELU)

    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 rapproche xP(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)])].

    Voir Unités linéaires d'erreur gaussienne .

    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

  • Renvoie un tenseur en appliquant la fonction d'activation 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 ReLU qui fuit 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>

  • Renvoie un tenseur en appliquant la fonction d'activation SeLU, à savoir scale * alpha * (exp(x) - 1) si x < 0 , et scale * x sinon.

    Note

    Ceci est conçu pour être utilisé avec les initialiseurs de couche de mise à l’échelle de la variance. Veuillez vous référer à Réseaux de neurones auto-normalisés 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 : « Recherche de fonctions d'activation » (Ramachandran et al. 2017) https://arxiv.org/abs/1710.05941

    Déclaration 

    @differentiable
public func swish<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • Renvoie un tenseur en appliquant la fonction d'activation sigmoïde dure, à savoir Relu6(x+3)/6 .

    Source : « Recherche de 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

  • Renvoie un tenseur en appliquant la fonction d'activation hard swish, à savoir x * Relu6(x+3)/6 .

    Source : « Recherche de 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 : une fonction d'activation neuronale non monotone auto-régularisée » 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 la nième racine élément n élément 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 et y .

    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 élément par élément de deux tenseurs.

    Note

    max prend en charge la diffusion.

    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 élément 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 élément 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 élément par élément de deux tenseurs.

    Note

    min prend en charge la diffusion.

    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 et y .

    Déclaration 

    @differentiable
public func cosineSimilarity<Scalar: TensorFlowFloatingPoint>(
  _ x: Tensor<Scalar>,
  _ y: Tensor<Scalar>
) -> Tensor<Scalar>

  • Renvoie la distance cosinus entre x et y . La distance cosinus est définie comme 1 - cosineSimilarity(x, y) .

    Déclaration 

    @differentiable
public func cosineDistance<Scalar: TensorFlowFloatingPoint>(
  _ x: Tensor<Scalar>,
  _ y: Tensor<Scalar>
) -> Tensor<Scalar>

  • Effectue une multiplication matricielle avec un autre tenseur et produit le résultat.

    Déclaration 

    @differentiable
public func matmul<Scalar: Numeric>(
  _ lhs: Tensor<Scalar>,
  transposed transposeLhs: Bool = false,
  _ rhs: Tensor<Scalar>,
  transposed transposeRhs: Bool = false
) -> 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 rang 3 .

    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 rang 4 .

    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 rang 4 .

    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 rang 5 .

    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 pooling maximum 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 pooling.

    strides

    Les foulées du filtre coulissant pour chaque dimension de l’entrée.

    padding

    Le rembourrage pour l'opération.

  • Renvoie un pooling maximum 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 pooling.

    strides

    Les foulées du filtre coulissant pour chaque dimension de l'entrée.

    padding

    Le rembourrage pour l'opération.

  • Renvoie un regroupement 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 pooling.

    strides

    Les foulées du filtre coulissant pour chaque dimension de l'entrée.

    padding

    Le rembourrage pour l'opération.

  • Renvoie un regroupement 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 pooling.

    strides

    Les foulées du filtre coulissant pour chaque dimension de l’entrée.

    padding

    Le rembourrage pour l'opération.

  • Renvoie un pooling maximal fractionnaire 2D, avec les ratios de pooling spécifiés.

    Remarque : fractionalMaxPool n'a pas d'implémentation XLA et peut donc avoir des implications en termes de performances.

    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 forme [batch, height, width, channels] .

    poolingRatio

    Une liste de Doubles . Le ratio de regroupement pour chaque dimension de input , ne prend actuellement en charge que les dimensions de ligne et de col et devrait être >= 1,0.

    pseudoRandom

    Un Bool facultatif. La valeur par défaut est false . Lorsqu'il est défini sur true , génère la séquence de pooling de manière pseudo-aléatoire, sinon de manière aléatoire.

    overlapping

    Un Bool facultatif. La valeur par défaut est false . Lorsqu'il est défini sur true , cela signifie que lors du regroupement, les valeurs à la limite des cellules de regroupement adjacentes sont utilisées par les deux cellules.

    deterministic

    Un Bool facultatif. Lorsqu'elle est définie sur true , une région de pooling fixe sera utilisée lors de l'itération sur un nœud fractionalMaxPool2D dans le graphe de calcul.

    seed

    Un Int64 facultatif. La valeur par défaut est 0 . S'il est défini sur une valeur différente de zéro, le générateur de nombres aléatoires est amorcé par la graine donnée.

    seed2

    Un Int64 facultatif. La valeur par défaut est 0 . Une deuxième graine pour éviter la collision des graines.

  • Renvoie une copie de input dans laquelle les valeurs de la dimension de profondeur sont déplacées dans des blocs spatiaux vers les dimensions de hauteur et de 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 produira 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 du lot a la forme [2, 2, 1] , la sortie correspondante aura un seul élément (c'est-à-dire que la largeur et la hauteur sont toutes deux égales à 1) et aura une profondeur de 4 canaux (1 * block_size * block_size). La forme de l'élément de sortie est [1, 1, 4] .

    Pour un tenseur d'entrée avec une plus grande profondeur, 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, renverra le tenseur de forme suivant [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 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 renverra le tenseur de forme suivant [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 d'entités doit être divisible par le carré de b .

    Déclaration 

    @differentiable(wrt: input)
public func depthToSpace<Scalar>(_ input: Tensor<Scalar>, blockSize b: Int) -> Tensor<Scalar> where Scalar : TensorFlowScalar

  • Renvoie une copie de input dans laquelle les valeurs des dimensions de hauteur et de largeur sont déplacées vers 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 produira 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 du lot a la forme [2, 2, 1] , la sortie correspondante aura un seul élément (c'est-à-dire que la largeur et la hauteur sont toutes deux égales à 1) et aura une profondeur de 4 canaux (1 * block_size * block_size). La forme de l'élément de sortie est [1, 1, 4] .

    Pour un tenseur d'entrée avec une plus grande profondeur, 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, renverra le tenseur de forme suivant [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 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 retournera le tenseur de forme suivant [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

    La hauteur de l'entrée doit être divisible par b .

    Condition préalable

    La largeur de l'entrée doit être divisible par b .

    Déclaration 

    @differentiable(wrt: input)
public func spaceToDepth<Scalar>(_ input: Tensor<Scalar>, blockSize b: Int) -> Tensor<Scalar> where Scalar : TensorFlowScalar

  • Construit un optimiseur par poids pour 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

  • Construit un optimiseur par poids basé sur SGD.

    Déclaration 

    public func makeSGD(
  learningRate: Float = 0.01,
  momentum: Float = 0,
  weightDecay: Float = 0,
  nesterov: Bool = false
) -> ParameterGroupOptimizer

  • Construit un optimiseur par poids pour Adam avec une désintégration de poids.

    Référence: «Adam - une méthode d'optimisation stochastique»

    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

  • Génère une nouvelle graine aléatoire pour TensorFlow.

    Déclaration 

    public func randomSeedForTensorFlow(using seed: TensorFlowSeed? = nil) -> TensorFlowSeed

  • Concatène deux valeurs.

    Déclaration 

    @differentiable
public func concatenate<T: Mergeable>(
  _ first: T,
  _ second: T
) -> T

  • Ajoute deux valeurs et produit leur somme.

    Déclaration 

    @differentiable
public func sum<T: Mergeable>(
  _ first: T,
  _ second: T
) -> T

  • En moyenne deux valeurs.

    Déclaration 

    @differentiable
public func average<T: Mergeable>(
  _ first: T,
  _ second: T
) -> T

  • Multiplie deux valeurs.

    Déclaration 

    @differentiable
public func multiply<T: Mergeable>(
  _ first: T,
  _ second: T
) -> T

  • Empiler deux valeurs.

    Déclaration 

    @differentiable
public func stack<T: Mergeable>(
  _ first: T,
  _ second: T
) -> T

  • Déclaration 

    public func PrintX10Metrics()

  • Crée un résumé de cordes d'une liste de statistiques de formation et de test.

    Déclaration 

    public func formatStatistics(_ stats: (train: HostStatistics, test: HostStatistics)) -> String

  • Déclaration 

    public func formatStatistics(train trainStats: HostStatistics, test testStats: HostStatistics)
  -> String

  • Carte une fonction sur n threads.

    Déclaration 

    public func runOnNThreads<R>(_ nThreads: Int, _ body: @escaping (Int) -> R) -> [R]