Les fonctions

Les fonctions suivantes sont disponibles dans le monde entier.

• l1Perte (prédite : attendue :)

  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.

• l2Perte (prédite : attendue :)

  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.

• charnièrePerte (prédite : attendue :)

  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.

• squaredHingeLoss (prédit : attendu :)

  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.

• Perte de charnière catégorique (prédite : attendue :)

  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.

• logCoshLoss (prédit : attendu :)

  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.

• poissonLoss(prédit:attendu :)

  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.

• kullbackLeiblerDivergence (prédit : attendu :)

  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.

• softmaxCrossEntropy(logits:probabilités:)

  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.

• sigmoidCrossEntropy(logits:labels:)

  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.

• identité(_:)

  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

• avecContexte(_:_:)

  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.

• withLearningPhase(_:_:)

  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.

• withRandomSeedForTensorFlow(_:_:)

  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.

• withRandomNumberGeneratorForTensorFlow(_:_:)

  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.

• Zip *: français(_:_:)

  Déclaration

  public func zip<T: TensorGroup, U: TensorGroup>(
    _ dataset1: Dataset<T>, _ dataset2: Dataset<U>
  ) -> Dataset<Zip2TensorGroup<T, U>>

• LazyTensorBarrier(sur:appareils:attente:)

  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)

• valueWithGradient(at:in:)

  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

• valueWithGradient(at:_:in:)

  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

• valueWithGradient(at:_:_:in:)

  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

• valeurAvecDégradé(de :)

  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

• valeurAvecDégradé(de :)

  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

• valeurAvecDégradé(de :)

  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égradé(at:in:)

  Déclaration

  public func gradient<T, R>(
    at x: T,
    in f: @differentiable (T) -> Tensor<R>
  ) -> T.TangentVector where T: Differentiable, R: TensorFlowFloatingPoint

• dégradé(at:_:in:)

  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égradé(at:_:_:in:)

  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

• gradient(de :)

  Déclaration

  public func gradient<T, R>(
    of f: @escaping @differentiable (T) -> Tensor<R>
  ) -> (T) -> T.TangentVector where T: Differentiable, R: TensorFlowFloatingPoint

• gradient(de :)

  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

• gradient(de :)

  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

• avecRecalculInPullbacks(_:)

  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

• fonction différentiable(de :)

  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

• fonction différentiable(de :)

  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

• sansDérivé(à :)

  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

• sansDérivé(at:in:)

  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

• avecPériphérique(_:_:effectuer :)

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

• withDevice(named:perform:)

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

• withDefaultDevice(effectuer :)

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

• redimensionner(images:taille:méthode:anticrénelage :)

  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.

• resizeArea(images:size:alignCorners:)

  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.

• dilatation2D(_:filtre:enjambées:taux:rembourrage :)

  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.

• érosion2D(_:filter:enjambées:taux:rembourrage :)

  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.

• zéros()

  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

• constantInitializer(valeur :)

  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>

• constantInitializer(valeur :)

  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>

• glorotUniform(graine :)

  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>

• glorotNormal(graine :)

  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>

• ilUniforme(graine :)

  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>

• ilNormal(graine :)

  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>

• leCunUniform(graine :)

  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>

• leCunNormal(graine :)

  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>

• tronquéNormalInitializer(mean:standardDeviation:seed:)

  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

• eye(rowCount:columnCount:batchShape:on:)

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

• trace(_:)

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

• cholesky(_:)

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

• triangularSolve(matrice:rhs:inférieur:adjoint:)

  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 .

• l1Perte(prédite :prévue :réduction :)

  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.

• l2Perte(prédite:attendue:réduction :)

  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.

• MeanAbsoluteError (prédit : attendu :)

  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.

• MeanSquaredError (prédit : attendu :)

  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.

• MeanSquaredLogarithmicError (prédit : attendu :)

  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.

• MeanAbsolutePercentageError (prédit : attendu :)

  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.

• Perte charnière(prédite:attendue:réduction :)

  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.

• squaredHingeLoss(prévu:attendu:réduction:)

  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.

• Perte de charnière catégorique(prédite :prévue :réduction :)

  Calcule la perte de charnière catégorique 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 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.

• logCoshLoss(prédit:attendu:réduction :)

  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.

• poissonLoss(prévu:attendu:réduction:)

  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.

• kullbackLeiblerDivergence(prévu:attendu:réduction:)

  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.

• softmaxCrossEntropy(logits:labels:reduction:)

  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.

• softmaxCrossEntropy(logits:probabilités:réduction:)

  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.

• sigmoidCrossEntropy(logits:labels:reduction:)

  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.

• huberLoss(prévu:attendu:delta:réduction :)

  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.

• abdos(_:)

  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

• Journal(_:)

  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

• log2(_:)

  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

• log10(_:)

  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

• log1p(_:)

  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

• log1mexp(_:)

  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

• péché(_:)

  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

• cos(_:)

  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

• bronzer(_:)

  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

• sinh(_:)

  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

• matraque(_:)

  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

• tanh(_:)

  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

• acos(_:)

  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

• un péché(_:)

  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

• un bronzage(_:)

  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

• acosh(_:)

  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

• asinh(_:)

  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

• atanh(_:)

  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

• sqrt(_:)

  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

• rqrt(_:)

  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

• exp(_:)

  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

• exp2(_:)

  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

• exp10(_:)

  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

• expm1(_:)

  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

• tour(_:)

  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

• plafond(_:)

  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

• sol(_:)

  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

• signe(_:)

  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

• sigmoïde(_:)

  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

• logSigmoïde(_:)

  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

• softplus(_:)

  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

• softsign(_:)

  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

• softmax(_:)

  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

• softmax(_:le long de l'axe :)

  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

• logSoftmax(_:)

  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

• élu(_:)

  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

• gelu(_:)

  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

• relu(_:)

  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

• relu6(_:)

  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

• leakyRelu(_:alpha:)

  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>

• selu(_:)

  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

• bruissement(_:)

  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

• durSigmoïde(_:)

  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

• hardSwish(_:)

  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

• mish(_:)

  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

• pow(_:_:)

  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

• pow(_:_:)

  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

• pow(_:_:)

  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

• pow(_:_:)

  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

• racine(_:_:)

  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

• Différence carré(_:_:)

  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 .

• max(_:_:)

  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

• max(_:_:)

  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

• max(_:_:)

  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

• min(_:_:)

  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

• min(_:_:)

  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

• min(_:_:)

  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

• cosinusSimilitude(_:_:)

  Renvoie la similarité cosinus entre x et y .

  Déclaration

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

• cosinusDistance(_:_:)

  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>

• matmul(_:transposé:_:transposé :)

  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>

• conv1D(_:filter:stride:padding:dilatation :)

  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.

• conv2D(_:filter:strides:padding:dilations :)

  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.

• transposedConv2D(_:shape:filter:strides:padding:dilations :)

  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.

• conv3D(_:filter:strides:padding:dilations :)

  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.

• depthwiseConv2D(_:filter:strides:padding :)

  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.

• maxPool2D(_:filterSize:strides:padding :)

  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.

• maxPool3D(_:filterSize:strides:padding :)

  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.

• avgPool2D(_:filterSize:strides:padding :)

  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.

• avgPool3D(_:filterSize:strides:padding :)

  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.

• fractionalMaxPool2D(_:poolingRatio:pseudoRandom:overlapping:deterministic:seed:seed2:)

  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.

• profondeurVersEspace(_:blockSize :)

  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

• spaceToDepth(_:blockSize:)

  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

• makeLARS(learningRate:momentum:trustCoefficient:nesterov:epsilon:weightDecay:)

  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

• makeSGD(learningRate:momentum:weightDecay:nesterov:)

  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

• makeAdam(learningRate:beta1:beta2:weightDecayRate:epsilon:)

  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

• randomSeedForTensorFlow(using:)

  Generates a new random seed for TensorFlow.

  Déclaration

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

• concatenate(_:_:)

  Concatenates two values.

  Déclaration

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

• sum(_:_:)

  Adds two values and produces their sum.

  Déclaration

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

• average(_:_:)

  Averages two values.

  Déclaration

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

• multiply(_:_:)

  Multiplies two values.

  Déclaration

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

• stack(_:_:)

  Stack two values.

  Déclaration

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

• PrintX10Metrics()

  Déclaration

  public func PrintX10Metrics()

• formatStatistics(_:)

  Creates a string summary of a list of training and testing stats.

  Déclaration

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

• formatStatistics(train:test:)

  Déclaration

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

• runOnNThreads(_:_:)

  Maps a function over n threads.

  Déclaration

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