Funktionen

Die folgenden Funktionen sind global verfügbar.

  • Gibt den L1-Verlust zwischen Vorhersagen und Erwartungen zurück.

    Erklärung

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

    Parameter

    predicted

    Voraussichtliche Ausgaben eines neuronalen Netzwerks.

    expected

    Erwartete Werte, dh Ziele, die der korrekten Ausgabe entsprechen.

  • Gibt den L2-Verlust zwischen Vorhersagen und Erwartungen zurück.

    Erklärung

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

    Parameter

    predicted

    Voraussichtliche Ausgaben eines neuronalen Netzwerks.

    expected

    Erwartete Werte, dh Ziele, die der korrekten Ausgabe entsprechen.

  • Gibt den Scharnierverlust zwischen Vorhersagen und Erwartungen zurück.

    Erklärung

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

    Parameter

    predicted

    Voraussichtliche Ausgaben eines neuronalen Netzwerks.

    expected

    Erwartete Werte, dh Ziele, die der korrekten Ausgabe entsprechen.

  • Gibt den quadratischen Scharnierverlust zwischen Vorhersagen und Erwartungen zurück.

    Erklärung

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

    Parameter

    predicted

    Voraussichtliche Ausgaben eines neuronalen Netzwerks.

    expected

    Erwartete Werte, dh Ziele, die der korrekten Ausgabe entsprechen.

  • Gibt den kategorialen Scharnierverlust zwischen Vorhersagen und Erwartungen zurück.

    Erklärung

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

    Parameter

    predicted

    Voraussichtliche Ausgaben eines neuronalen Netzwerks.

    expected

    Erwartete Werte, dh Ziele, die der korrekten Ausgabe entsprechen.

  • Gibt den Logarithmus des hyperbolischen Kosinus des Fehlers zwischen Vorhersagen und Erwartungen zurück.

    Erklärung

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

    Parameter

    predicted

    Voraussichtliche Ausgaben eines neuronalen Netzwerks.

    expected

    Erwartete Werte, dh Ziele, die der korrekten Ausgabe entsprechen.

  • Gibt den Poisson-Verlust zwischen Vorhersagen und Erwartungen zurück.

    Erklärung

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

    Parameter

    predicted

    Voraussichtliche Ausgaben eines neuronalen Netzwerks.

    expected

    Erwartete Werte, dh Ziele, die der korrekten Ausgabe entsprechen.

  • Gibt die Kullback-Leibler-Divergenz (KL-Divergenz) zwischen Erwartungen und Vorhersagen zurück. Bei zwei Verteilungen p und q berechnet die KL-Divergenz p * log(p / q) .

    Erklärung

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

    Parameter

    predicted

    Voraussichtliche Ausgaben eines neuronalen Netzwerks.

    expected

    Erwartete Werte, dh Ziele, die der korrekten Ausgabe entsprechen.

  • Gibt die Softmax-Kreuzentropie (kategoriale Kreuzentropie) zwischen Protokollen und Beschriftungen zurück.

    Erklärung

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

    Parameter

    logits

    One-Hot-codierte Ausgänge von einem neuronalen Netzwerk.

    labels

    Indizes (nullindexiert) der korrekten Ausgänge.

  • Gibt die Sigmoid-Kreuzentropie (binäre Kreuzentropie) zwischen Protokollen und Beschriftungen zurück.

    Erklärung

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

    Parameter

    logits

    Die nicht skalierte Ausgabe eines neuronalen Netzwerks.

    labels

    Ganzzahlige Werte, die der korrekten Ausgabe entsprechen.

  • Gibt einen Tensor mit derselben Form und denselben Skalaren wie der angegebene Tensor zurück.

    Erklärung

    @differentiable
    public func identity<Scalar>(_ x: Tensor<Scalar>) -> Tensor<Scalar> where Scalar : TensorFlowScalar
  • Ruft den angegebenen Abschluss in einem Kontext auf, in dem bis auf die angegebene Lernphase alles mit dem aktuellen Kontext identisch ist.

    Erklärung

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

    Parameter

    context

    Ein Kontext, der festgelegt wird, bevor der Abschluss aufgerufen und wiederhergestellt wird, nachdem der Abschluss zurückgekehrt ist.

    body

    Eine Nullschließung. Wenn der Abschluss einen Rückgabewert hat, wird dieser Wert auch als Rückgabewert der Funktion withContext(_:_:) verwendet.

    Rückgabewert

    Der Rückgabewert des body , falls vorhanden.

  • Ruft den angegebenen Abschluss in einem Kontext auf, in dem bis auf die angegebene Lernphase alles mit dem aktuellen Kontext identisch ist.

    Erklärung

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

    Parameter

    learningPhase

    Eine Lernphase, die festgelegt wird, bevor der Abschluss aufgerufen und wiederhergestellt wird, nachdem der Abschluss zurückgekehrt ist.

    body

    Eine Nullschließung. Wenn der Abschluss einen Rückgabewert hat, wird dieser Wert auch als Rückgabewert der Funktion withLearningPhase(_:_:) verwendet.

    Rückgabewert

    Der Rückgabewert des body , falls vorhanden.

  • Ruft den angegebenen Abschluss in einem Kontext auf, in dem bis auf den angegebenen zufälligen Startwert alles mit dem aktuellen Kontext identisch ist.

    Erklärung

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

    Parameter

    randomSeed

    Ein zufälliger Startwert, der festgelegt wird, bevor der Abschluss aufgerufen und wiederhergestellt wird, nachdem der Abschluss zurückgekehrt ist.

    body

    Eine Nullschließung. Wenn der Abschluss einen Rückgabewert hat, wird dieser Wert auch als Rückgabewert der Funktion withRandomSeedForTensorFlow(_:_:) verwendet.

    Rückgabewert

    Der Rückgabewert des body , falls vorhanden.

  • Ruft den angegebenen Abschluss in einem Kontext auf, in dem bis auf den angegebenen Zufallszahlengenerator alles mit dem aktuellen Kontext identisch ist.

    Erklärung

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

    Parameter

    randomNumberGenerator

    Ein Zufallszahlengenerator, der festgelegt wird, bevor der Abschluss aufgerufen und wiederhergestellt wird, nachdem der Abschluss zurückgekehrt ist.

    body

    Eine Nullschließung. Wenn der Abschluss einen Rückgabewert hat, wird dieser Wert auch als Rückgabewert der Funktion withRandomNumberGeneratorForTensorFlow(_:_:) verwendet.

    Rückgabewert

    Der Rückgabewert des body , falls vorhanden.

  • Erklärung

    public func zip<T: TensorGroup, U: TensorGroup>(
      _ dataset1: Dataset<T>, _ dataset2: Dataset<U>
    ) -> Dataset<Zip2TensorGroup<T, U>>
  • LazyTensorBarrier stellt sicher, dass alle aktiven Tensoren (auf dem Gerät, falls vorhanden) geplant und ausgeführt werden. Wenn wait auf true gesetzt ist, wird dieser Aufruf blockiert, bis die Berechnung abgeschlossen ist.

    Erklärung

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

    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
  • Erklärung

    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
  • Erklärung

    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
  • Erklärung

    public func valueWithGradient<T, R>(
      of f: @escaping @differentiable (T) -> Tensor<R>
    ) -> (T) -> (value: Tensor<R>, gradient: T.TangentVector)
    where T: Differentiable, R: TensorFlowFloatingPoint
  • Erklärung

    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
  • Erklärung

    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
  • Erklärung

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

    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
  • Erklärung

    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
  • Erklärung

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

    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
  • Erklärung

    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
  • Lassen Sie eine Funktion in ihrem Pullback neu berechnen, der bei der herkömmlichen automatischen Differenzierung als „Checkpointing“ bezeichnet wird.

    Erklärung

    public func withRecomputationInPullbacks<T, U>(
      _ body: @escaping @differentiable (T) -> U
    ) -> @differentiable (T) -> U where T : Differentiable, U : Differentiable
  • Erstellen Sie eine differenzierbare Funktion aus einer vektor-jakobianischen Produktfunktion.

    Erklärung

    public func differentiableFunction<T : Differentiable, R : Differentiable>(
      from vjp: @escaping (T)
               -> (value: R, pullback: (R.TangentVector) -> T.TangentVector)
    ) -> @differentiable (T) -> R
  • Erstellen Sie eine differenzierbare Funktion aus einer vektor-jakobianischen Produktfunktion.

    Erklärung

    public func differentiableFunction<T, U, R>(
      from vjp: @escaping (T, U)
               -> (value: R, pullback: (R.TangentVector)
                 -> (T.TangentVector, U.TangentVector))
    ) -> @differentiable (T, U) -> R
  • Gibt x wie eine Identitätsfunktion zurück. In einem Kontext, in dem x in Bezug auf differenziert wird, erzeugt diese Funktion bei x keine Ableitung.

    Erklärung

    @_semantics("autodiff.nonvarying")
    public func withoutDerivative<T>(at x: T) -> T
  • Wendet den angegebenen body auf x . In einem Kontext, in dem x in Bezug auf differenziert wird, erzeugt diese Funktion bei x keine Ableitung.

    Erklärung

    @_semantics("autodiff.nonvarying")
    public func withoutDerivative<T, R>(at x: T, in body: (T) -> R) -> R
  • Führt einen Abschluss aus, sodass TensorFlow-Vorgänge auf einem bestimmten Gerätetyp ausgeführt werden.

    Erklärung

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

    Parameter

    kind

    Eine Art Gerät, auf dem TensorFlow-Vorgänge ausgeführt werden können.

    index

    Das Gerät, auf dem die Operationen ausgeführt werden sollen.

    body

    Ein Abschluss, dessen TensorFlow-Operationen auf dem angegebenen Gerätetyp ausgeführt werden sollen.

  • Führt einen Abschluss aus, sodass TensorFlow-Vorgänge auf einem Gerät mit einem bestimmten Namen ausgeführt werden.

    Einige Beispiele für Gerätenamen:

    • "/ Device: CPU: 0": Die CPU Ihres Computers.
    • "/ GPU: 0": Kurznotation für die erste GPU Ihres Computers, die für TensorFlow sichtbar ist
    • "/ Job: localhost / replica: 0 / task: 0 / device: GPU: 1": Vollqualifizierter Name der zweiten GPU Ihres Computers, die für TensorFlow sichtbar ist.

    Erklärung

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

    Parameter

    name

    Gerätename.

    body

    Ein Abschluss, dessen TensorFlow-Operationen auf dem angegebenen Gerätetyp ausgeführt werden sollen.

  • Führt einen Abschluss aus, sodass TensorFlow TensorFlow-Vorgänge auf jedem Gerät platzieren kann. Dadurch sollte das Standardplatzierungsverhalten wiederhergestellt werden.

    Erklärung

    public func withDefaultDevice<R>(perform body: () throws -> R) rethrows -> R

    Parameter

    body

    Ein Abschluss, dessen TensorFlow-Operationen auf dem angegebenen Gerätetyp ausgeführt werden sollen.

  • Ändern Sie die Größe der Bilder mit der angegebenen Methode.

    Voraussetzung

    Die Bilder müssen Rang 3 oder 4 .

    Voraussetzung

    Die Größe muss positiv sein.

    Erklärung

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

    Parameter

    images

    4-D- Tensor der Form [batch, height, width, channels] oder 3-D- Tensor der Form [height, width, channels] .

    size

    Die neue Größe der Bilder.

    method

    Die Größenänderungsmethode. Der Standardwert ist .bilinear .

    antialias

    Wenn dies true , verwenden Sie beim Downsampling eines Bildes einen Anti-Aliasing-Filter.

  • Ändern Sie die Größe der Bilder mithilfe der Bereichsinterpolation.

    Voraussetzung

    Die Bilder müssen Rang 3 oder 4 .

    Voraussetzung

    Die Größe muss positiv sein.

    Erklärung

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

    Parameter

    images

    4-D- Tensor der Form [batch, height, width, channels] oder 3-D- Tensor der Form [height, width, channels] .

    size

    Die neue Größe der Bilder.

  • Gibt eine 2-D-Erweiterung mit den angegebenen Eingaben, Filtern, Schritten und Auffüllungen zurück.

    Voraussetzung

    input muss Rang 4 .

    Voraussetzung

    filter muss Rang 3 .

    Erklärung

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

    Parameter

    input

    Die Eingabe.

    filter

    Der Dilatationsfilter.

    strides

    Die Schritte des Gleitfilters für jede Dimension der Eingabe.

    padding

    Die Polsterung für die Operation

    rates

    Die Dilatationsraten für jede Dimension der Eingabe.

  • Gibt eine 2-D-Erosion mit den angegebenen Eingaben, Filtern, Schritten und Auffüllungen zurück.

    Voraussetzung

    input muss Rang 4 .

    Voraussetzung

    filter muss Rang 3 haben.

    Erklärung

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

    Parameter

    input

    Die Eingabe.

    filter

    Der Erosionsfilter.

    strides

    Die Schritte des Gleitfilters für jede Dimension der Eingabe.

    padding

    Die Polsterung für die Operation

    rates

    Die Dilatationsraten für jede Dimension der Eingabe.

  • Gibt eine Funktion zurück, die einen Tensor erstellt, indem alle ihre Werte auf Null gesetzt werden.

    Erklärung

    public func zeros<Scalar>() -> ParameterInitializer<Scalar> where Scalar : TensorFlowFloatingPoint
  • Gibt eine Funktion zurück, die einen Tensor erstellt, indem alle ihre Werte auf den angegebenen Wert initialisiert werden.

    Erklärung

    public func constantInitializer<Scalar: TensorFlowFloatingPoint>(
      value: Scalar
    ) -> ParameterInitializer<Scalar>
  • Gibt eine Funktion zurück, die einen Tensor erstellt, indem sie auf den angegebenen Wert initialisiert wird. Beachten Sie, dass das Senden des angegebenen Werts nicht unterstützt wird.

    Erklärung

    public func constantInitializer<Scalar: TensorFlowFloatingPoint>(
      value: Tensor<Scalar>
    ) -> ParameterInitializer<Scalar>
  • Gibt eine Funktion zurück, die einen Tensor erstellt, indem eine gleichmäßige Glorot (Xavier) -Initialisierung für die angegebene Form durchgeführt wird. Dabei werden zufällig skalare Werte aus einer gleichmäßigen Verteilung zwischen -limit und limit -limit , die vom Standard-Zufallszahlengenerator generiert wird, wobei limit sqrt(6 / (fanIn + fanOut)) und fanIn / fanOut die Anzahl der Eingangs- und Ausgangsmerkmale multipliziert mit dem Empfangsfeld an, falls vorhanden.

    Erklärung

    public func glorotUniform<Scalar: TensorFlowFloatingPoint>(
      seed: TensorFlowSeed = Context.local.randomSeed
    ) -> ParameterInitializer<Scalar>
  • Gibt eine Funktion zurück, die einen Tensor erstellt, indem eine Glorot (Xavier) -Normalinitialisierung für die angegebene Form durchgeführt wird, wobei Skalarwerte zufällig aus einer auf 0 zentrierten abgeschnittenen Normalverteilung mit Standardabweichung sqrt(2 / (fanIn + fanOut)) fanIn , wobei fanIn / fanOut stellen die Anzahl der Eingabe- und Ausgabemerkmale multipliziert mit der Empfangsfeldgröße dar, falls vorhanden.

    Erklärung

    public func glorotNormal<Scalar: TensorFlowFloatingPoint>(
      seed: TensorFlowSeed = Context.local.randomSeed
    ) -> ParameterInitializer<Scalar>
  • Gibt eine Funktion zurück, die einen Tensor erstellt, indem eine gleichmäßige Initialisierung von He (Kaiming) für die angegebene Form durchgeführt wird, wobei Skalarwerte zufällig aus einer gleichmäßigen Verteilung zwischen -limit und limit -limit , die vom Standard-Zufallszahlengenerator generiert wird, wobei limit sqrt(6 / fanIn) und fanIn für die Anzahl der Eingabemerkmale multipliziert mit dem Empfangsfeld, falls vorhanden.

    Erklärung

    public func heUniform<Scalar: TensorFlowFloatingPoint>(
      seed: TensorFlowSeed = Context.local.randomSeed
    ) -> ParameterInitializer<Scalar>
  • Gibt eine Funktion zurück, die einen Tensor erzeugt, indem sie eine He (Kaiming) -Normalinitialisierung für die angegebene Form durchführt und dabei zufällig Skalarwerte aus einer auf 0 zentrierten abgeschnittenen Normalverteilung mit Standardabweichung sqrt(2 / fanIn) , wobei fanIn die Anzahl der Eingabemerkmale darstellt multipliziert mit der Empfangsfeldgröße, falls vorhanden.

    Erklärung

    public func heNormal<Scalar: TensorFlowFloatingPoint>(
      seed: TensorFlowSeed = Context.local.randomSeed
    ) -> ParameterInitializer<Scalar>
  • Gibt eine Funktion zurück, die einen Tensor erstellt, indem eine einheitliche -limit Initialisierung für die angegebene Form durchgeführt wird. Dabei werden zufällig skalare Werte aus einer gleichmäßigen Verteilung zwischen -limit und limit -limit , die vom Standard-Zufallszahlengenerator generiert wird, wobei limit sqrt(3 / fanIn) ist fanIn die Anzahl der Eingabemerkmale multipliziert mit dem Empfangsfeld an, falls vorhanden.

    Erklärung

    public func leCunUniform<Scalar: TensorFlowFloatingPoint>(
      seed: TensorFlowSeed = Context.local.randomSeed
    ) -> ParameterInitializer<Scalar>
  • Gibt eine Funktion zurück, die einen Tensor erstellt, indem eine LeCun-Normalinitialisierung für die angegebene Form durchgeführt wird. Dabei werden zufällig skalare Werte aus einer auf 0 zentrierten abgeschnittenen Normalverteilung mit der Standardabweichung sqrt(1 / fanIn) , wobei fanIn die Anzahl der Eingabefunktionen multipliziert mit dem darstellt Empfangsfeldgröße, falls vorhanden.

    Erklärung

    public func leCunNormal<Scalar: TensorFlowFloatingPoint>(
      seed: TensorFlowSeed = Context.local.randomSeed
    ) -> ParameterInitializer<Scalar>
  • Gibt eine Funktion zurück, die einen Tensor erstellt, indem alle ihre Werte zufällig aus einer abgeschnittenen Normalverteilung initialisiert werden. Die erzeugten Werte folgen einer Normalverteilung mit dem Mittelwert mean und Standardabweichung standardDeviation , mit der Ausnahme , dass die Werte , deren Größe mehr als zwei Standardabweichungen vom Mittelwert werden gelöscht und neu abgetastet.

    Erklärung

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

    Parameter

    mean

    Mittelwert der Normalverteilung.

    standardDeviation

    Standardabweichung der Normalverteilung.

    Rückgabewert

    Eine abgeschnittene normale Parameterinitialisierungsfunktion.

  • Erklärung

    public func == (lhs: TFETensorHandle, rhs: TFETensorHandle) -> Bool
  • Gibt eine Identitätsmatrix oder einen Stapel von Matrizen zurück.

    Erklärung

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

    Parameter

    rowCount

    Die Anzahl der Zeilen in jeder Stapelmatrix.

    columnCount

    Die Anzahl der Spalten in jeder Stapelmatrix.

    batchShape

    Die führenden Chargendimensionen des zurückgegebenen Tensors.

  • Berechnet die Spur einer optional gestapelten Matrix. Die Kurve ist die Summe entlang der Hauptdiagonale jeder innersten Matrix.

    Die Eingabe ist ein Tensor mit der Form [..., M, N] . Die Ausgabe ist ein Tensor mit Form [...] .

    Voraussetzung

    matrix muss ein Tensor mit der Form [..., M, N] .

    Erklärung

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

    Parameter

    matrix

    Ein Tensor der Form [..., M, N] .

  • Gibt die Cholesky-Zerlegung einer oder mehrerer quadratischer Matrizen zurück.

    Die Eingabe ist ein Formtensor [..., M, M] dessen innerste 2 Dimensionen quadratische Matrizen bilden.

    Der Eingang muss symmetrisch und positiv definit sein. Für diesen Vorgang wird nur der untere dreieckige Teil der Eingabe verwendet. Der obere dreieckige Teil wird nicht gelesen.

    Die Ausgabe ist ein Tensor mit der gleichen Form wie die Eingabe, die die Cholesky-Zerlegungen für alle Eingabesubmatrizen enthält [..., :, :] .

    Erklärung

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

    Parameter

    input

    Ein Tensor der Form [..., M, M] .

  • Gibt die Lösung x an das durch Ax = b lineare Gleichungssystem zurück.

    Voraussetzung

    matrix muss ein Tensor mit der Form [..., M, M] .

    Voraussetzung

    rhs muss ein Tensor mit Form sein [..., M, K] .

    Erklärung

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

    Parameter

    matrix

    Die eingegebene Dreieckskoeffizientenmatrix, die A in Ax = b .

    rhs

    Werte auf der rechten Seite, die b in Ax = b .

    lower

    Gibt an, ob die matrix ein unteres Dreieck ( true ) oder ein oberes Dreieck ( false ) ist. Der Standardwert ist true .

    adjoint

    Wenn dies true , lösen Sie mit dem Zusatz matrix anstelle von matrix . Der Standardwert ist false .

    Rückgabewert

    Die Lösung x für das System der linearen Gleichungen, dargestellt durch Ax = b . x hat die gleiche Form wie b .

  • Berechnet den L1-Verlust zwischen expected und predicted . loss = reduction(abs(expected - predicted))

    Erklärung

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

    Parameter

    predicted

    Voraussichtliche Ausgaben eines neuronalen Netzwerks.

    expected

    Erwartete Werte, dh Ziele, die der korrekten Ausgabe entsprechen.

    reduction

    Reduzierung auf die berechneten elementweisen Verlustwerte.

  • Berechnet den L2-Verlust zwischen expected und predicted . loss = reduction(square(expected - predicted))

    Erklärung

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

    Parameter

    predicted

    Voraussichtliche Ausgaben eines neuronalen Netzwerks.

    expected

    Erwartete Werte, dh Ziele, die der korrekten Ausgabe entsprechen.

    reduction

    Reduzierung auf die berechneten elementweisen Verlustwerte.

  • Berechnet den Mittelwert der absoluten Differenz zwischen Beschriftungen und Vorhersagen. loss = mean(abs(expected - predicted))

    Erklärung

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

    Parameter

    predicted

    Voraussichtliche Ausgaben eines neuronalen Netzwerks.

    expected

    Erwartete Werte, dh Ziele, die der korrekten Ausgabe entsprechen.

  • Berechnet den Mittelwert der Fehlerquadrate zwischen Beschriftungen und Vorhersagen. loss = mean(square(expected - predicted))

    Erklärung

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

    Parameter

    predicted

    Voraussichtliche Ausgaben eines neuronalen Netzwerks.

    expected

    Erwartete Werte, dh Ziele, die der korrekten Ausgabe entsprechen.

  • Berechnet den mittleren quadratischen logarithmischen Fehler zwischen predicted und expected loss = square(log(expected) - log(predicted))

    Hinweis

    Negative Tensoreinträge werden auf 0 geklemmt, um undefiniertes logarithmisches Verhalten zu vermeiden, da log(_:) für negative Realzahlen undefiniert ist.

    Erklärung

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

    Parameter

    predicted

    Voraussichtliche Ausgaben eines neuronalen Netzwerks.

    expected

    Erwartete Werte, dh Ziele, die der korrekten Ausgabe entsprechen.

  • Berechnet den mittleren absoluten prozentualen Fehler zwischen predicted und expected . loss = 100 * mean(abs((expected - predicted) / abs(expected)))

    Erklärung

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

    Parameter

    predicted

    Voraussichtliche Ausgaben eines neuronalen Netzwerks.

    expected

    Erwartete Werte, dh Ziele, die der korrekten Ausgabe entsprechen.

  • Berechnet den Scharnierverlust zwischen predicted und expected . loss = reduction(max(0, 1 - predicted * expected)) expected Werte werden voraussichtlich -1 oder 1 sein.

    Erklärung

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

    Parameter

    predicted

    Voraussichtliche Ausgaben eines neuronalen Netzwerks.

    expected

    Erwartete Werte, dh Ziele, die der korrekten Ausgabe entsprechen.

    reduction

    Reduzierung auf die berechneten elementweisen Verlustwerte.

  • Berechnet den quadratischen Scharnierverlust zwischen predicted und expected . loss = reduction(square(max(0, 1 - predicted * expected))) expected Werte werden mit -1 oder 1 erwartet.

    Erklärung

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

    Parameter

    predicted

    Voraussichtliche Ausgaben eines neuronalen Netzwerks.

    expected

    Erwartete Werte, dh Ziele, die der korrekten Ausgabe entsprechen.

    reduction

    Reduzierung auf die berechneten elementweisen Verlustwerte.

  • Berechnet den kategorialen Scharnierverlust zwischen predicted und expected . loss = maximum(negative - positive + 1, 0) wobei negative = max((1 - expected) * predicted) und positive = sum(predicted * expected)

    Erklärung

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

    Parameter

    predicted

    Voraussichtliche Ausgaben eines neuronalen Netzwerks.

    expected

    Erwartete Werte, dh Ziele, die der korrekten Ausgabe entsprechen.

    reduction

    Reduzierung auf die berechneten elementweisen Verlustwerte.

  • Berechnet den Logarithmus des hyperbolischen Kosinus des Vorhersagefehlers. logcosh = log((exp(x) + exp(-x))/2) , wobei x der predicted - expected Fehler ist predicted - expected

    Erklärung

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

    Parameter

    predicted

    Voraussichtliche Ausgaben eines neuronalen Netzwerks.

    expected

    Erwartete Werte, dh Ziele, die der korrekten Ausgabe entsprechen.

    reduction

    Reduzierung auf die berechneten elementweisen Verlustwerte.

  • Berechnet den Poisson-Verlust zwischen vorhergesagt und erwartet Der Poisson-Verlust ist der Mittelwert der Elemente des predicted - expected * log(predicted) Tensor predicted - expected * log(predicted) .

    Erklärung

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

    Parameter

    predicted

    Voraussichtliche Ausgaben eines neuronalen Netzwerks.

    expected

    Erwartete Werte, dh Ziele, die der korrekten Ausgabe entsprechen.

    reduction

    Reduzierung auf die berechneten elementweisen Verlustwerte.

  • Berechnet den Kullback-Leibler-Divergenzverlust zwischen expected und predicted . loss = reduction(expected * log(expected / predicted))

    Erklärung

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

    Parameter

    predicted

    Voraussichtliche Ausgaben eines neuronalen Netzwerks.

    expected

    Erwartete Werte, dh Ziele, die der korrekten Ausgabe entsprechen.

    reduction

    Reduzierung auf die berechneten elementweisen Verlustwerte.

  • Berechnet die spärliche Softmax-Kreuzentropie (kategoriale Kreuzentropie) zwischen Protokollen und Beschriftungen. Verwenden Sie diese Crossentropy-Loss-Funktion, wenn zwei oder mehr Label-Klassen vorhanden sind. Wir erwarten, dass Labels als Ganzzahlen bereitgestellt werden. Es sollten # classes Gleitkommawerte pro Feature für logits und ein einzelner Gleitkommawert pro Feature für expected .

    Erklärung

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

    Parameter

    logits

    One-Hot-codierte Ausgänge von einem neuronalen Netzwerk.

    labels

    Indizes (nullindexiert) der korrekten Ausgänge.

    reduction

    Reduzierung auf die berechneten elementweisen Verlustwerte.

  • Berechnet die spärliche Softmax-Kreuzentropie (kategoriale Kreuzentropie) zwischen Protokollen und Beschriftungen. Verwenden Sie diese Crossentropy-Loss-Funktion, wenn zwei oder mehr Label-Klassen vorhanden sind. Wir erwarten, dass Beschriftungen in einer one_hot Darstellung one_hot . Pro Feature sollten # classes Gleitkommawerte vorhanden sein.

    Erklärung

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

    Parameter

    logits

    Unskalierte Protokollwahrscheinlichkeiten aus einem neuronalen Netzwerk.

    probabilities

    Wahrscheinlichkeitswerte, die der korrekten Ausgabe entsprechen. Jede Zeile muss eine gültige Wahrscheinlichkeitsverteilung sein.

    reduction

    Reduzierung auf die berechneten elementweisen Verlustwerte.

  • Berechnet die Sigmoid-Kreuzentropie (binäre Kreuzentropie) zwischen Logs und Labels. Verwenden Sie diesen Kreuzentropieverlust, wenn nur zwei Markierungsklassen vorhanden sind (angenommen 0 und 1). Für jedes Beispiel sollte es einen einzelnen Gleitkommawert pro Vorhersage geben.

    Erklärung

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

    Parameter

    logits

    Die nicht skalierte Ausgabe eines neuronalen Netzwerks.

    labels

    Ganzzahlige Werte, die der korrekten Ausgabe entsprechen.

    reduction

    Reduzierung auf die berechneten elementweisen Verlustwerte.

  • Berechnet den Huber-Verlust zwischen predicted und expected .

    Für jeden error = expected - predicted Wert x error = expected - predicted :

    • 0.5 * x^2 wenn |x| <= δ .
    • Andernfalls 0.5 * δ^2 + δ * (|x| - δ) .

    • Quelle: Wikipedia-Artikel .

    Erklärung

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

    Parameter

    predicted

    Voraussichtliche Ausgaben eines neuronalen Netzwerks.

    expected

    Erwartete Werte, dh Ziele, die der korrekten Ausgabe entsprechen.

    delta

    Ein Gleitkomma-Skalar, der den Punkt darstellt, an dem sich die Huber-Verlustfunktion von quadratisch zu linear ändert.

    reduction

    Reduzierung auf die berechneten elementweisen Verlustwerte.

  • Gibt den absoluten Wert des angegebenen Tensorelements zurück.

    Erklärung

    @differentiable
    public func abs<T>(_ x: Tensor<T>) -> Tensor<T> where T : SignedNumeric, T : TensorFlowScalar
  • Gibt den natürlichen Logarithmus des angegebenen Tensorelements zurück.

    Erklärung

    @differentiable
    public func log<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt den Basis-Zwei-Logarithmus des angegebenen Tensorelements zurück.

    Erklärung

    @differentiable
    public func log2<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt den Basis-Zehn-Logarithmus des angegebenen Tensorelements zurück.

    Erklärung

    @differentiable
    public func log10<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt den Logarithmus von 1 + x elementweise zurück.

    Erklärung

    @differentiable
    public func log1p<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt log(1 - exp(x)) Verwendung eines numerisch stabilen Ansatzes zurück.

    Erklärung

    @differentiable
    public func log1mexp<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt den Sinus des angegebenen Tensorelements zurück.

    Erklärung

    @differentiable
    public func sin<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt den Cosinus des angegebenen Tensorelements zurück.

    Erklärung

    @differentiable
    public func cos<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt die Tangente des angegebenen Tensorelements zurück.

    Erklärung

    @differentiable
    public func tan<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt den hyperbolischen Sinus des angegebenen Tensorelements zurück.

    Erklärung

    @differentiable
    public func sinh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt den hyperbolischen Cosinus des angegebenen Tensorelements zurück.

    Erklärung

    @differentiable
    public func cosh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt den hyperbolischen Tangens des angegebenen Tensorelements zurück.

    Erklärung

    @differentiable
    public func tanh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt den inversen Kosinus des angegebenen Tensorelements zurück.

    Erklärung

    @differentiable
    public func acos<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt den inversen Sinus des angegebenen Tensorelements zurück.

    Erklärung

    @differentiable
    public func asin<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt die inverse Tangente des angegebenen Tensorelements zurück.

    Erklärung

    @differentiable
    public func atan<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt den inversen hyperbolischen Cosinus des angegebenen Tensorelements zurück.

    Erklärung

    @differentiable
    public func acosh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt den inversen hyperbolischen Sinus des angegebenen Tensorelements zurück.

    Erklärung

    @differentiable
    public func asinh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt die inverse hyperbolische Tangente des angegebenen Tensorelements zurück.

    Erklärung

    @differentiable
    public func atanh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt die Quadratwurzel des angegebenen Tensorelements zurück.

    Erklärung

    @differentiable
    public func sqrt<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt die inverse Quadratwurzel des angegebenen Tensorelements zurück.

    Erklärung

    @differentiable
    public func rsqrt<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt das Exponential des angegebenen Tensorelements zurück.

    Erklärung

    @differentiable
    public func exp<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt zwei zurück, die auf die Potenz des angegebenen Tensorelements angehoben sind.

    Erklärung

    @differentiable
    public func exp2<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt zehn zurück, die in Bezug auf das angegebene Tensorelement erhöht sind.

    Erklärung

    @differentiable
    public func exp10<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt das Exponential von x - 1 elementweise zurück.

    Erklärung

    @differentiable
    public func expm1<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt die Werte des angegebenen Tensors zurück, die elementweise auf die nächste Ganzzahl gerundet sind.

    Erklärung

    @differentiable
    public func round<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt die Obergrenze des angegebenen Tensorelements zurück.

    Erklärung

    @differentiable
    public func ceil<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt den Boden des angegebenen Tensorelements zurück.

    Erklärung

    @differentiable
    public func floor<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt eine Angabe des Vorzeichens des angegebenen Tensorelements zurück. Berechnet insbesondere y = sign(x) = -1 wenn x < 0 ; 0 wenn x == 0 ; 1 wenn x > 0 .

    Erklärung

    @differentiable
    public func sign<T>(_ x: Tensor<T>) -> Tensor<T> where T : Numeric, T : TensorFlowScalar
  • Gibt das Sigmoid des angegebenen Tensorelements zurück. Berechnet insbesondere 1 / (1 + exp(-x)) .

    Erklärung

    @differentiable
    public func sigmoid<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt das log-Sigmoid des angegebenen Tensorelements zurück. Insbesondere log(1 / (1 + exp(-x))) . Für die numerische Stabilität verwenden wir -softplus(-x) .

    Erklärung

    @differentiable
    public func logSigmoid<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt den Softplus des angegebenen Tensorelements zurück. Berechnet insbesondere das log(exp(features) + 1) .

    Erklärung

    @differentiable
    public func softplus<T>(_ features: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt das Softsign des angegebenen Tensorelements zurück. Berechnet insbesondere features/ (abs(features) + 1) .

    Erklärung

    @differentiable
    public func softsign<T>(_ features: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt den Softmax des angegebenen Tensors entlang der letzten Achse zurück. Berechnet insbesondere exp(x) / exp(x).sum(alongAxes: -1) .

    Erklärung

    @differentiable
    public func softmax<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt den Softmax des angegebenen Tensors entlang der angegebenen Achse zurück. Berechnet insbesondere exp(x) / exp(x).sum(alongAxes: axis) .

    Erklärung

    @differentiable
    public func softmax<T>(_ x: Tensor<T>, alongAxis axis: Int) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt den log-softmax des angegebenen Tensorelements zurück.

    Erklärung

    @differentiable
    public func logSoftmax<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt einen Tensor durch Anwenden einer exponentiellen linearen Einheit zurück. Berechnet insbesondere exp(x) - 1 wenn <0, andernfalls x . Siehe Schnelles und genaues tiefes Netzwerklernen durch exponentielle lineare Einheiten (ELUs)

    Erklärung

    @differentiable
    public func elu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt die GELU-Aktivierungen (Gaussian Error Linear Unit) des angegebenen Tensorelements zurück.

    Insbesondere approximiert gelu xP(X <= x) , wobei P(X <= x) die kumulative Standardverteilung nach Gauß ist, indem berechnet wird: x * [0,5 * (1 + tanh [√ (2 / π) * (x +) 0,044715 * x ^ 3)])].

    Siehe Gaußsche Fehlerlineareinheiten .

    Erklärung

    @differentiable
    public func gelu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt einen Tensor zurück, indem die ReLU-Aktivierungsfunktion in Bezug auf das angegebene Tensorelement angewendet wird. Berechnet insbesondere max(0, x) .

    Erklärung

    @differentiable
    public func relu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt einen Tensor zurück, indem die ReLU6-Aktivierungsfunktion angewendet wird, nämlich min(max(0, x), 6) .

    Erklärung

    @differentiable
    public func relu6<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt einen Tensor zurück, indem die undichte ReLU-Aktivierungsfunktion in Bezug auf das angegebene Tensorelement angewendet wird. Berechnet insbesondere max(x, x * alpha) .

    Erklärung

    @differentiable(wrt: x)
    public func leakyRelu<T: TensorFlowFloatingPoint>(
      _ x: Tensor<T>,
      alpha: Double = 0.2
    ) -> Tensor<T>
  • Gibt einen Tensor zurück, indem die SeLU-Aktivierungsfunktion angewendet wird, nämlich scale * alpha * (exp(x) - 1) wenn x < 0 , und scale * x andernfalls.

    Hinweis

    Dies ist so konzipiert, dass es zusammen mit den Initialisierern der Varianzskalierungsschicht verwendet werden kann. Weitere Informationen finden Sie unter Selbstnormalisierende Neuronale Netze .

    Erklärung

    @differentiable
    public func selu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt einen Tensor durch Anwenden der Swish-Aktivierungsfunktion zurück, nämlich x * sigmoid(x) .

    Quelle: „Suche nach Aktivierungsfunktionen“ (Ramachandran et al. 2017) https://arxiv.org/abs/1710.05941

    Erklärung

    @differentiable
    public func swish<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt einen Tensor zurück, indem die Aktivierungsfunktion für harte Sigmoid Relu6(x+3)/6 , nämlich Relu6(x+3)/6 .

    Quelle: „Suche nach MobileNetV3“ (Howard et al. 2019) https://arxiv.org/abs/1905.02244

    Erklärung

    @differentiable
    public func hardSigmoid<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt einen Tensor durch Anwenden der Hard Swish-Aktivierungsfunktion zurück, nämlich x * Relu6(x+3)/6 .

    Quelle: „Suche nach MobileNetV3“ (Howard et al. 2019) https://arxiv.org/abs/1905.02244

    Erklärung

    @differentiable
    public func hardSwish<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt einen Tensor zurück, indem die x * tanh(softplus(x)) , nämlich x * tanh(softplus(x)) .

    Quelle: „Misch: Eine selbstregulierte nicht-monotone neuronale Aktivierungsfunktion“ https://arxiv.org/abs/1908.08681

    Erklärung

    @differentiable
    public func mish<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt die Leistung des ersten Tensors an den zweiten Tensor zurück.

    Erklärung

    @differentiable
    public func pow<T>(_ lhs: Tensor<T>, _ rhs: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt die Leistung des Skalars an den Tensor zurück und sendet den Skalar.

    Erklärung

    @differentiable(wrt: rhs)
    public func pow<T>(_ lhs: T, _ rhs: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt die Leistung des Tensors an den Skalar zurück und sendet den Skalar.

    Erklärung

    @differentiable(wrt: lhs)
    public func pow<T>(_ lhs: Tensor<T>, _ rhs: T) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt die Leistung des Tensors an den Skalar zurück und sendet den Skalar.

    Erklärung

    @differentiable
    public func pow<T>(_ x: Tensor<T>, _ n: Int) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt die elementweise n te Wurzel des Tensors zurück.

    Erklärung

    @differentiable
    public func root<T>(_ x: Tensor<T>, _ n: Int) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Gibt die quadratische Differenz zwischen x und y .

    Erklärung

    @differentiable
    public func squaredDifference<T>(_ x: Tensor<T>, _ y: Tensor<T>) -> Tensor<T> where T : Numeric, T : TensorFlowScalar

    Rückgabewert

    (x - y) ^ 2 .

  • Gibt das elementweise Maximum von zwei Tensoren zurück.

    Hinweis

    max unterstützt Rundfunk.

    Erklärung

    @differentiable
    public func max<T>(_ lhs: Tensor<T>, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
  • Gibt das elementweise Maximum des Skalars und des Tensors zurück und sendet den Skalar.

    Erklärung

    @differentiable(wrt: rhs)
    public func max<T>(_ lhs: T, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
  • Gibt das elementweise Maximum des Skalars und des Tensors zurück und sendet den Skalar.

    Erklärung

    @differentiable(wrt: lhs)
    public func max<T>(_ lhs: Tensor<T>, _ rhs: T) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
  • Gibt das elementweise Minimum von zwei Tensoren zurück.

    Hinweis

    min unterstützt Rundfunk.

    Erklärung

    @differentiable
    public func min<T>(_ lhs: Tensor<T>, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
  • Gibt das elementweise Minimum des Skalars und des Tensors zurück und sendet den Skalar.

    Erklärung

    @differentiable(wrt: rhs)
    public func min<T>(_ lhs: T, _ rhs: Tensor<T>) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
  • Gibt das elementweise Minimum des Skalars und des Tensors zurück und sendet den Skalar.

    Erklärung

    @differentiable(wrt: lhs)
    public func min<T>(_ lhs: Tensor<T>, _ rhs: T) -> Tensor<T> where T : Comparable, T : Numeric, T : TensorFlowScalar
  • Gibt die Kosinusähnlichkeit zwischen x und y .

    Erklärung

    @differentiable
    public func cosineSimilarity<Scalar: TensorFlowFloatingPoint>(
      _ x: Tensor<Scalar>,
      _ y: Tensor<Scalar>
    ) -> Tensor<Scalar>
  • Gibt den Kosinusabstand zwischen x und y . Der 1 - cosineSimilarity(x, y) ist definiert als 1 - cosineSimilarity(x, y) .

    Erklärung

    @differentiable
    public func cosineDistance<Scalar: TensorFlowFloatingPoint>(
      _ x: Tensor<Scalar>,
      _ y: Tensor<Scalar>
    ) -> Tensor<Scalar>
  • Führt eine Matrixmultiplikation mit einem anderen Tensor durch und erzeugt das Ergebnis.

    Erklärung

    @differentiable
    public func matmul<Scalar: Numeric>(
      _ lhs: Tensor<Scalar>,
      transposed transposeLhs: Bool = false,
      _ rhs: Tensor<Scalar>,
      transposed transposeRhs: Bool = false
    ) -> Tensor<Scalar>
  • Gibt eine 1-D-Faltung mit den angegebenen Eingaben, Filtern, Schritten und Auffüllungen zurück.

    Voraussetzung

    input muss Rang 3 .

    Voraussetzung

    filter muss Rang 3 haben.

    Erklärung

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

    Parameter

    input

    Die Eingabe.

    filter

    Der Faltungsfilter.

    stride

    Der Schritt des Gleitfilters.

    padding

    Die Polsterung für die Operation.

    dilation

    Der Dilatationsfaktor.

  • Gibt eine 2-D-Faltung mit den angegebenen Eingaben, Filtern, Schritten und Auffüllungen zurück.

    Voraussetzung

    input muss Rang 4 .

    Voraussetzung

    filter muss Rang 4 haben.

    Erklärung

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

    Parameter

    input

    Die Eingabe.

    filter

    Der Faltungsfilter.

    strides

    Die Schritte des Gleitfilters für jede Dimension der Eingabe.

    padding

    Die Polsterung für die Operation

    dilations

    Der Dilatationsfaktor für jede Dimension der Eingabe.

  • Gibt eine 2-D-transponierte Faltung mit den angegebenen Eingaben, Filtern, Schritten und Auffüllungen zurück.

    Voraussetzung

    input muss Rang 4 .

    Voraussetzung

    filter muss Rang 4 haben.

    Erklärung

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

    Parameter

    input

    Die Eingabe.

    shape

    Die Ausgabeform der Entfaltungsoperation.

    filter

    Der Faltungsfilter.

    strides

    Die Schritte des Gleitfilters für jede Dimension der Eingabe.

    padding

    Die Polsterung für die Operation

    dilations

    Der Dilatationsfaktor für jede Dimension der Eingabe.

  • Gibt eine 3-D-Faltung mit den angegebenen Eingaben, Filtern, Schritten, Polstern und Erweiterungen zurück.

    Voraussetzung

    input muss Rang 5 .

    Voraussetzung

    filter muss Rang 5 haben.

    Erklärung

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

    Parameter

    input

    Die Eingabe.

    filter

    Der Faltungsfilter.

    strides

    Die Schritte des Gleitfilters für jede Dimension der Eingabe.

    padding

    Die Polsterung für die Operation.

    dilations

    Der Dilatationsfaktor für jede Dimension der Eingabe.

  • Gibt eine 2-D-Tiefenfaltung mit den angegebenen Eingaben, Filtern, Schritten und Auffüllungen zurück.

    Voraussetzung

    input muss Rang 4 haben.

    Voraussetzung

    filter muss Rang 4 haben.

    Erklärung

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

    Parameter

    input

    Die Eingabe.

    filter

    Der Tiefenfaltungsfilter.

    strides

    Die Schritte des Gleitfilters für jede Dimension der Eingabe.

    padding

    Die Polsterung für die Operation.

  • Gibt ein 2-D-Max-Pooling mit den angegebenen Filtergrößen, Schritten und Auffüllungen zurück.

    Erklärung

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

    Parameter

    input

    Die Eingabe.

    filterSize

    Die Dimensionen des Pooling-Kernels.

    strides

    Die Schritte des Gleitfilters für jede Dimension der Eingabe.

    padding

    Die Polsterung für die Operation.

  • Gibt ein 3-D-Max-Pooling mit den angegebenen Filtergrößen, Schritten und Auffüllungen zurück.

    Erklärung

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

    Parameter

    input

    Die Eingabe.

    filterSize

    Die Dimensionen des Pooling-Kernels.

    strides

    Die Schritte des Gleitfilters für jede Dimension der Eingabe.

    padding

    Die Polsterung für die Operation.

  • Gibt ein 2-D-Durchschnittspooling mit den angegebenen Filtergrößen, Schritten und Auffüllungen zurück.

    Erklärung

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

    Parameter

    input

    Die Eingabe.

    filterSize

    Die Dimensionen des Pooling-Kernels.

    strides

    Die Schritte des Gleitfilters für jede Dimension der Eingabe.

    padding

    Die Polsterung für die Operation.

  • Gibt ein 3-D-Durchschnittspooling mit den angegebenen Filtergrößen, Schritten und Auffüllungen zurück.

    Erklärung

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

    Parameter

    input

    Die Eingabe.

    filterSize

    Die Dimensionen des Pooling-Kernels.

    strides

    Die Schritte des Gleitfilters für jede Dimension der Eingabe.

    padding

    Die Polsterung für die Operation.

  • Gibt ein 2-D-Fractional-Max-Pooling mit den angegebenen Pooling-Verhältnissen zurück.

    Hinweis: fractionalMaxPool verfügt nicht über eine XLA-Implementierung und kann daher Auswirkungen auf die Leistung haben.

    Erklärung

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

    Parameter

    input

    Ein Tensor. 4-D mit Form [batch, height, width, channels] .

    poolingRatio

    Eine Liste der Doubles . Das Pooling-Verhältnis für jede Dimension der input unterstützt derzeit nur die Zeilen- und Spaltendimension und sollte> = 1,0 sein.

    pseudoRandom

    Ein optionaler Bool . Der Standardwert ist false . Wenn true , wird die Pooling-Sequenz pseudozufällig generiert, andernfalls auf zufällige Weise.

    overlapping

    Ein optionaler Bool . Der Standardwert ist false . Bei true bedeutet true , dass beim Pooling die Werte an der Grenze benachbarter Pooling-Zellen von beiden Zellen verwendet werden.

    deterministic

    Ein optionaler Bool . Wenn true , wird ein fester Pooling-Bereich verwendet, wenn über einen fraktionalen MaxPool2D-Knoten im Berechnungsdiagramm iteriert wird.

    seed

    Ein optionaler Int64 . Der Standardwert ist 0 . Wenn der Wert ungleich Null ist, wird der Zufallszahlengenerator durch den angegebenen Startwert gesetzt.

    seed2

    Ein optionaler Int64 . Der Standardwert ist 0 . Ein zweiter Samen, um eine Samenkollision zu vermeiden.

  • Gibt eine Kopie der input bei der Werte aus der Tiefenbemaßung in räumlichen Blöcken in die Bemaßungen für Höhe und Breite verschoben werden.

    Bei einer Eingabe der Form [1, 2, 2, 1] ist beispielsweise data_format = "NHWC" und block_size = 2:

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

    This operation will output a tensor of shape [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 number of the features must be divisible by square of b .

    Erklärung

    @differentiable(wrt: input)
    public func depthToSpace<Scalar>(_ input: Tensor<Scalar>, blockSize b: Int) -> Tensor<Scalar> where Scalar : TensorFlowScalar
  • Returns a copy of input where values from the height and width dimensions are moved to the depth dimension.

    For example, given an input of shape [1, 2, 2, 1] , data_format = “NHWC” and block_size = 2:

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

    This operation will output a tensor of shape [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 .

    Erklärung

    @differentiable(wrt: input)
    public func spaceToDepth<Scalar>(_ input: Tensor<Scalar>, blockSize b: Int) -> Tensor<Scalar> where Scalar : TensorFlowScalar
  • Builds a per-weight optimizer for LARS ( https://arxiv.org/pdf/1708.03888.pdf ).

    Erklärung

    public func makeLARS(
      learningRate: Float = 0.01,
      momentum: Float = 0.9,
      trustCoefficient: Float = 0.001,
      nesterov: Bool = false,
      epsilon: Float = 0.0,
      weightDecay: Float = 0.0
    ) -> ParameterGroupOptimizer
  • Builds a SGD based per-weight optimizer.

    Erklärung

    public func makeSGD(
      learningRate: Float = 0.01,
      momentum: Float = 0,
      weightDecay: Float = 0,
      nesterov: Bool = false
    ) -> ParameterGroupOptimizer
  • Builds a per-weight optimizer for Adam with weight decay.

    Reference: “Adam - A Method for Stochastic Optimization”

    Erklärung

    public func makeAdam(
      learningRate: Float = 0.01,
      beta1: Float = 0.9,
      beta2: Float = 0.999,
      weightDecayRate: Float = 0.01,
      epsilon: Float = 1e-6
    ) -> ParameterGroupOptimizer
  • Generates a new random seed for TensorFlow.

    Erklärung

    public func randomSeedForTensorFlow(using seed: TensorFlowSeed? = nil) -> TensorFlowSeed
  • Concatenates two values.

    Erklärung

    @differentiable
    public func concatenate<T: Mergeable>(
      _ first: T,
      _ second: T
    ) -> T
  • Adds two values and produces their sum.

    Erklärung

    @differentiable
    public func sum<T: Mergeable>(
      _ first: T,
      _ second: T
    ) -> T
  • Averages two values.

    Erklärung

    @differentiable
    public func average<T: Mergeable>(
      _ first: T,
      _ second: T
    ) -> T
  • Multiplies two values.

    Erklärung

    @differentiable
    public func multiply<T: Mergeable>(
      _ first: T,
      _ second: T
    ) -> T
  • Stack two values.

    Erklärung

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

    public func PrintX10Metrics()
  • Creates a string summary of a list of training and testing stats.

    Erklärung

    public func formatStatistics(_ stats: (train: HostStatistics, test: HostStatistics)) -> String
  • Erklärung

    public func formatStatistics(train trainStats: HostStatistics, test testStats: HostStatistics)
      -> String
  • Maps a function over n threads.

    Erklärung

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