Fonctions

Les fonctions suivantes sont disponibles dans le monde entier.

• l1Perte (prévue : 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 neuronal.
  expected	Valeurs attendues, c'est-à-dire cibles, qui correspondent au résultat correct.

• l2Perte (prévue : 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 neuronal.
  expected	Valeurs attendues, c'est-à-dire cibles, qui correspondent au résultat correct.

• charnièreLoss (prédit : attendu :)
  Renvoie la perte de charnière entre les prédictions et les attentes.

  Déclaration

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

  Paramètres

  predicted	Sorties prévues d'un réseau neuronal.
  expected	Valeurs attendues, c'est-à-dire cibles, qui correspondent au résultat correct.

• squaredHingeLoss (prédit : attendu :)
  Renvoie la perte de charnière carrée entre les prédictions et les attentes.

  Déclaration

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

  Paramètres

  predicted	Sorties prévues d'un réseau neuronal.
  expected	Valeurs attendues, c'est-à-dire cibles, qui correspondent au résultat correct.

• categoricalHingeLoss (prédit : attendu :)
  Renvoie la perte de charnière catégorielle entre les prédictions et les attentes.

  Déclaration

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

  Paramètres

  predicted	Sorties prévues d'un réseau neuronal.
  expected	Valeurs attendues, c'est-à-dire cibles, qui correspondent au résultat correct.

• 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 neuronal.
  expected	Valeurs attendues, c'est-à-dire cibles, qui correspondent au résultat correct.

• 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 neuronal.
  expected	Valeurs attendues, c'est-à-dire cibles, qui correspondent au résultat correct.

• kullbackLeiblerDivergence (prédit : attendu :)
  Renvoie la divergence Kullback-Leibler (divergence KL) entre les attentes et les prédictions. Étant donné deux distributions p et q , la divergence KL calcule p * log(p / q) .

  Déclaration

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

  Paramètres

  predicted	Sorties prévues d'un réseau neuronal.
  expected	Valeurs attendues, c'est-à-dire cibles, qui correspondent au résultat correct.

• softmaxCrossEntropy(logits:probabilités :)
  Renvoie l'entropie croisée softmax (entropie croisée catégorielle) entre les logits et les étiquettes.

  Déclaration

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

  Paramètres

  logits	Sorties codées à chaud d'un réseau neuronal.
  labels	Indices (indexés à zéro) des sorties correctes.

• sigmoidCrossEntropy(logits:étiquettes :)
  Renvoie l'entropie croisée sigmoïde (entropie croisée binaire) entre les logits et les étiquettes.

  Déclaration

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

  Paramètres

  logits	La sortie non mise à l'échelle d'un réseau neuronal.
  labels	Valeurs entières qui correspondent à la sortie correcte.

• 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

• avecContext(_:_:)
  Appelle la fermeture donnée dans un contexte qui a tout ce qui est identique au contexte actuel, à l'exception de la phase d'apprentissage donnée.

  Déclaration

  public func withContext<R>(_ context: Context, _ body: () throws -> R) rethrows -> R

  Paramètres

  context	Un contexte qui sera défini avant que la fermeture ne soit appelée et restauré après le retour de la fermeture.
  body	Une fermeture nulle. Si la fermeture a une valeur de retour, cette valeur est également utilisée comme valeur de retour de la fonction withContext(_:_:) .

  Valeur de retour

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

• avecLearningPhase(_:_:)
  Appelle la fermeture donnée dans un contexte qui a tout ce qui est identique au contexte actuel, à l'exception de la phase d'apprentissage donnée.

  Déclaration

  public func withLearningPhase<R>(
    _ learningPhase: LearningPhase,
    _ body: () throws -> R
  ) rethrows -> R

  Paramètres

  learningPhase	Une phase d'apprentissage qui sera définie avant l'appel de la fermeture et restaurée après le retour de la fermeture.
  body	Une fermeture nulle. Si la fermeture a une valeur de retour, cette valeur est également utilisée comme valeur de retour de la fonction withLearningPhase(_:_:) .

  Valeur de retour

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

• avecRandomSeedForTensorFlow(_:_:)
  Appelle la fermeture donnée dans un contexte qui a tout ce qui est identique au contexte actuel à l'exception de la graine aléatoire donnée.

  Déclaration

  public func withRandomSeedForTensorFlow<R>(
    _ randomSeed: TensorFlowSeed,
    _ body: () throws -> R
  ) rethrows -> R

  Paramètres

  randomSeed	Une graine aléatoire qui sera définie avant que la fermeture ne soit appelée et restaurée après le retour de la fermeture.
  body	Une fermeture nulle. Si la fermeture a une valeur de retour, cette valeur est également utilisée comme valeur de retour de la fonction withRandomSeedForTensorFlow(_:_:) .

  Valeur de retour

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

• avecRandomNumberGeneratorForTensorFlow(_:_:)
  Appelle la fermeture donnée dans un contexte qui a tout ce qui est identique au contexte actuel à l'exception du générateur de nombres aléatoires donné.

  Déclaration

  public func withRandomNumberGeneratorForTensorFlow<G: RandomNumberGenerator, R>(
    _ randomNumberGenerator: inout G,
    _ body: () throws -> R
  ) rethrows -> R

  Paramètres

  randomNumberGenerator	Un générateur de nombres aléatoires qui sera défini avant que la fermeture ne soit appelée et restauré après le retour de la fermeture.
  body	Une fermeture nulle. Si la fermeture a une valeur de retour, cette valeur est également utilisée comme valeur de retour de la fonction withRandomNumberGeneratorForTensorFlow(_:_:) .

  Valeur de retour

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

• fermeture éclair(_:_:)
  Déclaration

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

• LazyTensorBarrier(sur:appareils:attendre :)
  LazyTensorBarrier garantit que tous les tenseurs en direct (sur l'appareil s'il est fourni) sont planifiés et exécutés. Si wait est défini sur true, cet appel se bloque jusqu'à ce que le calcul soit terminé.

  Déclaration

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

• valeurAvecGradient(à:dans:)
  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

• valeurAvecGradient(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

• valeurAvecGradient(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

• valeurAvecGradient(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

• valeurAvecGradient(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

• valeurAvecGradient(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é (à: dans :)
  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é (à: _: dans :)
  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é (à:_:_: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

• dégradé(de :)
  Déclaration

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

• dégradé(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

• dégradé(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

• avecRecomputationInPullbacks(_:)
  Faire en sorte qu'une fonction soit recalculée lors de son retrait, connu sous le nom de « point de contrôle » dans la différenciation automatique traditionnelle.

  Déclaration

  public func withRecomputationInPullbacks<T, U>(
    _ body: @escaping @differentiable (T) -> U
  ) -> @differentiable (T) -> U where T : Differentiable, U : Differentiable

• fonction différentiable (de :)
  Créez une fonction différentiable à partir d'une fonction de produits vectoriels-jacobiens.

  Déclaration

  public func differentiableFunction<T : Differentiable, R : Differentiable>(
    from vjp: @escaping (T)
             -> (value: R, pullback: (R.TangentVector) -> T.TangentVector)
  ) -> @differentiable (T) -> R

• fonction différentiable (de :)
  Créez une fonction différentiable à partir d'une fonction de produits vectoriels-jacobiens.

  Déclaration

  public func differentiableFunction<T, U, R>(
    from vjp: @escaping (T, U)
             -> (value: R, pullback: (R.TangentVector)
               -> (T.TangentVector, U.TangentVector))
  ) -> @differentiable (T, U) -> R

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

  Déclaration

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

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

  Déclaration

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

• avecDevice(_:_:perform :)
  Exécute une fermeture, exécutant les opérations TensorFlow sur un type spécifique d'appareil.

  Déclaration

  public func withDevice<R>(
    _ kind: DeviceKind,
    _ index: UInt = 0,
    perform body: () throws -> R
  ) rethrows -> R

  Paramètres

  kind	Une sorte d'appareil sur lequel exécuter des opérations TensorFlow.
  index	L'appareil sur lequel exécuter les opérations.
  body	Fermeture dont les opérations TensorFlow doivent être exécutées sur le type d'appareil spécifié.

• avecDevice (nommé : effectuer :)
  Exécute une fermeture, exécutant les opérations TensorFlow sur un appareil portant un nom spécifique.

  Quelques exemples de noms d'appareils :

  • « /device:CPU:0 » : Le processeur de votre machine.
  • "/GPU:0" : notation abrégée pour le premier GPU de votre machine visible par TensorFlow
  • « /job:localhost/replica:0/task:0/device:GPU:1 » : nom complet du deuxième GPU de votre machine visible par TensorFlow.

  Déclaration

  public func withDevice<R>(named name: String, perform body: () throws -> R) rethrows -> R

  Paramètres

  name	Nom de l'appareil.
  body	Fermeture dont les opérations TensorFlow doivent être exécutées sur le type d'appareil spécifié.

• avecDefaultDevice (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: antialias :)
  Redimensionnez les images à leur taille en utilisant la méthode spécifiée.

  Condition préalable

  Les images doivent avoir le rang 3 ou 4 .

  Condition préalable

  La taille doit être positive.

  Déclaration

  @differentiable(wrt: images)
  public func resize(
    images: Tensor<Float>,
    size: (newHeight: Int, newWidth: Int),
    method: ResizeMethod = .bilinear,
    antialias: Bool = false
  ) -> Tensor<Float>

  Paramètres

  images	Tensor de forme 4-D [batch, height, width, channels] ou Tensor de forme 3-D [height, width, channels] .
  size	La nouvelle taille des images.
  method	La méthode de redimensionnement. La valeur par défaut est .bilinear .
  antialias	Si c'est true , utilisez un filtre anti-aliasing lors du sous-échantillonnage d'une image.

• resizeArea (images: taille: alignCorners :)
  Redimensionnez les images à leur taille à l'aide de l'interpolation de zone.

  Condition préalable

  Les images doivent avoir le rang 3 ou 4 .

  Condition préalable

  La taille doit être positive.

  Déclaration

  public func resizeArea<Scalar: TensorFlowNumeric>(
    images: Tensor<Scalar>,
    size: (newHeight: Int, newWidth: Int),
    alignCorners: Bool = false
  ) -> Tensor<Float>

  Paramètres

  images	Tensor de forme 4-D [batch, height, width, channels] ou Tensor de forme 3-D [height, width, channels] .
  size	La nouvelle taille des images.

• dilatation2D (_: filtre: foulé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:strides:rates:padding :)
  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.

• des zéros()
  Renvoie une fonction qui crée un tenseur en initialisant toutes ses valeurs à des zéros.

  Déclaration

  public func zeros<Scalar>() -> ParameterInitializer<Scalar> where Scalar : TensorFlowFloatingPoint

• constanteInitializer(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>

• constanteInitializer(valeur :)
  Renvoie une fonction qui crée un tenseur en l'initialisant à la valeur fournie. Notez que la diffusion de la valeur fournie n'est pas prise en charge.

  Déclaration

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

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

  Déclaration

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

• glorotNormal(graine :)
  Renvoie une fonction qui crée un tenseur en effectuant une initialisation normale Glorot (Xavier) pour la forme spécifiée, en échantillonnant aléatoirement les valeurs scalaires d'une distribution normale tronquée centrée sur 0 avec l'écart type sqrt(2 / (fanIn + fanOut)) , où fanIn / fanOut représentent le nombre d’entités d’entrée et de sortie multiplié par la taille du champ récepteur, le cas échéant.

  Déclaration

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

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

  Déclaration

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

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

  Déclaration

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

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

  Déclaration

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

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

  Déclaration

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

• truncatedNormalInitializer (moyenne: standardDeviation: graine :)
  Renvoie une fonction qui crée un tenseur en initialisant toutes ses valeurs de manière aléatoire à partir d'une distribution normale tronquée. Les valeurs générées suivent une distribution normale avec une mean et un écart type standardDeviation , sauf que les valeurs dont l'ampleur est supérieure à deux écarts types par rapport à la moyenne sont supprimées et rééchantillonnées.

  Déclaration

  public func truncatedNormalInitializer<Scalar: TensorFlowFloatingPoint>(
    mean: Tensor<Scalar> = Tensor<Scalar>(0),
    standardDeviation: Tensor<Scalar> = Tensor<Scalar>(1),
    seed: TensorFlowSeed = Context.local.randomSeed
  ) -> ParameterInitializer<Scalar>

  Paramètres

  mean	Moyenne de la distribution normale.
  standardDeviation	Écart type de la distribution normale.

  Valeur de retour

  Une fonction d'initialisation de paramètre normal tronquée.

• ==(_:_:)
  Déclaration

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

• oeil (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 lots.
  columnCount	Le nombre de colonnes dans chaque matrice de lots.
  batchShape	Les principales dimensions du lot du tenseur renvoyé.

• tracer(_:)
  Calcule la trace d'une matrice éventuellement groupée. La trace est la somme le long de la diagonale principale de chaque matrice la plus interne.

  L'entrée est un tenseur de forme [..., M, N] . La sortie est un tenseur de forme [...] .

  Condition préalable

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

  Déclaration

  @differentiable(wrt: matrix)
  public func trace<T>(_ matrix: Tensor<T>) -> Tensor<T> where T : Numeric, T : TensorFlowScalar

  Paramètres

  matrix

  Un tenseur de forme [..., M, N] .

• 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 2 dimensions les plus intérieures forment des matrices carrées.

  L'entrée doit être symétrique et définie positive. Seule la partie triangulaire inférieure de l'entrée sera utilisée pour cette opération. La partie triangulaire supérieure ne sera pas lue.

  La sortie est un tenseur de la même forme que l'entrée contenant les décompositions de Cholesky pour toutes les sous-matrices d'entrée [..., :, :] .

  Déclaration

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

  Paramètres

  input

  Un tenseur de forme [..., M, M] .

• triangularSolve (matrice: rhs: inférieur: adjoint :)
  Renvoie la solution x au système d'équations linéaires représenté par Ax = b .

  Condition préalable

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

  Condition préalable

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

  Déclaration

  @differentiable
  public func triangularSolve<T: TensorFlowFloatingPoint>(
    matrix: Tensor<T>,
    rhs: Tensor<T>,
    lower: Bool = true,
    adjoint: Bool = false
  ) -> Tensor<T>

  Paramètres

  matrix	La matrice de coefficients triangulaires d'entrée, représentant A dans Ax = b .
  rhs	Valeurs du côté droit, représentant b dans Ax = b .
  lower	Si matrix est triangulaire inférieure ( true ) ou triangulaire supérieure ( false ). La valeur par défaut est true .
  adjoint	Si c'est true , résolvez avec l'adjoint de matrix au lieu de matrix . La valeur par défaut est false .

  Valeur de retour

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

• l1Perte (prévue : attendue : 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 neuronal.
  expected	Valeurs attendues, c'est-à-dire cibles, qui correspondent au résultat correct.
  reduction	Réduction à appliquer sur les valeurs de perte calculées par élément.

• l2Loss (prédit : attendu : 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 neuronal.
  expected	Valeurs attendues, c'est-à-dire cibles, qui correspondent au résultat correct.
  reduction	Réduction à appliquer sur les valeurs de perte calculées par élément.

• 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 neuronal.
  expected	Valeurs attendues, c'est-à-dire cibles, qui correspondent au résultat correct.

• MeanSquaredError (prédit : attendu :)
  Calcule la moyenne des carrés d'erreurs entre les étiquettes et les prédictions. loss = mean(square(expected - predicted))

  Déclaration

  @differentiable(wrt: predicted)
  @differentiable(wrt: (predicted, expected)
  public func meanSquaredError<Scalar: TensorFlowFloatingPoint>(
    predicted: Tensor<Scalar>,
    expected: Tensor<Scalar>
  ) -> Tensor<Scalar>

  Paramètres

  predicted	Sorties prévues d'un réseau neuronal.
  expected	Valeurs attendues, c'est-à-dire cibles, qui correspondent au résultat correct.

• MeanSquaredLogarithmicError (prédit : attendu :)
  Calcule l'erreur logarithmique quadratique moyenne entre la perte predicted et expected loss = square(log(expected) - log(predicted))

  Note

  Les entrées tensorielles négatives seront limitées à 0 pour éviter un comportement logarithmique indéfini, car log(_:) n'est pas défini pour les réels négatifs.

  Déclaration

  @differentiable(wrt: predicted)
  @differentiable(wrt: (predicted, expected)
  public func meanSquaredLogarithmicError<Scalar: TensorFlowFloatingPoint>(
    predicted: Tensor<Scalar>,
    expected: Tensor<Scalar>
  ) -> Tensor<Scalar>

  Paramètres

  predicted	Sorties prévues d'un réseau neuronal.
  expected	Valeurs attendues, c'est-à-dire cibles, qui correspondent au résultat correct.

• MeanAbsolutePercentageError (prédit : attendu :)
  Calcule le pourcentage d'erreur absolu moyen 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 neuronal.
  expected	Valeurs attendues, c'est-à-dire cibles, qui correspondent au résultat correct.

• charnièreLoss (prédit : attendu : réduction :)
  Calcule la perte charnière entre predicted et expected . loss = reduction(max(0, 1 - predicted * expected)) les valeurs expected devraient être de -1 ou 1.

  Déclaration

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

  Paramètres

  predicted	Sorties prévues d'un réseau neuronal.
  expected	Valeurs attendues, c'est-à-dire cibles, qui correspondent au résultat correct.
  reduction	Réduction à appliquer sur les valeurs de perte calculées par élément.

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

  Déclaration

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

  Paramètres

  predicted	Sorties prévues d'un réseau neuronal.
  expected	Valeurs attendues, c'est-à-dire cibles, qui correspondent au résultat correct.
  reduction	Réduction à appliquer sur les valeurs de perte calculées par élément.

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

  Déclaration

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

  Paramètres

  predicted	Sorties prévues d'un réseau neuronal.
  expected	Valeurs attendues, c'est-à-dire cibles, qui correspondent au résultat correct.
  reduction	Réduction à appliquer sur les valeurs de perte calculées par élément.

• 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 neuronal.
  expected	Valeurs attendues, c'est-à-dire cibles, qui correspondent au résultat correct.
  reduction	Réduction à appliquer sur les valeurs de perte calculées par élément.

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

  Déclaration

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

  Paramètres

  predicted	Sorties prévues d'un réseau neuronal.
  expected	Valeurs attendues, c'est-à-dire cibles, qui correspondent au résultat correct.
  reduction	Réduction à appliquer sur les valeurs de perte calculées par élément.

• kullbackLeiblerDivergence(prédit:attendu:réduction :)
  Calcule la perte de divergence Kullback-Leibler entre expected et predicted . loss = reduction(expected * log(expected / predicted))

  Déclaration

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

  Paramètres

  predicted	Sorties prévues d'un réseau neuronal.
  expected	Valeurs attendues, c'est-à-dire cibles, qui correspondent au résultat correct.
  reduction	Réduction à appliquer sur les valeurs de perte calculées par élément.

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

  Déclaration

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

  Paramètres

  logits	Sorties codées à chaud d'un réseau neuronal.
  labels	Indices (indexés à zéro) des sorties correctes.
  reduction	Réduction à appliquer sur les valeurs de perte calculées par élément.

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

  Déclaration

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

  Paramètres

  logits	Probabilités de journalisation non mises à l'échelle à partir d'un réseau neuronal.
  probabilities	Valeurs de probabilité qui correspondent à la sortie correcte. Chaque ligne doit être une distribution de probabilité valide.
  reduction	Réduction à appliquer sur les valeurs de perte calculées par élément.

• sigmoidCrossEntropy(logits:étiquettes:réduction :)
  Calcule l'entropie croisée sigmoïde (entropie croisée binaire) entre les logits et les étiquettes. Utilisez cette perte d'entropie croisée lorsqu'il n'y a que deux classes d'étiquettes (supposées être 0 et 1). Pour chaque exemple, il doit y avoir une seule valeur à virgule flottante par prédiction.

  Déclaration

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

  Paramètres

  logits	La sortie non mise à l'échelle d'un réseau neuronal.
  labels	Valeurs entières qui correspondent à la sortie correcte.
  reduction	Réduction à appliquer sur les valeurs de perte calculées par élément.

• huberLoss (prédit: attendu: delta: réduction :)
  Calcule la perte de Huber entre predicted et expected .

  Pour chaque valeur x en error = expected - predicted :

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

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

  • Source : Article Wikipédia .

  Déclaration

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

  Paramètres

  predicted	Sorties prévues d'un réseau neuronal.
  expected	Valeurs attendues, c'est-à-dire cibles, qui correspondent au résultat correct.
  delta	Un scalaire à virgule flottante représentant le point où la fonction de perte de Huber passe de quadratique à linéaire.
  reduction	Réduction à appliquer sur les valeurs de perte calculées par élément.

• 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

• enregistrer(_:)
  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(_:)
  Renvoie log(1 - exp(x)) en utilisant une approche numériquement stable.

  Note

  L'approche est présentée dans l'équation 7 de : https://cran.r-project.org/web/packages/Rmpfr/vignettes/log1mexp-note.pdf .

  Déclaration

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

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

• carré(_:)
  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

• rsqrt(_:)
  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é 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

• rond(_:)
  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

• signe doux(_:)
  Renvoie le softsign du tenseur spécifié par élément. Plus précisément, calcule features/ (abs(features) + 1) .

  Déclaration

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

• softmax(_:)
  Renvoie le softmax du tenseur spécifié le long du dernier axe. Plus précisément, calcule exp(x) / exp(x).sum(alongAxes: -1) .

  Déclaration

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

• softmax (_: le long de l'axe :)
  Renvoie le softmax du tenseur spécifié le long de l'axe spécifié. Plus précisément, calcule exp(x) / exp(x).sum(alongAxes: axis) .

  Déclaration

  @differentiable
  public func softmax<T>(_ x: Tensor<T>, alongAxis axis: Int) -> Tensor<T> where T : TensorFlowFloatingPoint

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

  Déclaration

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

• 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 Unités linéaires d'erreur gaussienne .

  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(_:)
  Renvoie un tenseur en appliquant la fonction d'activation ReLU6, à savoir min(max(0, x), 6) .

  Déclaration

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

• fuiteRelu (_: alpha :)
  Renvoie un tenseur en appliquant la fonction d'activation ReLU qui fuit au tenseur spécifié par élément. Plus précisément, calcule max(x, x * alpha) .

  Déclaration

  @differentiable(wrt: x)
  public func leakyRelu<T: TensorFlowFloatingPoint>(
    _ x: Tensor<T>,
    alpha: Double = 0.2
  ) -> Tensor<T>

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

  Note

  Ceci est conçu pour être utilisé avec les initialiseurs de couche de mise à l’échelle de la variance. Veuillez vous référer à Réseaux de neurones auto-normalisés pour plus d'informations.

  Déclaration

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

• bruissement(_:)
  Renvoie un tenseur en appliquant la fonction d'activation swish, à savoir x * sigmoid(x) .

  Source : « Recherche de fonctions d'activation » (Ramachandran et al. 2017) https://arxiv.org/abs/1710.05941

  Déclaration

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

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

  Source : « Recherche de MobileNetV3 » (Howard et al. 2019) https://arxiv.org/abs/1905.02244

  Déclaration

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

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

  Source : « Recherche de MobileNetV3 » (Howard et al. 2019) https://arxiv.org/abs/1905.02244

  Déclaration

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

• mish(_:)
  Renvoie un tenseur en appliquant la fonction d'activation mish, à savoir x * tanh(softplus(x)) .

  Source : « Mish : une fonction d'activation neuronale non monotone auto-régularisée » https://arxiv.org/abs/1908.08681

  Déclaration

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

• 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 la n racine élément par élément du tenseur.

  Déclaration

  @differentiable
  public func root<T>(_ x: Tensor<T>, _ n: Int) -> Tensor<T> where T : TensorFlowFloatingPoint

• Différence carrée (_: _ :)
  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 .

• maximum(_:_:)
  Renvoie le maximum élément par élément de deux tenseurs.

  Note

  max prend en charge la diffusion.

  Déclaration

  @differentiable
  public func max<T>(_ lhs: Tensor<T>, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar

• maximum(_:_:)
  Renvoie le maximum élément par élément du scalaire et du tenseur, diffusant le scalaire.

  Déclaration

  @differentiable(wrt: rhs)
  public func max<T>(_ lhs: T, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar

• maximum(_:_:)
  Renvoie le maximum élément par élément du scalaire et du tenseur, diffusant le scalaire.

  Déclaration

  @differentiable(wrt: lhs)
  public func max<T>(_ lhs: Tensor<T>, _ rhs: T) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar

• min(_:_:)
  Renvoie le minimum élément par élément de deux tenseurs.

  Note

  min prend en charge la diffusion.

  Déclaration

  @differentiable
  public func min<T>(_ lhs: Tensor<T>, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar

• 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

• cosinusSimilarité(_:_:)
  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 . La distance cosinus est définie comme 1 - cosineSimilarity(x, y) .

  Déclaration

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

• 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:dilation :)
  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.

• deepwiseConv2D(_: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 pooling maximum 2D, avec les tailles de filtre, les foulées et le remplissage spécifiés.

  Déclaration

  @differentiable(wrt: input)
  public func maxPool2D<Scalar: TensorFlowFloatingPoint>(
    _ input: Tensor<Scalar>,
    filterSize: (Int, Int, Int, Int),
    strides: (Int, Int, Int, Int),
    padding: Padding
  ) -> Tensor<Scalar>

  Paramètres

  input	L'entrée.
  filterSize	Les dimensions du noyau de pooling.
  strides	Les foulées du filtre coulissant pour chaque dimension de l’entrée.
  padding	Le rembourrage pour l'opération.

• maxPool3D (_:filterSize:strides:padding :)
  Renvoie un pooling maximum 3D, avec les tailles de filtre, les foulées et le remplissage spécifiés.

  Déclaration

  @differentiable(wrt: input)
  public func maxPool3D<Scalar: TensorFlowFloatingPoint>(
    _ input: Tensor<Scalar>,
    filterSize: (Int, Int, Int, Int, Int),
    strides: (Int, Int, Int, Int, Int),
    padding: Padding
  ) -> Tensor<Scalar>

  Paramètres

  input	L'entrée.
  filterSize	Les dimensions du noyau de pooling.
  strides	Les foulées du filtre coulissant pour chaque dimension de l’entrée.
  padding	Le rembourrage pour l'opération.

• avgPool2D (_:filterSize:strides:padding :)
  Renvoie un regroupement moyen 2D, avec les tailles de filtre, les foulées et le remplissage spécifiés.

  Déclaration

  @differentiable(wrt: input)
  public func avgPool2D<Scalar: TensorFlowFloatingPoint>(
    _ input: Tensor<Scalar>,
    filterSize: (Int, Int, Int, Int),
    strides: (Int, Int, Int, Int),
    padding: Padding
  ) -> Tensor<Scalar>

  Paramètres

  input	L'entrée.
  filterSize	Les dimensions du noyau de pooling.
  strides	Les foulées du filtre coulissant pour chaque dimension de l’entrée.
  padding	Le rembourrage pour l'opération.

• avgPool3D (_:filterSize:strides:padding :)
  Renvoie un regroupement moyen 3D, avec les tailles de filtre, les foulées et le remplissage spécifiés.

  Déclaration

  @differentiable(wrt: input)
  public func avgPool3D<Scalar: TensorFlowFloatingPoint>(
    _ input: Tensor<Scalar>,
    filterSize: (Int, Int, Int, Int, Int),
    strides: (Int, Int, Int, Int, Int),
    padding: Padding
  ) -> Tensor<Scalar>

  Paramètres

  input	L'entrée.
  filterSize	Les dimensions du noyau de pooling.
  strides	Les foulées du filtre coulissant pour chaque dimension de l’entrée.
  padding	Le rembourrage pour l'opération.

• fractionalMaxPool2D (_: poolingRatio: pseudoRandom: chevauchement: déterministe: graine: graine2 :)
  Renvoie un pooling maximal fractionnaire 2D, avec les ratios de pooling spécifiés.

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

  Déclaration

  @differentiable(wrt: input)
  public func fractionalMaxPool2D<Scalar: TensorFlowFloatingPoint>(
    _ input: Tensor<Scalar>,
    poolingRatio: (Double, Double, Double, Double),
    pseudoRandom: Bool = false,
    overlapping: Bool = false,
    deterministic: Bool = false,
    seed: Int64 = 0,
    seed2: Int64 = 0
  ) -> Tensor<Scalar>

  Paramètres

  input	Un Tenseur. 4-D avec forme [batch, height, width, channels] .
  poolingRatio	Une liste de Doubles . Le ratio de regroupement pour chaque dimension de input , ne prend actuellement en charge que les dimensions de ligne et de col et devrait être >= 1,0.
  pseudoRandom	Un Bool facultatif. La valeur par défaut est false . Lorsqu'il est défini sur true , génère la séquence de pooling de manière pseudo-aléatoire, sinon de manière aléatoire.
  overlapping	Un Bool facultatif. La valeur par défaut est false . Lorsqu'il est défini sur true , cela signifie que lors du regroupement, les valeurs à la limite des cellules de regroupement adjacentes sont utilisées par les deux cellules.
  deterministic	Un Bool facultatif. Lorsqu'elle est définie sur true , une région de pooling fixe sera utilisée lors de l'itération sur un nœud fractionalMaxPool2D dans le graphe de calcul.
  seed	Un Int64 facultatif. La valeur par défaut est 0 . S'il est défini sur une valeur différente de zéro, le générateur de nombres aléatoires est amorcé par la graine donnée.
  seed2	Un Int64 facultatif. La valeur par défaut est 0 . Une deuxième graine pour éviter la collision des graines.

• profondeurVersEspace(_:blockSize :)
  Renvoie une copie de input dans laquelle les valeurs de la dimension de profondeur sont déplacées dans des blocs spatiaux vers les dimensions de hauteur et de largeur.

  Par exemple, étant donné une entrée de forme [1, 2, 2, 1] , data_format = « NHWC » et block_size = 2 :

  x = [[[[1], [2]],
        [[3], [4]]]]
  

  Cette opération produira un tenseur de forme [1, 1, 1, 4] :

  [[[[1, 2, 3, 4]]]]
  

  Ici, l'entrée a un lot de 1 et chaque élément du lot a la forme [2, 2, 1] , la sortie correspondante aura un seul élément (c'est-à-dire que la largeur et la hauteur sont toutes deux égales à 1) et aura une profondeur de 4 canaux (1 * block_size * block_size). La forme de l'élément de sortie est [1, 1, 4] .

  Pour un tenseur d'entrée avec une plus grande profondeur, ici de forme [1, 2, 2, 3] , par exemple

  x = [[[[1, 2, 3], [4, 5, 6]],
        [[7, 8, 9], [10, 11, 12]]]]
  

  Cette opération, pour block_size de 2, renverra le tenseur de forme suivant [1, 1, 1, 12]

  [[[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]]]]
  

  De même, pour l'entrée suivante de forme [1 4 4 1] et une taille de bloc de 2 :

  x = [[[[1],   [2],  [5],  [6]],
        [[3],   [4],  [7],  [8]],
        [[9],  [10], [13],  [14]],
        [[11], [12], [15],  [16]]]]
  

  l'opérateur renverra le tenseur de forme suivant [1 2 2 4] :

  x = [[[[1, 2, 3, 4],
         [5, 6, 7, 8]],
        [[9, 10, 11, 12],
         [13, 14, 15, 16]]]]
  

  Condition préalable

  input.rank == 4 && b >= 2 .

  Condition préalable

  Le nombre d'entités doit être divisible par le carré de b .

  Déclaration

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

• espaceVersProfondeur(_:blockSize :)
  Renvoie une copie de input dans laquelle les valeurs des dimensions de hauteur et de largeur sont déplacées vers la dimension de profondeur.

  Par exemple, étant donné une entrée de forme [1, 2, 2, 1] , data_format = « NHWC » et block_size = 2 :

  x = [[[[1], [2]],
        [[3], [4]]]]
  

  Cette opération produira un tenseur de forme [1, 1, 1, 4] :

  [[[[1, 2, 3, 4]]]]
  

  Ici, l'entrée a un lot de 1 et chaque élément du lot a la forme [2, 2, 1] , la sortie correspondante aura un seul élément (c'est-à-dire que la largeur et la hauteur sont toutes deux égales à 1) et aura une profondeur de 4 canaux (1 * block_size * block_size). La forme de l'élément de sortie est [1, 1, 4] .

  Pour un tenseur d'entrée avec une plus grande profondeur, ici de forme [1, 2, 2, 3] , par exemple

  x = [[[[1, 2, 3], [4, 5, 6]],
        [[7, 8, 9], [10, 11, 12]]]]
  

  Cette opération, pour block_size de 2, renverra le tenseur de forme suivant [1, 1, 1, 12]

  [[[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]]]]
  

  De même, pour l'entrée suivante de forme [1 4 4 1] et une taille de bloc de 2 :

  x = [[[[1],   [2],  [5],  [6]],
        [[3],   [4],  [7],  [8]],
        [[9],  [10], [13],  [14]],
        [[11], [12], [15],  [16]]]]
  

  l'opérateur renverra le tenseur de forme suivant [1 2 2 4] :

  x = [[[[1, 2, 3, 4],
         [5, 6, 7, 8]],
        [[9, 10, 11, 12],
         [13, 14, 15, 16]]]]
  

  Condition préalable

  input.rank == 4 && b >= 2 .

  Condition préalable

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

  Condition préalable

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

  Déclaration

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

• makeLARS (learningRate:momentum:trustCoefficient:nesterov:epsilon:weightDecay :)
  Construit un optimiseur par poids pour LARS ( https://arxiv.org/pdf/1708.03888.pdf ).

  Déclaration

  public func makeLARS(
    learningRate: Float = 0.01,
    momentum: Float = 0.9,
    trustCoefficient: Float = 0.001,
    nesterov: Bool = false,
    epsilon: Float = 0.0,
    weightDecay: Float = 0.0
  ) -> ParameterGroupOptimizer

• makeSGD(learningRate:momentum:weightDecay:nesterov:)
  Construit un optimiseur par poids basé sur SGD.

  Déclaration

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

• MAKEADAM (Apprentissage: Beta1: Beta2: WeightDecayRate: Epsilon :)
  Construit un optimiseur par poids pour Adam avec une désintégration de poids.

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

  Déclaration

  public func makeAdam(
    learningRate: Float = 0.01,
    beta1: Float = 0.9,
    beta2: Float = 0.999,
    weightDecayRate: Float = 0.01,
    epsilon: Float = 1e-6
  ) -> ParameterGroupOptimizer

• RandomsseedForttenSorflow (en utilisant :)
  Génère une nouvelle graine aléatoire pour TensorFlow.

  Déclaration

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

• enchaîner(_:_:)
  Concatène deux valeurs.

  Déclaration

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

• somme(_:_:)
  Ajoute deux valeurs et produit leur somme.

  Déclaration

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

• moyenne(_:_:)
  En moyenne deux valeurs.

  Déclaration

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

• multiplier(_:_:)
  Multiplie deux valeurs.

  Déclaration

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

• empiler(_:_:)
  Empiler deux valeurs.

  Déclaration

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

• PrintX10Metrics ()
  Déclaration

  public func PrintX10Metrics()

• Formatstatistics (_ :)
  Crée un résumé de cordes d'une liste de statistiques de formation et de test.

  Déclaration

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

• Formatstatistics (train: test :)
  Déclaration

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

• RunonnThreads (_: _ :)
  Carte une fonction sur n threads.

  Déclaration

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