Les 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 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 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 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 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 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 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

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

    4-D Tensor de forme [batch, height, width, channels] la Tensor [height, width, channels] [batch, height, width, channels] la [batch, height, width, channels] les [batch, height, width, channels] ou 3-D Tensor 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 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 à 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 et limit , généré par le générateur par défaut du nombre aléatoire, où la limite est sqrt(6 / (fanIn + fanOut)) , et fanIn / 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 type sqrt(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 et limit , généré par le générateur par défaut du nombre aléatoire, où la limite est sqrt(6 / fanIn) , et fanIn 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 type sqrt(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 et limit , généré par le générateur de nombres aléatoires par défaut, où la limite est sqrt(3 / fanIn) , et fanIn 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 type sqrt(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 et standardDeviation , 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

    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 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 par Ax = 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 dans Ax = b .

    lower

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

    adjoint

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

    Valeur de retour

    La solution x au système d'équations linéaires représentés 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 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 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 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 et expected 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, comme log(_:) 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 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 de neurones.

    expected

    Les valeurs attendues, c'est-à-dire les cibles, qui correspondent à la sortie correcte.

  • Calcule la perte de charnière entre predicted et expected . loss = reduction(max(0, 1 - predicted * expected)) de loss = reduction(max(0, 1 - predicted * expected)) expected valeurs devraient être -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 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 et expected . loss = reduction(square(max(0, 1 - predicted * expected))) de loss = reduction(square(max(0, 1 - predicted * expected))) expected valeurs 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 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 et expected . loss = maximum(negative - positive + 1, 0)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 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'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 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

    @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 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 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 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 pour logits et une seule valeur à virgule flottante par fonction 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 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

    @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 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

    @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 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 et expected .

    Pour chaque valeur x dans l' error = expected - predicted :

    • 0.5 * x^2 si |x| <= δ .
    • 0.5 * δ^2 + δ * (|x| - δ) autrement.

    • Source: article de Wikipedia .

    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 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 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 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 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 gaussienne Erreur unités linéaires .

    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) si x < 0 , et scale * 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 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 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 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 . Distance de cosinus est défini 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 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 dimension input , 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é sur true , 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é sur true , 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é sur true , 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éfaut 0 . 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éfaut 0 . 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é 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 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] , eg

    x = [[[[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 by b .

    Precondition

    The width of the input must be divisible by b .

    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.

    Reference: “Adam - A Method for Stochastic Optimization”

    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]