Tensor

Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.
@frozen
public struct Tensor<Scalar> where Scalar : TensorFlowScalar
extension Tensor: Collatable
extension Tensor: CopyableToDevice
extension Tensor: AnyTensor
extension Tensor: ExpressibleByArrayLiteral
extension Tensor: CustomStringConvertible
extension Tensor: CustomPlaygroundDisplayConvertible
extension Tensor: CustomReflectable
extension Tensor: TensorProtocol
extension Tensor: TensorGroup
extension Tensor: ElementaryFunctions where Scalar: TensorFlowFloatingPoint
extension Tensor: VectorProtocol where Scalar: TensorFlowFloatingPoint
extension Tensor: Mergeable where Scalar: TensorFlowFloatingPoint
035504

Ein mehrdimensionales Array von Elementen, das eine Verallgemeinerung von Vektoren und Matrizen auf potenziell höhere Dimensionen darstellt.

Der generische Parameter Scalar beschreibt die Art der Skalare im Tensor (z. B. Int32 , Float usw.).

  • Der zugrunde liegende TensorHandle .

    Hinweis

    handle ist öffentlich, um benutzerdefinierte Operationen zuzulassen, sollte jedoch normalerweise nicht verwendet werden.

    Erklärung

    public let handle: TensorHandle<Scalar>
  • Erklärung

    public init(handle: TensorHandle<Scalar>)
  • Packt die angegebene Dimension eines Rang- R Tensors in mehrere Rang (R-1) Tensoren (R-1) . Auspackt N Tensoren von diesem Tensor durch sie entlang der Chipping - axis Dimension, wobei N aus dieser Tensor der Form entnommen wird. Zum Beispiel bei einem Tensor mit der Form [A, B, C, D] :

    • Wenn axis == 0 ist der i te Tensor im zurückgegebenen Array das Slice- self[i, :, :, :] und jeder Tensor in diesem Array hat die Form [B, C, D] . (Beachten Sie, dass die entpackte Dimension im Gegensatz zu Tensor.split(numSplits:alongAxis) oder Tensor.split(sizes:alongAxis)
    • Wenn axis == 1 ist der i te Tensor im zurückgegebenen Array der Slice- value[:, i, :, :] und jeder Tensor in diesem Array hat die Form [A, C, D] .
    • Usw.

    Dies ist das Gegenteil von Tensor.init(stacking:alongAxis:) .

    Voraussetzung

    axis muss im Bereich [-rank, rank) , wobei rank der Rang der bereitgestellten Tensoren ist.

    Erklärung

    @differentiable
    public func unstacked(alongAxis axis: Int = 0) -> [Tensor]

    Parameter

    axis

    Dimension, entlang der entstapelt werden soll. Negative Werte wickeln sich um.

    Rückgabewert

    Array mit den nicht gestapelten Tensoren.

  • Teilt einen Tensor in mehrere Tensoren auf. Der Tensor ist gespalten entlang Dimension axis in count kleinere Tensoren. Dies erfordert, dass die count die shape[axis] gleichmäßig teilt.

    Beispielsweise:

    // 'value' is a tensor with shape [5, 30]
    // Split 'value' into 3 tensors along dimension 1:
    let parts = value.split(count: 3, alongAxis: 1)
    parts[0] // has shape [5, 10]
    parts[1] // has shape [5, 10]
    parts[2] // has shape [5, 10]
    

    Voraussetzung

    count muß teilen die Größe der Dimension der axis gleichmäßig.

    Voraussetzung

    axis muss im Bereich [-rank, rank) , wobei rank der Rang der bereitgestellten Tensoren ist.

    Erklärung

    @differentiable
    public func split(count: Int, alongAxis axis: Int = 0) -> [Tensor]

    Parameter

    count

    Anzahl der zu erstellenden Teilungen.

    axis

    Die Abmessung, entlang der dieser Tensor aufgeteilt werden soll. Negative Werte wickeln sich um.

    Rückgabewert

    Ein Array, das den Tensorteil enthält.

  • Teilt einen Tensor in mehrere Tensoren auf. Der Tensor ist in sizes.shape[0] aufgeteilt. sizes.shape[0] Stücke. Die Form des i ten Stücks hat die gleiche Form wie dieser Tensor, außer entlang der axis wo die Größe die sizes[i] .

    Beispielsweise:

    // 'value' is a tensor with shape [5, 30]
    // Split 'value' into 3 tensors with sizes [4, 15, 11] along dimension 1:
    let parts = value.split(sizes: Tensor<Int32>([4, 15, 11]), alongAxis: 1)
    parts[0] // has shape [5, 4]
    parts[1] // has shape [5, 15]
    parts[2] // has shape [5, 11]
    

    Voraussetzung

    Die Werte in sizes müssen bis zur Größe der Dimension hinzuzufügen axis .

    Voraussetzung

    axis muss im Bereich [-rank, rank) , wobei rank der Rang der bereitgestellten Tensoren ist.

    Erklärung

    @differentiable(wrt: self)
    public func split(sizes: Tensor<Int32>, alongAxis axis: Int = 0) -> [Tensor]

    Parameter

    sizes

    1-D-Tensor, der die Größe jeder Teilung enthält.

    axis

    Dimension, entlang der dieser Tensor geteilt werden soll. Negative Werte werden umgangen.

    Rückgabewert

    Array mit den Tensorteilen.

  • Erklärung

    @differentiable(wrt: self)
    public func split(sizes: [Int], alongAxis axis: Int = 0) -> [Tensor]
  • Gibt einen gekachelten Tensor zurück, der durch Kacheln dieses Tensors erstellt wurde.

    Dieser Konstruktor erstellt einen neuen Tensor von diesem Tensor replizierende multiples Zeiten. Die i -te Dimension des konstruierten Tensors hat self.shape[i] * multiples[i] Elemente, und die Werte dieses Tensors werden entlang der i -ten Dimension multiples[i] repliziert. Wenn Sie beispielsweise [abcd] mit [2] [abcdabcd] wird [abcdabcd] .

    Voraussetzung

    Der erwartete rank der Vielfachen muss 1 .

    Voraussetzung

    Die Form von multiples muss [tensor.rank] .

    Voraussetzung

    Alle Skalare in multiples dürfen nicht negativ sein.

    Erklärung

    @differentiable(wrt: self)
    public func tiled(multiples: [Int]) -> Tensor
  • Gibt einen gekachelten Tensor zurück, der durch Kacheln dieses Tensors erstellt wurde.

    Dieser Konstruktor erstellt einen neuen Tensor von diesem Tensor replizierende multiples Zeiten. Die i -te Dimension des konstruierten Tensors hat self.shape[i] * multiples[i] -Elemente, und die Werte dieses Tensors werden entlang der i -ten Dimension um ein multiples[i] repliziert. Wenn Sie beispielsweise [abcd] mit [2] [abcdabcd] wird [abcdabcd] .

    Voraussetzung

    Der erwartete rank der Vielfachen muss 1 .

    Voraussetzung

    Die Form von multiples muss [tensor.rank] .

    Erklärung

    @differentiable(wrt: self)
    public func tiled(multiples: Tensor<Int32>) -> Tensor
  • Umformen auf die Form des angegebenen Tensor .

    Voraussetzung

    Die Anzahl der Skalare entspricht der neuen Form.

    Erklärung

    @differentiable(wrt: self)
    public func reshaped<T>(like other: Tensor<T>) -> Tensor where T : TensorFlowScalar
  • Umformen auf die angegebene Form.

    Voraussetzung

    Die Anzahl der Skalare entspricht der neuen Form.

    Erklärung

    @differentiable(wrt: self)
    public func reshaped(to newShape: TensorShape) -> Tensor
  • Umformen auf den angegebenen Tensor der eine Form darstellt.

    Voraussetzung

    Die Anzahl der Skalare entspricht der neuen Form.

    Erklärung

    @differentiable(wrt: self)
    public func reshaped(toShape newShape: Tensor<Int32>) -> Tensor
  • Geben Sie eine Kopie des in einen 1-D- Tensor zusammengeklappten Tensors in der Reihenfolge der Hauptreihenfolge zurück.

    Erklärung

    @differentiable(wrt: self)
    public func flattened() -> Tensor
  • Gibt einen formerweiterten Tensor mit einer Dimension von 1 zurück, die an den angegebenen Formindizes eingefügt wird.

    Erklärung

    @differentiable(wrt: self)
    public func expandingShape(at axes: Int...) -> Tensor
  • Gibt einen formerweiterten Tensor mit einer Dimension von 1 zurück, die an den angegebenen Formindizes eingefügt wird.

    Erklärung

    @differentiable(wrt: self)
    public func expandingShape(at axes: [Int]) -> Tensor
  • Gibt einen ranghohen Tensor mit einer führenden Dimension von 1 zurück.

    Erklärung

    @differentiable(wrt: self)
    public func rankLifted() -> Tensor
  • Entfernt die angegebenen Abmessungen der Größe 1 aus der Form eines Tensors. Wenn keine Abmessungen angegeben sind, werden alle Abmessungen der Größe 1 entfernt.

    Erklärung

    @differentiable(wrt: self)
    public func squeezingShape(at axes: Int...) -> Tensor
  • Entfernt die angegebenen Abmessungen der Größe 1 aus der Form eines Tensors. Wenn keine Abmessungen angegeben sind, werden alle Abmessungen der Größe 1 entfernt.

    Erklärung

    @differentiable(wrt: self)
    public func squeezingShape(at axes: [Int]) -> Tensor
  • Gibt einen transponierten Tensor zurück, dessen Abmessungen in der angegebenen Reihenfolge permutiert sind.

    Erklärung

    @differentiable(wrt: self)
    public func transposed(permutation: Tensor<Int32>) -> Tensor
  • Gibt einen transponierten Tensor zurück, dessen Abmessungen in der angegebenen Reihenfolge permutiert sind.

    Erklärung

    @available(*, deprecated, renamed: "transposed(permutation:﹚")
    @differentiable(wrt: self)
    public func transposed(withPermutations permutations: Tensor<Int32>) -> Tensor
  • Gibt einen transponierten Tensor zurück, dessen Abmessungen in der angegebenen Reihenfolge permutiert sind.

    Erklärung

    @differentiable(wrt: self)
    public func transposed(permutation: [Int]) -> Tensor
  • Gibt einen transponierten Tensor zurück, dessen Abmessungen in der angegebenen Reihenfolge permutiert sind.

    Erklärung

    @available(*, deprecated, renamed: "transposed(permutation:﹚")
    @differentiable(wrt: self)
    public func transposed(withPermutations permutations: [Int]) -> Tensor
  • Gibt einen transponierten Tensor zurück, dessen Abmessungen in der angegebenen Reihenfolge permutiert sind.

    Erklärung

    @differentiable(wrt: self)
    public func transposed(permutation: Int...) -> Tensor
  • Gibt einen transponierten Tensor zurück, dessen Abmessungen in der angegebenen Reihenfolge permutiert sind.

    Erklärung

    @available(*, deprecated, renamed: "transposed(permutation:﹚")
    @differentiable(wrt: self)
    public func transposed(withPermutations permutations: Int...) -> Tensor
  • Gibt einen transponierten Tensor zurück, dessen Abmessungen in umgekehrter Reihenfolge permutiert sind.

    Erklärung

    @differentiable(wrt: self)
    public func transposed() -> Tensor
  • Gibt einen Tensor mit umgekehrten angegebenen Abmessungen zurück.

    Voraussetzung

    Jeder Wert in axes muss im Bereich -rank..<rank .

    Voraussetzung

    Die axes dürfen nicht dupliziert werden.

    Erklärung

    @differentiable(wrt: self)
    public func reversed(inAxes axes: Tensor<Int32>) -> Tensor
  • Gibt einen Tensor mit umgekehrten angegebenen Abmessungen zurück.

    Voraussetzung

    Jeder Wert in axes muss im Bereich -rank..<rank .

    Voraussetzung

    Die axes dürfen nicht dupliziert werden.

    Erklärung

    @differentiable(wrt: self)
    public func reversed(inAxes axes: [Int]) -> Tensor
  • Gibt einen Tensor mit umgekehrten angegebenen Abmessungen zurück.

    Voraussetzung

    Jeder Wert in axes muss im Bereich -rank..<rank .

    Voraussetzung

    Die axes dürfen nicht dupliziert werden.

    Erklärung

    @differentiable(wrt: self)
    public func reversed(inAxes axes: Int...) -> Tensor
  • Gibt einen verketteten Tensor entlang der angegebenen Achse zurück.

    Voraussetzung

    Die Tensoren müssen bis auf die angegebene Achse die gleichen Abmessungen haben.

    Voraussetzung

    Die Achse muss im Bereich -rank..<rank .

    Erklärung

    @differentiable
    public func concatenated(with other: Tensor, alongAxis axis: Int = 0) -> Tensor
  • Verkettungsoperator.

    Hinweis

    ++ ist ein benutzerdefinierter Operator, der in Swift nicht vorhanden ist, in Haskell / Scala jedoch. Seine Hinzufügung ist keine unbedeutende Sprachänderung und kann kontrovers sein. Das Vorhandensein / Benennen von ++ wird in einer späteren API-Entwurfsphase erörtert.

    Erklärung

    @differentiable
    public static func ++ (lhs: Tensor, rhs: Tensor) -> Tensor
  • Gibt einen Tensor zurück, indem Slices der Eingabe an indices entlang der axis gesammelt werden

    Für 0-D- indices (Skalarindizes):

    result[p_0,          ..., p_{axis-1},
           p_{axis + 1}, ..., p_{N-1}] =
    self[p_0,          ..., p_{axis-1},
         indices,
         p_{axis + 1}, ..., p_{N-1}]
    

    Für 1-D (Vektor) indices :

    result[p_0,          ..., p_{axis-1},
           i,
           p_{axis + 1}, ..., p_{N-1}] =
    self[p_0,          ..., p_{axis-1},
         indices[i],
         p_{axis + 1}, ..., p_{N-1}]
    

    Im allgemeinen Fall wird ein resultierender Tensor erzeugt, wobei:

    result[p_0,             ..., p_{axis-1},
           i_{batch\_dims}, ..., i_{M-1},
           p_{axis + 1},    ..., p_{N-1}] =
    self[p_0,             ..., p_{axis-1},
         indices[i_0,     ..., i_{M-1}],
         p_{axis + 1},    ..., p_{N-1}]
    

    Dabei ist N = self.rank und M = indices.rank .

    Die Form des resultierenden Tensors ist: self.shape[..<axis] + indices.shape + self.shape[(axis + 1)...] .

    Hinweis

    Wenn auf der CPU ein Index außerhalb des Bereichs gefunden wird, wird ein Fehler ausgegeben. Wenn auf der GPU ein Index außerhalb des Bereichs gefunden wird, wird eine 0 in den entsprechenden Ausgabewerten gespeichert.

    Voraussetzung

    axis muss im Bereich [-rank, rank) .

    Erklärung

    @differentiable(wrt: self)
    public func gathering<Index: TensorFlowIndex>(
      atIndices indices: Tensor<Index>,
      alongAxis axis: Int = 0
    ) -> Tensor

    Parameter

    indices

    Enthält die Indizes, bei denen gesammelt werden soll.

    axis

    Dimension, entlang der gesammelt werden soll. Negative Werte wickeln sich um.

    Rückgabewert

    Der versammelte Tensor.

  • Returns Scheiben dieser Tensor bei indices entlang der axis Dimension, während die ersten ignorieren batchDimensionCount Dimensionen dass entsprechen Chargenabmessungen. Das Sammeln wird entlang der ersten Nicht-Batch-Dimension durchgeführt.

    Führt ähnliche Funktionen wie das gathering , außer dass die resultierende shape[..<axis] + indices.shape[batchDimensionCount...] + shape[(axis + 1)...] jetzt shape[..<axis] + indices.shape[batchDimensionCount...] + shape[(axis + 1)...] .

    Voraussetzung

    axis muss im Bereich -rank..<rank und gleichzeitig größer oder gleich batchDimensionCount .

    Voraussetzung

    batchDimensionCount muss kleiner als indices.rank .

    Erklärung

    @differentiable(wrt: self)
    public func batchGathering<Index: TensorFlowIndex>(
      atIndices indices: Tensor<Index>,
      alongAxis axis: Int = 1,
      batchDimensionCount: Int = 1
    ) -> Tensor

    Parameter

    indices

    Enthält die zu sammelnden Indizes.

    axis

    Dimension, entlang der gesammelt werden soll. Negative Werte wickeln sich um.

    batchDimensionCount

    Anzahl der zu ignorierenden führenden Chargendimensionen.

    Rückgabewert

    Der versammelte Tensor.

  • Gibt einen Tensor zurück, indem die Werte erfasst werden, nachdem die bereitgestellte Boolesche Maske auf die Eingabe angewendet wurde.

    Beispielsweise:

    // 1-D example
    // tensor is [0, 1, 2, 3]
    // mask is [true, false, true, false]
    tensor.gathering(where: mask) // is [0, 2]
    
    // 2-D example
    // tensor is [[1, 2], [3, 4], [5, 6]]
    // mask is [true, false, true]
    tensor.gathering(where: mask) // is [[1, 2], [5, 6]]
    

    Im Allgemeinen 0 < mask.rank = K <= tensor.rank und der mask die Form , muß die ersten K Dimensionen des Spiel tensor 's Form. Wir haben dann: tensor.gathering(where: mask)[i, j1, ..., jd] = tensor[i1, ..., iK, j1, ..., jd] , wobei [i1, ..., iK] ist der i te true Eintrag der mask (Zeilen-Hauptreihenfolge).

    Die axis kann mit mask , um die Achse anzugeben, von der maskiert werden soll. In diesem Fall müssen axis + mask.rank <= tensor.rank und die 's shape must match the first der mask 's shape must match the first dimensions of the 's shape must match the first Achse + Maskenrang dimensions of the Tensorform übereinstimmen.

    Voraussetzung

    Die mask kann kein Skalar sein: mask.rank != 0 .

    Erklärung

    @differentiable(wrt: self)
    public func gathering(where mask: Tensor<Bool>, alongAxis axis: Int = 0) -> Tensor

    Parameter

    mask

    KD Boolescher Tensor, wobei K <= self.rank .

    axis

    0-D ganzzahliger Tensor, der die Achse in self , von der maskiert werden soll, wobei K + axis <= self.rank .

    Rückgabewert

    (self.rank - K + 1) -dimensionaler Tensor, (self.rank - K + 1) mit Einträgen in diesem Tensor, die den true Werten in der mask .

  • Gibt die Positionen von Nicht-Null / Wahr-Werten in diesem Tensor zurück.

    Die Koordinaten werden in einem 2D-Tensor zurückgegeben, wobei die erste Dimension (Zeilen) die Anzahl der Nicht-Null-Elemente und die zweite Dimension (Spalten) die Koordinaten der Nicht-Null-Elemente darstellt. Beachten Sie, dass die Form des Ausgangstensors abhängig von der Anzahl der tatsächlichen Werte in diesem Tensor variieren kann. Die Indizes werden in der Hauptreihenfolge ausgegeben.

    Beispielsweise:

    // 'input' is [[true, false], [true, false]]
    // 'input' has 2 true values and so the output has 2 rows.
    // 'input' has rank of 2, and so the second dimension of the output has size 2.
    input.nonZeroIndices() // is [[0, 0], [1, 0]]
    
    // 'input' is [[[ true, false], [ true, false]],
    //             [[false,  true], [false,  true]],
    //             [[false, false], [false,  true]]]
    // 'input' has 5 true values and so the output has 5 rows.
    // 'input' has rank 3, and so the second dimension of the output has size 3.
    input.nonZeroIndices() // is [[0, 0, 0],
                           //     [0, 1, 0],
                           //     [1, 0, 1],
                           //     [1, 1, 1],
                           //     [2, 1, 1]]
    

    Erklärung

    public func nonZeroIndices() -> Tensor<Int64>

    Rückgabewert

    Ein Tensor mit Form (num_true, rank(condition)) .

  • Erklärung

    @differentiable(wrt: self)
    public func broadcasted(toShape shape: Tensor<Int32>) -> Tensor
  • Erklärung

    @differentiable(wrt: self)
    public func broadcasted(to shape: TensorShape) -> Tensor
  • Broadcast in der gleichen Form wie der angegebene Tensor .

    Voraussetzung

    Die angegebene Form muss für den Rundfunk kompatibel sein.

    Erklärung

    @differentiable(wrt: self)
    public func broadcasted<OtherScalar>(like other: Tensor<OtherScalar>) -> Tensor where OtherScalar : TensorFlowScalar
  • Erklärung

    public static func .= (lhs: inout Tensor, rhs: Tensor)
  • Extrahiert für jede Dimension eine Schicht aus dem Tensor, der durch die Unter- und Obergrenze definiert ist.

    Erklärung

    @differentiable(wrt: self)
    public func slice(lowerBounds: [Int], upperBounds: [Int]) -> Tensor

    Parameter

    lowerBounds

    Die unteren Grenzen bei jeder Dimension.

    upperBounds

    Die oberen Grenzen bei jeder Dimension.

  • Erklärung

    @differentiable(wrt: self)
    public func slice(lowerBounds: Tensor<Int32>, sizes: Tensor<Int32>) -> Tensor
  • Erklärung

    @differentiable(wrt: self)
    public func slice(lowerBounds: [Int], sizes: [Int]) -> Tensor
  • Erklärung

    @differentiable(wrt: self)
    public subscript(ranges: TensorRangeExpression...) -> Tensor { get set }
  • Prüft , dass jedes Element der axes eine Achse bezeichnet self und stoppt das Programm mit einem ansonsten diagnostisch.

    Erklärung

    func ensureValid(
      axes: Tensor<Int32>,
      function: StaticString = #function,
      file: StaticString = #file,
      line: UInt = #line
    )
  • Prüft , dass jedes Element der axes eine Achse bezeichnet self und stoppt das Programm mit einem ansonsten diagnostisch.

    Erklärung

    func ensureValid(
      axes: [Int],
      function: StaticString = #function,
      file: StaticString = #file,
      line: UInt = #line
    )
  • Überprüft, ob k eine Achse des self , und stoppt das Programm ansonsten mit einer Diagnose.

    Erklärung

    func ensureValid(
      axis k: Int,
      function: StaticString = #function,
      file: StaticString = #file,
      line: UInt = #line
    )
  • Erklärung

    public init<BatchSamples: Collection>(collating samples: BatchSamples)
    where BatchSamples.Element == Self
  • Erstellt eine Kopie von other auf dem angegebenen Device .

    Erklärung

    public init(copying other: Tensor, to device: Device)
  • Erstellt einen Tensor mit der angegebenen Form und einem einzelnen, wiederholten Skalarwert.

    Erklärung

    @available(*, deprecated, renamed: "init(repeating:shape:﹚")
    public init(shape: TensorShape, repeating repeatedValue: Scalar)

    Parameter

    shape

    Die Abmessungen des Tensors.

    repeatedValue

    Der zu wiederholende Skalarwert.

  • Erstellt einen Tensor mit der angegebenen Form und einem einzelnen, wiederholten Skalarwert.

    Erklärung

    @differentiable
    public init(
      repeating repeatedValue: Scalar, shape: TensorShape,
      on device: Device = .default
    )

    Parameter

    repeatedValue

    Der zu wiederholende Skalarwert.

    shape

    Die Abmessungen des Tensors.

  • Erstellt einen Tensor, indem der angegebene Skalar an einen bestimmten Rang gesendet wird, wobei alle Dimensionen 1 sind.

    Erklärung

    public init(broadcasting scalar: Scalar, rank: Int, on device: Device = .default)
  • Erstellt einen Tensor aus einem Array von Tensoren (die selbst Skalare sein können).

    Erklärung

    @differentiable
    public init(_ elements: [Tensor])
  • Stapelt tensors entlang der axis in einen neuen Tensor, dessen Rang eins höher ist als der aktuelle Tensor und jeder Tensor in tensors .

    Wenn alle tensors die Form [A, B, C] und tensors.count = N , gilt tensors.count = N :

    • Wenn die axis == 0 ist, hat der resultierende Tensor die Form [N, A, B, C] .
    • Wenn die axis == 1 ist, hat der resultierende Tensor die Form [A, N, B, C] .
    • usw.

    Beispielsweise:

    // 'x' is [1, 4]
    // 'y' is [2, 5]
    // 'z' is [3, 6]
    Tensor(stacking: [x, y, z]) // is [[1, 4], [2, 5], [3, 6]]
    Tensor(stacking: [x, y, z], alongAxis: 1) // is [[1, 2, 3], [4, 5, 6]]
    

    Dies ist das Gegenteil von Tensor.unstacked(alongAxis:) .

    Voraussetzung

    Alle Tensoren müssen die gleiche Form haben.

    Voraussetzung

    axis muss im Bereich [-rank, rank) , wobei rank der Rang der bereitgestellten Tensoren ist.

    Erklärung

    @differentiable
    public init(stacking tensors: [Tensor], alongAxis axis: Int = 0)

    Parameter

    tensors

    Tensoren zum Stapeln.

    axis

    Dimension, entlang der gestapelt werden soll. Negative Werte wickeln sich um.

    Rückgabewert

    Der gestapelte Tensor.

  • Verkettet tensors entlang der axis .

    Wenn die tensors[i].shape = [D0, D1, ... Daxis(i), ...Dn] , hat das verkettete Ergebnis die Form [D0, D1, ... Raxis, ...Dn] , wobei Raxis = sum(Daxis(i)) . Das heißt, die Daten von den Eingangstensoren werden entlang der axis .

    Beispielsweise:

    // t1 is [[1, 2, 3], [4, 5, 6]]
    // t2 is [[7, 8, 9], [10, 11, 12]]
    Tensor(concatenating: [t1, t2]) // is [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]
    Tensor(concatenating: [t1, t2], alongAxis: 1) // is [[1, 2, 3, 7, 8, 9], [4, 5, 6, 10, 11, 12]]
    
    // t3 has shape [2, 3]
    // t4 has shape [2, 3]
    Tensor(concatenating: [t3, t4]) // has shape [4, 3]
    Tensor(concatenating: [t3, t4], alongAxis: 1) // has shape [2, 6]
    

    Hinweis

    Wenn Sie entlang einer neuen Achse verketten, sollten Sie Tensor.init(stacking:alongAxis:) entlang der Achse Tensor.init(stacking:alongAxis:) .

    Voraussetzung

    Alle Tensoren müssen den gleichen Rang haben und alle Abmessungen außer der axis müssen gleich sein.

    Voraussetzung

    axis muss im Bereich [-rank, rank) , wobei rank der Rang der bereitgestellten Tensoren ist.

    Erklärung

    @differentiable
    public init(concatenating tensors: [Tensor], alongAxis axis: Int = 0)

    Parameter

    tensors

    Tensoren zum Verketten.

    axis

    Dimension, entlang der verkettet werden soll. Negative Werte wickeln sich um.

    Rückgabewert

    Der verkettete Tensor.

  • Ersetzt Elemente dieses Tensors durch other in den Spuren, in denen die mask true .

    Voraussetzung

    self und other müssen die gleiche Form haben. Wenn self und other skalar sind, muss auch die mask skalar sein. Wenn self und other einen Rang größer oder gleich 1 , muss die mask entweder die gleiche Form wie self oder ein 1-D- Tensor so dass mask.scalarCount == self.shape[0] .

    Erklärung

    @differentiable(wrt: (self, other)
    ) public func replacing(with other: Tensor, where mask: Tensor<Bool>) -> Tensor
  • Gibt true zurück, wenn die Genauigkeit des physischen Skalartyps verringert ist.

    Derzeit enthalten physikalische BFloat16 reduzierter Genauigkeit nur BFloat16 .

    Erklärung

    public var isReducedPrecision: Bool { get }
  • Fördert einen Skalar zu einem Tensor mit der gleichen Vorrichtung und Präzision wie der angegebene Tensor.

    Erklärung

    @differentiable
    public init(_ value: Scalar, deviceAndPrecisionLike tensor: Tensor)
  • Gibt eine Kopie von self die in BFloat16 physischen BFloat16 konvertiert wurde.

    Erklärung

    public var toReducedPrecision: `Self` { get }
  • Gibt eine Kopie von self die in den physischen Skalartyp Scalar konvertiert wurde.

    Erklärung

    public var toFullPrecision: `Self` { get }
  • Die Anzahl der Dimensionen des Tensor .

    Erklärung

    public var rank: Int { get }
  • Die Form des Tensor .

    Erklärung

    public var shape: TensorShape { get }
  • Die Anzahl der Skalare im Tensor .

  • Erklärung

    public var scalarCount: Int { get }
  • Der Rang des Tensors, dargestellt als Tensor<Int32> .

    Erklärung

    public var rankTensor: Tensor<Int32> { get }
  • Die Abmessungen des Tensors, dargestellt als Tensor<Int32> .

    Erklärung

    public var shapeTensor: Tensor<Int32> { get }
  • Die Anzahl der Skalare im Tensor, dargestellt als Tensor<Int32> .

    Erklärung

    public var scalarCountTensor: Tensor<Int32> { get }
  • Gibt true wenn der rank gleich 0 ist, andernfalls false .

    Erklärung

    public var isScalar: Bool { get }
  • Gibt das einzelne Skalarelement zurück, wenn der rank gleich 0 und andernfalls nil .

    Erklärung

    public var scalar: Scalar? { get }
  • Umformung auf Skalar.

    Voraussetzung

    Der Tensor hat genau einen Skalar.

    Erklärung

    @differentiable
    public func scalarized() -> Scalar
  • Erklärung

    public var array: ShapedArray<Scalar> { get }
  • Erklärung

    @differentiable
    public var scalars: [Scalar] { get }
  • Erstellt einen 0-D-Tensor aus einem Skalarwert.

    Erklärung

    @differentiable
    public init(_ value: Scalar, on device: Device = .default)
  • Erstellt einen 1D-Tensor aus Skalaren.

    Erklärung

    @differentiable
    public init(_ scalars: [Scalar], on device: Device = .default)
  • Erstellt einen 1D-Tensor aus Skalaren.

    Erklärung

    public init<C: Collection>(
      _ vector: C, on device: Device = .default
    ) where C.Element == Scalar
  • Erstellt einen Tensor mit der angegebenen Form und zusammenhängenden Skalaren in Zeilenreihenfolge.

    Voraussetzung

    Das Produkt der Abmessungen der Form muss der Anzahl der Skalare entsprechen.

    Erklärung

    @differentiable
    public init(shape: TensorShape, scalars: [Scalar], on device: Device = .default)

    Parameter

    shape

    Die Form des Tensors.

    scalars

    Der skalare Inhalt des Tensors.

  • Erstellt einen Tensor mit der angegebenen Form und zusammenhängenden Skalaren in Zeilenreihenfolge.

    Voraussetzung

    Das Produkt der Abmessungen der Form muss der Anzahl der Skalare entsprechen.

    Erklärung

    public init(
      shape: TensorShape,
      scalars: UnsafeBufferPointer<Scalar>,
      on device: Device = .default
    )

    Parameter

    shape

    Die Form des Tensors.

    scalars

    Der skalare Inhalt des Tensors.

  • Erstellt einen Tensor mit der angegebenen Form und zusammenhängenden Skalaren in der Reihenfolge der Hauptreihenfolge.

    Voraussetzung

    Das Produkt der Abmessungen der Form muss der Anzahl der Skalare entsprechen.
  • Erstellt einen Tensor mit der angegebenen Form und zusammenhängenden Skalaren in Zeilenreihenfolge.

    Voraussetzung

    Das Produkt der Abmessungen der Form muss der Anzahl der Skalare entsprechen.

    Erklärung

    public init<C: Collection>(
      shape: TensorShape, scalars: C, on device: Device = .default
    ) where C.Element == Scalar

    Parameter

    shape

    Die Form des Tensors.

    scalars

    Der skalare Inhalt des Tensors.

  • Der Typ der Elemente eines Array-Literal.

    Erklärung

    public typealias ArrayLiteralElement = _TensorElementLiteral<Scalar>
  • Erstellt einen Tensor, der mit den angegebenen Elementen initialisiert wird.

    Erklärung

    public init(arrayLiteral elements: _TensorElementLiteral<Scalar>...)
  • Eine Textdarstellung des Tensors.

    Hinweis

    Verwenden Sie fullDescription für eine nicht hübsch gedruckte Beschreibung, in der alle Skalare fullDescription .

    Erklärung

    public var description: String { get }
  • Eine Textdarstellung des Tensors. Gibt eine zusammengefasste Beschreibung zurück, wenn die summarize wahr ist und die Elementanzahl das Doppelte der edgeElementCount überschreitet.

    Erklärung

    public func description(
      lineWidth: Int = 80,
      edgeElementCount: Int = 3,
      summarizing: Bool = false
    ) -> String

    Parameter

    lineWidth

    Die maximale Zeilenbreite zum Drucken. Wird verwendet, um die Anzahl der zu druckenden Skalare pro Zeile zu bestimmen.

    edgeElementCount

    Die maximale Anzahl von Elementen, die vor und nach der Zusammenfassung über Ellipsen ( ... ) gedruckt werden sollen.

    summarizing

    Wenn true, fassen Sie die Beschreibung zusammen, wenn die Anzahl der Elemente das doppelte edgeElementCount überschreitet.

  • Eine vollständige, nicht hübsch gedruckte Textdarstellung des Tensors mit allen Skalaren.

    Erklärung

    public var fullDescription: String { get }
  • Erklärung

    public var playgroundDescription: Any { get }
  • Erklärung

    public var customMirror: Mirror { get }
  • Die Anmerkungen, die diesen Tensor beschreiben.

    Erklärung

    public var annotations: String { get }
  • Ein Alias ​​für Anmerkungen.

    Erklärung

    public var summary: String { get }
  • Erklärung

    public init(_owning tensorHandles: UnsafePointer<CTensorHandle>?)
  • Erklärung

    public init<C: RandomAccessCollection>(
      _handles: C
    ) where C.Element: _AnyTensorHandle
  • Erklärung

    public init(_ array: ShapedArray<Scalar>, on device: Device = .default)
  • Erklärung

    init(_xla: XLATensor)
  • Erklärung

    init(_xlaHandle: UnsafeMutablePointer<OpaqueXLATensor>)
  • Erklärung

    var xlaHandle: UnsafeMutablePointer<OpaqueXLATensor> { get }
  • Erklärung

    var xlaTensor: XLATensor { get }

Verfügbar bei `Scalar`:` Numeric`

  • Erklärung

    @differentiable(wrt: self)
    public func unbroadcasted(toShape otherShape: Tensor<Int32>) -> Tensor
  • Erklärung

    @differentiable(wrt: self)
    public func unbroadcasted<OtherScalar>(like other: Tensor<OtherScalar>) -> Tensor where OtherScalar : TensorFlowScalar
  • Erklärung

    @differentiable(wrt: self)
    public func unbroadcasted(to shape: TensorShape) -> Tensor
  • Ein Modus, der vorschreibt, wie ein Tensor aufgefüllt wird.

    Erklärung

    public enum PaddingMode
  • Gibt einen Tensor zurück, der mit einer Konstante gemäß den angegebenen Polstergrößen aufgefüllt ist.

    Erklärung

    @differentiable(wrt: self)
    public func padded(forSizes sizes: [(before: Int, after: Int)], with value: Scalar = 0)
      -> Tensor
  • Gibt einen gepolsterten Tensor gemäß den angegebenen Polstergrößen und -modi zurück.

    Erklärung

    @differentiable(wrt: self)
    public func padded(forSizes sizes: [(before: Int, after: Int)], mode: PaddingMode) -> Tensor

Verfügbar bei `Scalar`:` Numeric` & `Comparable`

  • Gibt einen Tensor von Booleschen Skalaren zurück, indem lhs < rhs .

    Erklärung

    public static func .< (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
  • Gibt einen Tensor von Booleschen Skalaren zurück, indem lhs <= rhs elementweise lhs <= rhs .

    Erklärung

    public static func .<= (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
  • Gibt einen Tensor von Booleschen Skalaren zurück, indem lhs > rhs .

    Erklärung

    public static func .> (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
  • Gibt einen Tensor von Booleschen Skalaren zurück, indem lhs >= rhs elementweise lhs >= rhs .

    Erklärung

    public static func .>= (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
  • Gibt einen Tensor von Booleschen Skalaren zurück, indem lhs < rhs .

    Hinweis

    .< unterstützt Rundfunk.

    Erklärung

    public static func .< (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
  • Gibt einen Tensor von Booleschen Skalaren zurück, indem lhs <= rhs elementweise lhs <= rhs .

    Hinweis

    .<= unterstützt Rundfunk.

    Erklärung

    public static func .<= (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
  • Gibt einen Tensor von Booleschen Skalaren zurück, indem lhs > rhs .

    Hinweis

    .> unterstützt Rundfunk.

    Erklärung

    public static func .> (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
  • Gibt einen Tensor von Booleschen Skalaren zurück, indem lhs >= rhs elementweise lhs >= rhs .

    Hinweis

    .>= unterstützt Rundfunk.

    Erklärung

    public static func .>= (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
  • Gibt einen Tensor von Booleschen Skalaren zurück, indem lhs < rhs .

    Hinweis

    .< unterstützt Rundfunk.

    Erklärung

    public static func .< (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
  • Gibt einen Tensor von Booleschen Skalaren zurück, indem lhs <= rhs elementweise lhs <= rhs .

    Hinweis

    .<= unterstützt Rundfunk.

    Erklärung

    public static func .<= (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
  • Gibt einen Tensor von Booleschen Skalaren zurück, indem lhs > rhs .

    Hinweis

    .> unterstützt Rundfunk.

    Erklärung

    public static func .> (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
  • Gibt einen Tensor von Booleschen Skalaren zurück, indem lhs >= rhs elementweise lhs >= rhs .

    Hinweis

    .>= unterstützt Rundfunk.

    Erklärung

    public static func .>= (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>

Verfügbar wo `Scalar`:` Equatable`

  • Gibt einen Tensor von Booleschen Skalaren zurück, indem lhs == rhs .

    Hinweis

    .== unterstützt Rundfunk.

    Erklärung

    public static func .== (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
  • Gibt einen Tensor von Booleschen Skalaren zurück, indem lhs != rhs elementweise lhs != rhs .

    Hinweis

    .!= unterstützt Rundfunk.

    Erklärung

    public static func .!= (lhs: Tensor, rhs: Tensor) -> Tensor<Bool>
  • Gibt einen Tensor von Booleschen Skalaren zurück, indem lhs == rhs .

    Hinweis

    .== unterstützt Rundfunk.

    Erklärung

    public static func .== (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
  • Gibt einen Tensor von Booleschen Skalaren zurück, indem lhs != rhs elementweise lhs != rhs .

    Hinweis

    .!= unterstützt Rundfunk.

    Erklärung

    public static func .!= (lhs: Scalar, rhs: Tensor) -> Tensor<Bool>
  • Gibt einen Tensor von Booleschen Skalaren zurück, indem lhs == rhs .

    Hinweis

    .== unterstützt Rundfunk.

    Erklärung

    public static func .== (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
  • Gibt einen Tensor von Booleschen Skalaren zurück, indem lhs != rhs elementweise lhs != rhs .

    Hinweis

    .!= unterstützt Rundfunk.

    Erklärung

    public static func .!= (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>

Verfügbar bei `Scalar`:` TensorFlowFloatingPoint` & `Equatable`

  • Gibt einen Tensor von Booleschen Werten zurück, der angibt, ob die Elemente von self ungefähr gleich denen von other .

    Voraussetzung

    self und other müssen die gleiche Form haben.

    Erklärung

    public func elementsAlmostEqual(
      _ other: Tensor,
      tolerance: Scalar = Scalar.ulpOfOne.squareRoot()
    ) -> Tensor<Bool>

Verfügbar wo `Scalar`:` TensorFlowFloatingPoint`

  • Gibt true wenn alle Elemente des self ungefähr gleich denen des other .

    Voraussetzung

    self und other müssen die gleiche Form haben.

    Erklärung

    public func isAlmostEqual(
      to other: Tensor,
      tolerance: Scalar = Scalar.ulpOfOne.squareRoot()
    ) -> Bool

Verfügbar wo `Scalar`:` TensorFlowNumeric`

  • Führt eine Kreuzreplikationssumme für diesen Tensor aus. Die gleiche Cross-Replica-Summe muss auf jedem der anderen an der Summe beteiligten Geräte auftreten.

    Erklärung

    public mutating mutating func crossReplicaSum(_ scale: Double)

Verfügbar wo `Scalar`:` TensorFlowFloatingPoint`

Verfügbar bei `Scalar`:` Numeric`

  • Führen Sie eine elementweise Typkonvertierung von einem Bool Tensor durch.

    Erklärung

    public init(_ other: Tensor<Bool>)
  • Führen Sie eine elementweise Konvertierung von einem anderen Tensor .

    Erklärung

    @differentiable
    public init<OtherScalar>(_ other: Tensor<OtherScalar>) where OtherScalar : Numeric, OtherScalar : TensorFlowScalar

Verfügbar wo `Scalar`:` TensorFlowFloatingPoint`

Verfügbar bei `Scalar`:` Numeric`

  • Erstellt einen Tensor, bei dem alle Skalare auf Null gesetzt sind.

    Erklärung

    public init(zeros shape: TensorShape, on device: Device = .default)

    Parameter

    shape

    Form des Tensors.

  • Erstellt einen Tensor, bei dem alle Skalare auf eins gesetzt sind.

    Erklärung

    public init(ones shape: TensorShape, on device: Device = .default)

    Parameter

    shape

    Form des Tensors.

  • Erstellt einen Tensor, bei dem alle Skalare auf Null gesetzt sind und dieselbe Form und denselben Typ wie der bereitgestellte Tensor haben.

    Erklärung

    public init(zerosLike other: Tensor)

    Parameter

    other

    Tensor, dessen Form und Datentyp verwendet werden sollen.

  • Erstellt einen Tensor, bei dem alle Skalare auf einen gesetzt sind, der dieselbe Form und denselben Typ wie der bereitgestellte Tensor hat.

    Erklärung

    public init(onesLike other: Tensor)

    Parameter

    other

    Tensor, dessen Form und Datentyp verwendet werden sollen.

  • Erstellt einen 1-D-Tensor, der eine Sequenz von einem Startwert bis zu einem Endwert darstellt, diesen jedoch nicht einschließt, wobei der angegebene Betrag schrittweise überschritten wird.

    Erklärung

    public init(
      rangeFrom start: Scalar, to end: Scalar, stride: Scalar,
      on device: Device = .default
    )

    Parameter

    start

    Der Startwert, der für die Sequenz verwendet werden soll. Wenn die Sequenz Werte enthält, wird der erste start .

    end

    Ein Endwert zum Begrenzen der Sequenz. end ist niemals ein Element der resultierenden Sequenz.

    stride

    Der Betrag, der bei jeder Iteration schrittweise verwendet werden muss. stride muss positiv sein.

  • Erstellt einen 1-D-Tensor, der eine Sequenz von einem Startwert bis zu einem Endwert darstellt, diesen jedoch nicht einschließt, wobei der angegebene Betrag schrittweise überschritten wird.

    Erklärung

    public init(rangeFrom start: Tensor<Scalar>, to end: Tensor<Scalar>, stride: Tensor<Scalar>)

    Parameter

    start

    Der Startwert, der für die Sequenz verwendet werden soll. Wenn die Sequenz Werte enthält, wird der erste start .

    end

    Ein Endwert zum Begrenzen der Sequenz. end ist niemals ein Element der resultierenden Sequenz.

    stride

    Der Betrag, um den bei jeder Iteration Schritt für Schritt vorgegangen werden muss. stride muss positiv sein.

  • Erzeugt einen One-Hot-Tensor bei bestimmten Indizes. Die durch indices onValue nehmen den Wert onValue (standardmäßig 1 ) an, während alle anderen Positionen den Wert offValue (standardmäßig 0 ) offValue . Wenn der indices Rang n , hat der neue Tensor Rang n+1 . Die neue Achse wird bei Dimension erstellt axis (standardmäßig die neue Achse ist am Ende angehängt).

    Wenn indices ein Skalar sind, ist die Form des neuen Tensors ein Vektor der depth .

    Wenn indices ein Vektor von Längenmerkmalen features , lautet die Ausgabeform: Merkmale x Tiefe, wenn Achse == -1 Tiefe x Merkmale, wenn Achse == 0

    Wenn indices eine Matrix (Stapel) mit der Form [batch, features] , lautet die Ausgabeform: Stapel x Merkmale x Tiefe, wenn Achse == -1 Stapel x Tiefe x Merkmale, wenn Achse == 1 Tiefe x Stapel x Merkmale , wenn Achse == 0

    Erklärung

    public init(
      oneHotAtIndices indices: Tensor<Int32>,
      depth: Int,
      onValue: Scalar = 1,
      offValue: Scalar = 0,
      axis: Int = -1
    )

    Parameter

    indices

    Ein Tensor von Indizes.

    depth

    Ein Skalar, der die Tiefe der einen heißen Dimension definiert.

    onValue

    Ein Skalar, der den Wert an der Stelle definiert, auf die sich ein Index in indices bezieht.

    offValue

    Ein Skalar den Wert an einer Stelle zu definieren, die nicht durch einen Index in genannten indices .

    axis

    Die zu füllende Achse. Der Standardwert ist -1 , eine neue innerste Achse.

Verfügbar wo `Scalar`:` TensorFlowFloatingPoint`

  • Erstellt einen 1-D-Tensor, der eine Sequenz von einem Startwert bis einschließlich eines Endwerts darstellt, der gleichmäßig verteilt ist, um die Anzahl der angegebenen Werte zu generieren.

    Erklärung

    public init(
      linearSpaceFrom start: Scalar, to end: Scalar, count: Int, on device: Device = .default
    )

    Parameter

    start

    Der Startwert, der für die Sequenz verwendet werden soll. Wenn die Sequenz Werte enthält, ist der erste start .

    end

    Ein Endwert zum Begrenzen der Sequenz. end ist das letzte Element der resultierenden Sequenz.

    count

    Die Anzahl der Werte in der resultierenden Sequenz. count muss positiv sein.

  • Erstellt einen 1-D-Tensor, der eine Sequenz von einem Startwert bis einschließlich eines Endwerts darstellt, der gleichmäßig verteilt ist, um die Anzahl der angegebenen Werte zu generieren.

    Voraussetzung

    start , to und count müssen Tensoren sein, die einen einzelnen Skalarwert enthalten.

    Erklärung

    public init(linearSpaceFrom start: Tensor<Scalar>, to end: Tensor<Scalar>, count: Tensor<Int32>)

    Parameter

    start

    Der Startwert, der für die Sequenz verwendet werden soll. Wenn die Sequenz Werte enthält, wird der erste start .

    end

    Ein Endwert zum Begrenzen der Sequenz. end ist das letzte Element der resultierenden Sequenz.

    count

    Die Anzahl der Werte in der resultierenden Sequenz. count muss positiv sein.

Verfügbar bei `Scalar`:` TensorFlowIndex`

  • Erstellt einen Tensor mit der angegebenen Form und upperBound zufällig skalare Werte aus einer gleichmäßigen Verteilung zwischen lowerBound und upperBound .

    Erklärung

    public init(
      randomUniform shape: TensorShape,
      lowerBound: Tensor<Scalar>? = nil,
      upperBound: Tensor<Scalar>? = nil,
      seed: TensorFlowSeed = Context.local.randomSeed,
      on device: Device = .default
    )

    Parameter

    shape

    Die Abmessungen des Tensors.

    lowerBound

    Die Untergrenze der Verteilung.

    upperBound

    Die Obergrenze der Verteilung.

    seed

    Der Startwert.

Verfügbar wo `Scalar`:` TensorFlowFloatingPoint`

  • Erstellt einen Tensor mit der angegebenen Form und upperBound zufällig skalare Werte aus einer gleichmäßigen Verteilung zwischen lowerBound und upperBound .

    Erklärung

    public init(
      randomUniform shape: TensorShape,
      lowerBound: Tensor<Scalar>? = nil,
      upperBound: Tensor<Scalar>? = nil,
      seed: TensorFlowSeed = Context.local.randomSeed,
      on device: Device = .default
    )

    Parameter

    shape

    Die Abmessungen des Tensors.

    lowerBound

    Die Untergrenze der Verteilung.

    upperBound

    Die Obergrenze der Verteilung.

    seed

    Der Startwert.

  • Erstellt einen Tensor mit der angegebenen Form und wählt zufällig Skalarwerte aus einer Normalverteilung aus.

    Erklärung

    public init(
      randomNormal shape: TensorShape,
      mean: Tensor<Scalar>? = nil,
      standardDeviation: Tensor<Scalar>? = nil,
      seed: TensorFlowSeed = Context.local.randomSeed,
      on device: Device = .default
    )

    Parameter

    shape

    Die Abmessungen des Tensors.

    mean

    Der Mittelwert der Verteilung.

    standardDeviation

    Die Standardabweichung der Verteilung.

    seed

    Der Startwert.

  • Erstellt einen Tensor mit der angegebenen Form und wählt zufällig skalare Werte aus einer abgeschnittenen Normalverteilung aus.

    Erklärung

    public init(
      randomTruncatedNormal shape: TensorShape,
      mean: Tensor<Scalar>? = nil,
      standardDeviation: Tensor<Scalar>? = nil,
      seed: TensorFlowSeed = Context.local.randomSeed,
      on device: Device = .default
    )

    Parameter

    shape

    Die Abmessungen des Tensors.

    mean

    Der Mittelwert der Verteilung.

    standardDeviation

    Die Standardabweichung der Verteilung.

    seed

    Der Startwert.

Verfügbar bei `Scalar`:` TensorFlowIndex`

  • Erstellt einen Tensor durch Zeichnen von Stichproben aus einer kategorialen Verteilung.

    Erklärung

    public init<T: TensorFlowFloatingPoint>(
      randomCategorialLogits: Tensor<T>,
      sampleCount: Int32,
      seed: TensorFlowSeed = Context.local.randomSeed
    )

    Parameter

    randomCategorialLogits

    2-D-Tensor mit Form [batchSize, classCount] . Jedes Slice [i, :] :: [i, :] repräsentiert die nicht normalisierten Protokollwahrscheinlichkeiten für alle Klassen.

    sampleCount

    0-D. Anzahl der unabhängigen Stichproben, die für jede Zeilenscheibe gezogen werden sollen.

    seed

    Der Startwert.

    Rückgabewert

    2-D-Tensor mit Form [batchSize, sampleCount] . Jedes Slice [i, :] [0, classCount) [i, :] enthält die gezeichneten Klassenbeschriftungen mit dem Bereich [0, classCount) .

Verfügbar wo `Scalar`:` TensorFlowFloatingPoint`

  • Erstellt einen Tensor mit der angegebenen Form, indem eine einheitliche Glorot (Xavier) -Initialisierung durchgeführt wird.

    Es werden Zufallsstichproben aus einer gleichmäßigen Verteilung zwischen -limit und limit die vom Standard-Zufallszahlengenerator generiert wird, wobei limit sqrt(6 / (fanIn + fanOut)) und fanIn / fanOut die Anzahl der Eingabe- und Ausgabemerkmale multipliziert mit dem fanOut darstellt Feldgröße.

    Referenz: „Die Schwierigkeit verstehen, tiefe vorwärtsgerichtete neuronale Netze zu trainieren“

    Erklärung

    public init(
      glorotUniform shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed,
      on device: Device = .default
    )

    Parameter

    shape

    Die Abmessungen des Tensors.

    seed

    Der Startwert.

  • Erstellt einen Tensor mit der angegebenen Form, indem eine normale Glorot (Xavier) -Initialisierung durchgeführt wird.

    Es werden Zufallsstichproben aus einer abgeschnittenen Normalverteilung gezogen, die auf 0 zentriert ist, wobei die Standardabweichung sqrt(2 / (fanIn + fanOut)) vom Standard-Zufallszahlengenerator generiert wird, wobei fanIn / fanOut die Anzahl der Eingangs- und Ausgangsmerkmale multipliziert mit dem Empfangsfeld darstellt Größe.

    Referenz: „Die Schwierigkeit verstehen, tiefe vorwärtsgerichtete neuronale Netze zu trainieren“

    Erklärung

    public init(
      glorotNormal shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed,
      on device: Device = .default
    )

    Parameter

    shape

    Die Abmessungen des Tensors.

    seed

    Der Startwert.

  • Erstellt einen Tensor mit der angegebenen Form, indem eine gleichmäßige Initialisierung von He (Kaiming) durchgeführt wird.

    Es werden Zufallsstichproben aus einer gleichmäßigen Verteilung zwischen -limit und limit die vom Standard-Zufallszahlengenerator generiert wird, wobei limit sqrt(6 / fanIn) und fanIn die Anzahl der Eingabemerkmale multipliziert mit der Empfangsfeldgröße darstellt.

    Referenz: „Tief in Gleichrichter eintauchen: Die Leistung auf menschlicher Ebene bei der ImageNet-Klassifizierung übertreffen“

    Erklärung

    public init(
      heUniform shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed,
      on device: Device = .default
    )

    Parameter

    shape

    Die Abmessungen des Tensors.

    seed

    Der Startwert.

  • Erstellt einen Tensor mit der angegebenen Form, indem eine normale He (Kaiming) -Initialisierung durchgeführt wird.

    Es werden Zufallsstichproben aus einer abgeschnittenen Normalverteilung gezogen, die auf 0 zentriert ist, wobei die Standardabweichung sqrt(2 / fanIn)) vom Standard-Zufallszahlengenerator generiert wird, wobei fanIn die Anzahl der Eingabemerkmale multipliziert mit der Größe des Empfangsfelds darstellt.

    Referenz: „Tief in Gleichrichter eintauchen: Die Leistung auf menschlicher Ebene bei der ImageNet-Klassifizierung übertreffen“

    Erklärung

    public init(
      heNormal shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed,
      on device: Device = .default
    )

    Parameter

    shape

    Die Abmessungen des Tensors.

    seed

    Der Startwert.

  • Erstellt einen Tensor mit der angegebenen Form, indem eine einheitliche LeCun-Initialisierung durchgeführt wird.

    Es werden Zufallsstichproben aus einer gleichmäßigen Verteilung zwischen -limit und limit die vom Standard-Zufallszahlengenerator generiert wird, wobei limit sqrt(3 / fanIn) und fanIn die Anzahl der Eingabemerkmale multipliziert mit der Größe des Empfangsfelds darstellt.

    Referenz: „Effizientes BackProp“

    Erklärung

    public init(
      leCunUniform shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed,
      on device: Device = .default
    )

    Parameter

    shape

    Die Abmessungen des Tensors.

    seed

    Der Startwert.

  • Erstellt einen Tensor mit der angegebenen Form, indem die normale LeCun-Initialisierung durchgeführt wird.

    Es werden Zufallsstichproben aus einer abgeschnittenen Normalverteilung gezogen, die auf 0 zentriert ist, wobei die Standardabweichung sqrt(1 / fanIn) vom Standard-Zufallszahlengenerator generiert wird, wobei fanIn die Anzahl der Eingabemerkmale multipliziert mit der Empfangsfeldgröße darstellt.

    Referenz: „Effizientes BackProp“

    Erklärung

    public init(
      leCunNormal shape: TensorShape, seed: TensorFlowSeed = Context.local.randomSeed,
      on device: Device = .default
    )

    Parameter

    shape

    Die Abmessungen des Tensors.

    seed

    Der Startwert.

  • Erstellt eine orthogonale Matrix oder einen Tensor.

    Wenn die Form des zu initialisierenden Tensors zweidimensional ist, wird sie mit einer orthogonalen Matrix initialisiert, die aus der QR-Zerlegung einer Matrix von Zufallszahlen erhalten wird, die aus einer Normalverteilung gezogen werden. Wenn die Matrix weniger Zeilen als Spalten enthält, enthält die Ausgabe orthogonale Zeilen. Andernfalls hat die Ausgabe orthogonale Spalten.

    Wenn die Form des zu initialisierenden Tensors mehr als zweidimensional ist, wird eine Matrix aus Form [shape[0] * ... * shape[rank - 2], shape[rank - 1]] initialisiert. Die Matrix wird anschließend umgeformt, um einen Tensor der gewünschten Form zu ergeben.

    Erklärung

    public init(
      orthogonal shape: TensorShape,
      gain: Tensor<Scalar> = Tensor<Scalar>(1),
      seed: TensorFlowSeed = Context.local.randomSeed
    )

    Parameter

    shape

    Die Form des Tensors.

    gain

    Ein multiplikativer Faktor für den orthogonalen Tensor.

    seed

    Ein Tupel aus zwei ganzen Zahlen, um den Zufallszahlengenerator zu setzen.

Verfügbar wo `Scalar`:` TensorFlowNumeric`

  • Gibt den [gestapelten] diagonalen Teil eines [gestapelten] Tensors zurück. Für die Tensorinstanz der Form [..., M, N] ist die Ausgabe ein Tensor der Form [..., K] , wobei K gleich min(N, M) .

    Beispielsweise:

    // 't' is [[1, 0, 0, 0]
    //         [0, 2, 0, 0]
    //         [0, 0, 3, 0]
    //         [0, 0, 0, 4]]
    t.diagonalPart()
    // [1, 2, 3, 4]
    

    Erklärung

    @differentiable
    public func diagonalPart() -> Tensor
  • Konstruiert ein [gestapeltes] diagonales Array. Für die Tensorinstanz der Form [..., M] ist die Ausgabe ein Tensor der Form [..., M, M] .

    Beispielsweise:

    // 't' is [1, 2, 3, 4]
    
    t.diagonal()
    // [[1, 0, 0, 0]
    //  [0, 2, 0, 0]
    //  [0, 0, 3, 0]
    //  [0, 0, 0, 4]]
    

    Erklärung

    @differentiable
    public func diagonal() -> Tensor
  • Gibt self mit neuen Diagonalwerten zurück, vorausgesetzt, self ist eine optional gestapelte Matrix.

    Der zurückgegebene Tensor hat die gleiche Form und die gleichen Werte wie self , mit Ausnahme der angegebenen Diagonalen der innersten Matrizen, die durch die diagonal Werte überschrieben werden.

    Parameterdiagonale: Ein Tensor mit Rang rank - 1 der die neuen Diagonalwerte darstellt.

    Erklärung

    public func withDiagonal(_ diagonal: Tensor<Scalar>) -> Tensor
  • Erklärung

    @differentiable(wrt: self)
    public func bandPart(_ subdiagonalCount: Int, _ superdiagonalCount: Int) -> Tensor
  • Gibt eine Kopie eines innersten Tensors zurück, der durch eine zentrale Bandgrenze definiert ist. Die Ausgabe ist ein Tensor mit der gleichen Form wie die Instanz [..., :, :] .

    Beispielsweise:

    // 't' is [[ 0,  1,  2, 3]
    //         [-1,  0,  1, 2]
    //         [-2, -1,  0, 1]
    //         [-3, -2, -1, 0]]
    
    t.bandPart(1, -1)
    // [[ 0,  1,  2, 3]
    //  [-1,  0,  1, 2]
    //  [ 0, -1,  0, 1]
    //  [ 0,  0, -1, 0]]
    
    t.bandPart(2, 1)
    // [[ 0,  1,  0, 0]
    //  [-1,  0,  1, 0]
    //  [-2, -1,  0, 1]
    //  [ 0, -2, -1, 0]]
    

    Erklärung

    @differentiable
    public func bandPart(subdiagonalCount: Int, superdiagonalCount: Int) -> Tensor

    Parameter

    subdiagonalCount

    Die Anzahl der zu behaltenden Subdiagonalen. Wenn negativ, das gesamte untere Dreieck beibehalten.

    superdiagonalCount

    Die Anzahl der Superdiagonale, die beibehalten werden sollen. Wenn negativ, behalten Sie das gesamte obere Dreieck.

Verfügbar wo `Scalar`:` TensorFlowFloatingPoint`

  • Gibt die QR-Zerlegung jeder inneren Matrix im Tensor zurück, einen Tensor mit inneren orthogonalen Matrizen q und einen Tensor mit inneren oberen Dreiecksmatrizen r , so dass der Tensor gleich matmul(q, r) .

    Erklärung

    public func qrDecomposition(fullMatrices: Bool = false) -> (
      q: Tensor<Scalar>, r: Tensor<Scalar>
    )

    Parameter

    fullMatrices

    Wenn dies der true , berechnen Sie q und r voller Größe. Andernfalls berechnen Sie nur die führenden min(shape[rank - 1], shape[rank - 2]) Spalten min(shape[rank - 1], shape[rank - 2]) von q .

  • Gibt die Singularwertzerlegung von self , vorausgesetzt, self ist eine optional gestapelte Matrix.

    The singular value decomposition (SVD) of the optionally batched matrix self is values s , u , and v , such that:

    self[..., :, :] = u[..., :, :]  s[..., :, :].diagonal()  v[..., :, :].transposed()`
    

    self must be a tensor with shape […, M, N] . Let K = min(M, N)`.

    Voraussetzung

    self must be a tensor with shape [..., M, N] .

    Erklärung

    public func svd(computeUV: Bool = true, fullMatrices: Bool = false) -> (
      s: Tensor<Scalar>, u: Tensor<Scalar>?, v: Tensor<Scalar>?
    )

    Parameter

    computeUV

    If true , the left and right singular vectors are computed and returned as u and v , respectively. If false , nil values are returned as u and v .

    fullMatrices

    If true , u and v respectively have shapes [..., M, M] and [..., N, N] . If false , u and v respectively have shapes [..., M, K] and [..., K, N] . Ignored when computeUV is false.

    Rückgabewert

    • s: The singular values, with shape [..., K] . Within each vector, the singular values are sorted in descending order.
    • u: The left singular vectors.
    • v: The right singular vectors.
  • The square root of x .

    For real types, if x is negative the result is .nan . For complex types there is a branch cut on the negative real axis.

    Erklärung

    @differentiable
    public static func sqrt(_ x: `Self`) -> Tensor<Scalar>
  • The cosine of x , interpreted as an angle in radians.

    Erklärung

    @differentiable
    public static func cos(_ x: `Self`) -> Tensor<Scalar>
  • The sine of x , interpreted as an angle in radians.

    Erklärung

    @differentiable
    public static func sin(_ x: `Self`) -> Tensor<Scalar>
  • The tangent of x , interpreted as an angle in radians.

    Erklärung

    @differentiable
    public static func tan(_ x: `Self`) -> Tensor<Scalar>
  • The inverse cosine of x in radians.

    Erklärung

    @differentiable
    public static func acos(_ x: `Self`) -> Tensor<Scalar>
  • The inverse sine of x in radians.

    Erklärung

    @differentiable
    public static func asin(_ x: `Self`) -> Tensor<Scalar>
  • The inverse tangent of x in radians.

    Erklärung

    @differentiable
    public static func atan(_ x: `Self`) -> Tensor<Scalar>
  • The hyperbolic cosine of x .

    Erklärung

    @differentiable
    public static func cosh(_ x: `Self`) -> Tensor<Scalar>
  • The hyperbolic sine of x .

    Erklärung

    @differentiable
    public static func sinh(_ x: `Self`) -> Tensor<Scalar>
  • The hyperbolic tangent of x .

    Erklärung

    @differentiable
    public static func tanh(_ x: `Self`) -> Tensor<Scalar>
  • The inverse hyperbolic cosine of x .

    Erklärung

    @differentiable
    public static func acosh(_ x: `Self`) -> Tensor<Scalar>
  • The inverse hyperbolic sine of x .

    Erklärung

    @differentiable
    public static func asinh(_ x: `Self`) -> Tensor<Scalar>
  • The inverse hyperbolic tangent of x .

    Erklärung

    @differentiable
    public static func atanh(_ x: `Self`) -> Tensor<Scalar>
  • The exponential function applied to x , or e**x .

    Erklärung

    @differentiable
    public static func exp(_ x: `Self`) -> Tensor<Scalar>
  • Two raised to to power x .

    Erklärung

    @differentiable
    public static func exp2(_ x: `Self`) -> Tensor<Scalar>
  • Ten raised to to power x .

    Erklärung

    @differentiable
    public static func exp10(_ x: `Self`) -> Tensor<Scalar>
  • exp(x) - 1 evaluated so as to preserve accuracy close to zero.

    Erklärung

    @differentiable
    public static func expm1(_ x: `Self`) -> Tensor<Scalar>
  • The natural logarithm of x .

    Erklärung

    @differentiable
    public static func log(_ x: `Self`) -> Tensor<Scalar>
  • The base-two logarithm of x .

    Erklärung

    @differentiable
    public static func log2(_ x: `Self`) -> Tensor<Scalar>
  • The base-ten logarithm of x .

    Erklärung

    @differentiable
    public static func log10(_ x: `Self`) -> Tensor<Scalar>
  • log(1 + x) evaluated so as to preserve accuracy close to zero.

    Erklärung

    @differentiable
    public static func log1p(_ x: `Self`) -> Tensor<Scalar>
  • exp(y log(x)) computed without loss of intermediate precision.

    For real types, if x is negative the result is NaN, even if y has an integral value. For complex types, there is a branch cut on the negative real axis.

    Erklärung

    @differentiable
    public static func pow(_ x: `Self`, _ y: `Self`) -> Tensor<Scalar>
  • x raised to the n th power.

    The product of n copies of x .

    Erklärung

    @differentiable
    public static func pow(_ x: `Self`, _ n: Int) -> Tensor<Scalar>
  • The n th root of x .

    For real types, if x is negative and n is even, the result is NaN. For complex types, there is a branch cut along the negative real axis.

    Erklärung

    @differentiable
    public static func root(_ x: `Self`, _ n: Int) -> Tensor<Scalar>
  • Erklärung

    public typealias VectorSpaceScalar = Float
  • Erklärung

    public func scaled(by scale: Float) -> Tensor<Scalar>
  • Erklärung

    public func adding(_ scalar: Float) -> Tensor<Scalar>
  • Erklärung

    public func subtracting(_ scalar: Float) -> Tensor<Scalar>

Available where `Scalar`: `Numeric`

  • Adds the scalar to every scalar of the tensor and produces the sum.

    Erklärung

    @differentiable
    public static func + (lhs: Scalar, rhs: Tensor) -> Tensor
  • Adds the scalar to every scalar of the tensor and produces the sum.

    Erklärung

    @differentiable
    public static func + (lhs: Tensor, rhs: Scalar) -> Tensor
  • Subtracts the scalar from every scalar of the tensor and produces the difference.

    Erklärung

    @differentiable
    public static func - (lhs: Scalar, rhs: Tensor) -> Tensor
  • Subtracts the scalar from every scalar of the tensor and produces the difference

    Erklärung

    @differentiable
    public static func - (lhs: Tensor, rhs: Scalar) -> Tensor
  • Adds two tensors and stores the result in the left-hand-side variable.

    Note

    += supports broadcasting.

    Erklärung

    public static func += (lhs: inout Tensor, rhs: Tensor)
  • Adds the scalar to every scalar of the tensor and stores the result in the left-hand-side variable.

    Erklärung

    public static func += (lhs: inout Tensor, rhs: Scalar)
  • Subtracts the second tensor from the first and stores the result in the left-hand-side variable.

    Note

    -= supports broadcasting.

    Erklärung

    public static func -= (lhs: inout Tensor, rhs: Tensor)
  • Subtracts the scalar from every scalar of the tensor and stores the result in the left-hand-side variable.

    Erklärung

    public static func -= (lhs: inout Tensor, rhs: Scalar)
  • Returns the tensor produced by multiplying the two tensors.

    Note

    * supports broadcasting.

    Erklärung

    @differentiable
    public static func * (lhs: Tensor, rhs: Tensor) -> Tensor
  • Returns the tensor by multiplying it with every scalar of the tensor.

    Erklärung

    @differentiable
    public static func * (lhs: Scalar, rhs: Tensor) -> Tensor
  • Multiplies the scalar with every scalar of the tensor and produces the product.

    Erklärung

    @differentiable
    public static func * (lhs: Tensor, rhs: Scalar) -> Tensor
  • Multiplies two tensors and stores the result in the left-hand-side variable.

    Note

    *= supports broadcasting.

    Erklärung

    public static func *= (lhs: inout Tensor, rhs: Tensor)
  • Multiplies the tensor with the scalar, broadcasting the scalar, and stores the result in the left-hand-side variable.

    Erklärung

    public static func *= (lhs: inout Tensor, rhs: Scalar)
  • Returns the quotient of dividing the first tensor by the second.

    Note

    / supports broadcasting.

    Erklärung

    @differentiable
    public static func / (lhs: Tensor, rhs: Tensor) -> Tensor
  • Returns the quotient of dividing the scalar by the tensor, broadcasting the scalar.

    Erklärung

    @differentiable
    public static func / (lhs: Scalar, rhs: Tensor) -> Tensor
  • Returns the quotient of dividing the tensor by the scalar, broadcasting the scalar.

    Erklärung

    @differentiable
    public static func / (lhs: Tensor, rhs: Scalar) -> Tensor
  • Divides the first tensor by the second and stores the quotient in the left-hand-side variable.

    Erklärung

    public static func /= (lhs: inout Tensor, rhs: Tensor)
  • Divides the tensor by the scalar, broadcasting the scalar, and stores the quotient in the left-hand-side variable.

    Erklärung

    public static func /= (lhs: inout Tensor, rhs: Scalar)
  • Returns the remainder of dividing the first tensor by the second.

    Note

    % supports broadcasting.

    Erklärung

    public static func % (lhs: Tensor, rhs: Tensor) -> Tensor
  • Returns the remainder of dividing the tensor by the scalar, broadcasting the scalar.

    Erklärung

    public static func % (lhs: Tensor, rhs: Scalar) -> Tensor
  • Returns the remainder of dividing the scalar by the tensor, broadcasting the scalar.

    Erklärung

    public static func % (lhs: Scalar, rhs: Tensor) -> Tensor
  • Divides the first tensor by the second and stores the remainder in the left-hand-side variable.

    Erklärung

    public static func %= (lhs: inout Tensor, rhs: Tensor)
  • Divides the tensor by the scalar and stores the remainder in the left-hand-side variable.

    Erklärung

    public static func %= (lhs: inout Tensor, rhs: Scalar)

Available where `Scalar` == `Bool`

  • Returns !self element-wise.

    Erklärung

    public func elementsLogicalNot() -> Tensor
  • Returns self && other element-wise.

    Note

    && supports broadcasting.

    Erklärung

    public func elementsLogicalAnd(_ other: Tensor) -> Tensor
  • Returns self && other element-wise, broadcasting other .

    Erklärung

    public func elementsLogicalAnd(_ other: Scalar) -> Tensor
  • Returns self || other element-wise.

    Erklärung

    public func elementsLogicalOr(_ other: Tensor) -> Tensor
  • Returns self || other element-wise, broadcasting other .

    Erklärung

    public func elementsLogicalOr(_ other: Scalar) -> Tensor

Available where `Scalar`: `TensorFlowNumeric`

  • Returns max(min(self, max), min) .

    Erklärung

    @differentiable
    public func clipped(min: Tensor, max: Tensor) -> Tensor
  • Returns max(min(self, max), min) .

    Erklärung

    @differentiable(wrt: (self, min)
    ) public func clipped(min: Tensor, max: Scalar) -> Tensor
  • Returns max(min(self, max), min) .

    Erklärung

    @differentiable(wrt: (self, max)
    ) public func clipped(min: Scalar, max: Tensor) -> Tensor
  • Returns max(min(self, max), min) .

    Erklärung

    @differentiable(wrt: self)
    public func clipped(min: Scalar, max: Scalar) -> Tensor

Available where `Scalar`: `SignedNumeric`

  • Returns the negation of the specified tensor element-wise.

    Erklärung

    @differentiable
    public prefix static func - (rhs: Tensor) -> Tensor

Available where `Scalar`: `Numeric`

  • Erklärung

    @differentiable(wrt: self)
    public func squared() -> Tensor

Available where `Scalar`: `TensorFlowFloatingPoint`

  • Returns a boolean tensor indicating which elements of x are finite.

    Erklärung

    public var isFinite: Tensor<Bool> { get }
  • Returns a boolean tensor indicating which elements of x are infinite.

    Erklärung

    public var isInfinite: Tensor<Bool> { get }
  • Returns a boolean tensor indicating which elements of x are NaN-valued.

    Erklärung

    public var isNaN: Tensor<Bool> { get }

Available where `Scalar` == `Bool`

  • Returns true if all scalars are equal to true . Otherwise, returns false .

    Erklärung

    public func all() -> Bool
  • Returns true if any scalars are equal to true . Otherwise, returns false .

    Erklärung

    public func any() -> Bool
  • Performs a logical AND operation along the specified axes. The reduced dimensions are removed.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    public func all(squeezingAxes axes: Int...) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Performs a logical AND operation along the specified axes. The reduced dimensions are removed.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    public func any(squeezingAxes axes: Int...) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Performs a logical AND operation along the specified axes. The reduced dimensions are retained with value 1.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    public func all(alongAxes axes: Int...) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Performs a logical OR operation along the specified axes. The reduced dimensions are retained with value 1.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    public func any(alongAxes axes: Int...) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

Available where `Scalar`: `Numeric` & `Comparable`

  • Erklärung

    @differentiable
    public func min() -> Tensor
  • Erklärung

    @differentiable
    public func max() -> Tensor
  • Returns the maximum values along the specified axes. The reduced dimensions are removed.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func max(squeezingAxes axes: Tensor<Int32>) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns the maximum values along the specified axes. The reduced dimensions are removed.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func max(squeezingAxes axes: [Int]) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns the maximum values along the specified axes. The reduced dimensions are removed.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func max(squeezingAxes axes: Int...) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns the minimum values along the specified axes. The reduced dimensions are removed.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func min(squeezingAxes axes: Tensor<Int32>) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns the minimum values along the specified axes. The reduced dimensions are removed.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func min(squeezingAxes axes: [Int]) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns the minimum values along the specified axes. The reduced dimensions are removed.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func min(squeezingAxes axes: Int...) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns the indices of the maximum values along the specified axes. The reduced dimensions are removed.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    public func argmax(squeezingAxis axis: Int) -> Tensor<Int32>

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns the indices of the minimum values along the specified axes. The reduced dimensions are removed.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    public func argmin(squeezingAxis axis: Int) -> Tensor<Int32>

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns the minimum along the specified axes. The reduced dimensions are retained with value 1.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func min(alongAxes axes: Tensor<Int32>) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns the minimum along the specified axes. The reduced dimensions are retained with value 1.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func min(alongAxes axes: [Int]) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns the minimum along the specified axes. The reduced dimensions are retained with value 1.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func min(alongAxes axes: Int...) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns the minimum along the specified axes. The reduced dimensions are retained with value 1.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func max(alongAxes axes: Tensor<Int32>) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns the minimum along the specified axes. The reduced dimensions are retained with value 1.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func max(alongAxes axes: [Int]) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns the minimum along the specified axes. The reduced dimensions are retained with value 1.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func max(alongAxes axes: Int...) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns the index of the maximum value of the flattened scalars.

    Erklärung

    public func argmax() -> Tensor<Int32>
  • Returns the index of the minimum value of the flattened scalars.

    Erklärung

    public func argmin() -> Tensor<Int32>

Available where `Scalar`: `Numeric`

  • Returns the sum along the specified axes. The reduced dimensions are removed.

    Voraussetzung

    Each value in axes must be in the range -rank...rank .

    Erklärung

    @differentiable(wrt: self)
    public func sum(squeezingAxes axes: Tensor<Int32>) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns the sum along the specified axes. The reduced dimensions are removed.

    Voraussetzung

    Each value in axes must be in the range -rank...rank .

    Erklärung

    @differentiable(wrt: self)
    public func sum(squeezingAxes axes: [Int]) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns the sum along the specified axes. The reduced dimensions are removed.

    Voraussetzung

    Each value in axes must be in the range -rank...rank .

    Erklärung

    @differentiable(wrt: self)
    public func sum(squeezingAxes axes: Int...) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Erklärung

    @differentiable(wrt: self)
    public func sum() -> Tensor
  • Returns the sum along the specified axes. The reduced dimensions are retained with value 1.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func sum(alongAxes axes: Tensor<Int32>) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns the sum along the specified axes. The reduced dimensions are retained with value 1.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func sum(alongAxes axes: [Int]) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns the sum along the specified axes. The reduced dimensions are retained with value 1.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func sum(alongAxes axes: Int...) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns the product along the specified axes. The reduced dimensions are removed.

    Voraussetzung

    Each value in axes must be in the range -rank...rank .

    Erklärung

    @differentiable(wrt: self)
    public func product(squeezingAxes axes: Tensor<Int32>) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns the product along the specified axes. The reduced dimensions are removed.

    Voraussetzung

    Each value in axes must be in the range -rank...rank .

    Erklärung

    @differentiable(wrt: self)
    public func product(squeezingAxes axes: [Int]) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns the product along the specified axes. The reduced dimensions are removed.

    Voraussetzung

    Each value in axes must be in the range -rank...rank .

    Erklärung

    @differentiable(wrt: self)
    public func product(squeezingAxes axes: Int...) -> Tensor

    Parameter

    axes

    The dimensions to reduce.

  • Erklärung

    @differentiable(wrt: self)
    public func product() -> Tensor
  • Returns the product along the specified axes. The reduced dimensions are retained with value 1.

    Precondition

    Each value in axes must be in the range -rank..<rank .

    Declaration

    public func product(alongAxes axes: Tensor<Int32>) -> Tensor

    Parameter

    axes

    The dimensions to reduce.

  • Returns the product along the specified axes. The reduced dimensions are retained with value 1.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Declaration

    public func product(alongAxes axes: [Int]) -> Tensor

    Parameters

    axes

    The dimensions to reduce.

  • Returns the product along the specified axes. The reduced dimensions are retained with value 1.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    public func product(alongAxes axes: Int...) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns the arithmetic mean along the specified axes. The reduced dimensions are removed.

    Voraussetzung

    Each value in axes must be in the range -rank...rank .

    Erklärung

    @differentiable(wrt: self)
    public func mean(squeezingAxes axes: Tensor<Int32>) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns the arithmetic mean along the specified axes. The reduced dimensions are removed.

    Voraussetzung

    Each value in axes must be in the range -rank...rank .

    Erklärung

    @differentiable(wrt: self)
    public func mean(squeezingAxes axes: [Int]) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns the arithmetic mean along the specified axes. The reduced dimensions are removed.

    Voraussetzung

    Each value in axes must be in the range -rank...rank .

    Erklärung

    @differentiable(wrt: self)
    public func mean(squeezingAxes axes: Int...) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Erklärung

    @differentiable(wrt: self)
    public func mean() -> Tensor
  • Returns the arithmetic mean along the specified axes. The reduced dimensions are retained with value 1.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Declaration

    @differentiable(wrt: self)
    public func mean(alongAxes axes: Tensor<Int32>) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns the arithmetic mean along the specified axes. The reduced dimensions are retained with value 1.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func mean(alongAxes axes: [Int]) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns the arithmetic mean along the specified axes. The reduced dimensions are retained with value 1.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func mean(alongAxes axes: Int...) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns the variance along the specified axes. The reduced dimensions are removed. Does not apply Bessel's correction.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func variance(squeezingAxes axes: Tensor<Int32>) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns the variance along the specified axes. The reduced dimensions are removed. Does not apply Bessel's correction.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func variance(squeezingAxes axes: [Int]) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns the variance along the specified axes. The reduced dimensions are retained with value 1. Does not apply Bessel's correction.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func variance(squeezingAxes axes: Int...) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Erklärung

    @differentiable(wrt: self)
    public func variance() -> Tensor
  • Returns the variance along the specified axes. The reduced dimensions are retained with value 1. Does not apply Bessel's correction.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func variance(alongAxes axes: Tensor<Int32>) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns the variance along the specified axes. The reduced dimensions are retained with value 1. Does not apply Bessel's correction.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func variance(alongAxes axes: [Int]) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns the variance along the specified axes. The reduced dimensions are retained with value 1. Does not apply Bessel's correction.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func variance(alongAxes axes: Int...) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns the cumulative sum of this tensor along the specified axis. By default, this function performs an inclusive cumulative sum which means that the first element of the input is identical to the first element of the output:

    Tensor<Float>([a, b, c]).cumulativeSum() = Tensor<Float>([a, a + b, a + b + c])
    

    By setting the exclusive argument to true , an exclusive cumulative sum is performed instead:

    Tensor<Float>([a, b, c]).cumulativeSum(exclusive: true) = Tensor<Float>([0, a, a + b])
    

    By setting the reverse argument to true , the cumulative sum is performed in the opposite direction:

    Tensor<Float>([a, b, c]).cumulativeSum(reverse: true) ==
        Tensor<Float>([a + b + c, a + b, a])
    

    This is more efficient than separately reversing the resulting tensor.

    Voraussetzung

    axis must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func cumulativeSum(
      alongAxis axis: Int,
      exclusive: Bool = false,
      reverse: Bool = false
    ) -> Tensor

    Parameter

    axis

    Axis along which to perform the cumulative sum operation.

    exclusive

    Indicates whether to perform an exclusive cumulative sum.

    reverse

    Indicates whether to perform the cumulative sum in reversed order.

    Rückgabewert

    Result of the cumulative sum operation.

  • Returns the cumulative sum of this tensor along the specified axis. By default, this function performs an inclusive cumulative sum which means that the first element of the input is identical to the first element of the output:

    Tensor<Float>([a, b, c]).cumulativeSum() = Tensor<Float>([a, a + b, a + b + c])
    

    By setting the exclusive argument to true , an exclusive cumulative sum is performed instead:

    Tensor<Float>([a, b, c]).cumulativeSum(exclusive: true) = Tensor<Float>([0, a, a + b])
    

    By setting the reverse argument to true , the cumulative sum is performed in the opposite direction:

    Tensor<Float>([a, b, c]).cumulativeSum(reverse: true) ==
        Tensor<Float>([a + b + c, a + b, a])
    

    This is more efficient than separately reversing the resulting tensor.

    Voraussetzung

    axis.rank must be 0 .

    Voraussetzung

    axis must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func cumulativeSum(
      alongAxis axis: Tensor<Int32>,
      exclusive: Bool = false,
      reverse: Bool = false
    ) -> Tensor

    Parameter

    axis

    Axis along which to perform the cumulative sum operation.

    exclusive

    Indicates whether to perform an exclusive cumulative sum.

    reverse

    Indicates whether to perform the cumulative sum in reversed order.

    Rückgabewert

    Result of the cumulative sum operation.

  • Returns the cumulative product of this tensor along the specified axis. By default, this function performs an inclusive cumulative product which means that the first element of the input is identical to the first element of the output:

    Tensor<Float>([a, b, c]).cumulativeProduct() = Tensor<Float>([a, a * b, a * b * c])
    

    By setting the exclusive argument to true , an exclusive cumulative product is performed instead:

    Tensor<Float>([a, b, c]).cumulativeProduct(exclusive: true) = Tensor<Float>([1, a, a * b])
    

    By setting the reverse argument to true , the cumulative product is performed in the opposite direction:

    Tensor<Float>([a, b, c]).cumulativeProduct(reverse: true) ==
        Tensor<Float>([a * b * c, a * b, a])
    

    This is more efficient than separately reversing the resulting tensor.

    Voraussetzung

    axis must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func cumulativeProduct(
      alongAxis axis: Int,
      exclusive: Bool = false,
      reverse: Bool = false
    ) -> Tensor

    Parameter

    axis

    Axis along which to perform the cumulative product operation.

    exclusive

    Indicates whether to perform an exclusive cumulative product.

    reverse

    Indicates whether to perform the cumulative product in reversed order.

    Rückgabewert

    Result of the cumulative product operation.

  • Returns the cumulative product of this tensor along the specified axis. By default, this function performs an inclusive cumulative product which means that the first element of the input is identical to the first element of the output:

    Tensor<Float>([a, b, c]).cumulativeProduct() = Tensor<Float>([a, a * b, a * b * c])
    

    By setting the exclusive argument to true , an exclusive cumulative product is performed instead:

    Tensor<Float>([a, b, c]).cumulativeProduct(exclusive: true) = Tensor<Float>([1, a, a * b])
    

    By setting the reverse argument to true , the cumulative product is performed in the opposite direction:

    Tensor<Float>([a, b, c]).cumulativeProduct(reverse: true) ==
        Tensor<Float>([a * b * c, a * b, a])
    

    This is more efficient than separately reversing the resulting tensor.

    Voraussetzung

    axis must have rank 0 .

    Voraussetzung

    axis must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func cumulativeProduct(
      alongAxis axis: Tensor<Int32>,
      exclusive: Bool = false,
      reverse: Bool = false
    ) -> Tensor

    Parameter

    axis

    Axis along which to perform the cumulative product operation.

    exclusive

    Indicates whether to perform an exclusive cumulative product.

    reverse

    Indicates whether to perform the cumulative product in reversed order.

    Rückgabewert

    Result of the cumulative product operation.

Available where `Scalar`: `TensorFlowFloatingPoint`

  • Returns the standard deviation of the elements along the specified axes. The reduced dimensions are retained with value 1 . Does not apply Bessel's correction.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func standardDeviation(squeezingAxes axes: Tensor<Int32>) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns the standard deviation of the elements along the specified axes. The reduced dimensions are retained with value 1 . Does not apply Bessel's correction.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func standardDeviation(squeezingAxes axes: [Int]) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns the standard deviation of the elements along the specified axes. The reduced dimensions are retained with value 1 . Does not apply Bessel's correction.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func standardDeviation(squeezingAxes axes: Int...) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns the standard deviation of all elements in this tensor. Does not apply Bessel's correction.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func standardDeviation() -> Tensor
  • Returns the standard deviation of the elements along the specified axes. The reduced dimensions are retained with value 1 . Does not apply Bessel's correction.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func standardDeviation(alongAxes axes: Tensor<Int32>) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns the standard deviation of the elements along the specified axes. The reduced dimensions are retained with value 1 . Does not apply Bessel's correction.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func standardDeviation(alongAxes axes: [Int]) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns the standard deviation of the elements along the specified axes. The reduced dimensions are retained with value 1 . Does not apply Bessel's correction.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func standardDeviation(alongAxes axes: Int...) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns log(exp(self).sum(squeezingAxes: axes)) . The reduced dimensions are removed.

    This function is more numerically stable than computing log(exp(self).sum(squeezingAxes: axes)) directly. It avoids overflows caused by computing the exp of large inputs and underflows caused by computing the log of small inputs.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func logSumExp(squeezingAxes axes: Tensor<Int32>) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns log(exp(self).sum(squeezingAxes: axes)) . The reduced dimensions are removed.

    This function is more numerically stable than computing log(exp(self).sum(squeezingAxes: axes)) directly. It avoids overflows caused by computing the exp of large inputs and underflows caused by computing the log of small inputs.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func logSumExp(squeezingAxes axes: [Int]) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns log(exp(self).sum(squeezingAxes: axes)) . The reduced dimensions are removed.

    This function is more numerically stable than computing log(exp(self).sum(squeezingAxes: axes)) directly. It avoids overflows caused by computing the exp of large inputs and underflows caused by computing the log of small inputs.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func logSumExp(squeezingAxes axes: Int...) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns log(exp(self).sum()) . The result is a scalar.

    This function is more numerically stable than computing log(exp(self).sum()) directly. It avoids overflows caused by computing the exp of large inputs and underflows caused by computing the log of small inputs.

    Erklärung

    @differentiable(wrt: self)
    public func logSumExp() -> Tensor
  • Returns log(exp(self).sum(alongAxes: axes)) . The reduced dimensions are retained with value 1 .

    This function is more numerically stable than computing log(exp(self).sum(alongAxes: axes)) directly. It avoids overflows caused by computing the exp of large inputs and underflows caused by computing the log of small inputs.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func logSumExp(alongAxes axes: Tensor<Int32>) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns log(exp(self).sum(alongAxes: axes)) . The reduced dimensions are retained with value 1 .

    This function is more numerically stable than computing log(exp(self).sum(alongAxes: axes)) directly. It avoids overflows caused by computing the exp of large inputs and underflows caused by computing the log of small inputs.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func logSumExp(alongAxes axes: [Int]) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns log(exp(self).sum(alongAxes: axes)) . The reduced dimensions are retained with value 1 .

    This function is more numerically stable than computing log(exp(self).sum(alongAxes: axes)) directly. It avoids overflows caused by computing the exp of large inputs and underflows caused by computing the log of small inputs.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func logSumExp(alongAxes axes: Int...) -> Tensor

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns the mean and variance of this tensor along the specified axes. The reduced dimensions are removed.

    Voraussetzung

    axes must have rank 1 .

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func moments(squeezingAxes axes: Tensor<Int32>) -> Moments<Scalar>

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns the mean and variance of this tensor along the specified axes. The reduced dimensions are removed.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func moments(squeezingAxes axes: [Int]) -> Moments<Scalar>

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns the mean and variance of this tensor along the specified axes. The reduced dimensions are removed.

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func moments(squeezingAxes axes: Int...) -> Moments<Scalar>

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns the mean and variance of this tensor's elements.

    Erklärung

    @differentiable(wrt: self)
    public func moments() -> Moments<Scalar>
  • Returns the mean and variance of this tensor along the specified axes. The reduced dimensions are retained with value 1 .

    Voraussetzung

    axes must have rank 1 .

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func moments(alongAxes axes: Tensor<Int32>) -> Moments<Scalar>

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns the mean and variance of this tensor along the specified axes. The reduced dimensions are retained with value 1 .

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func moments(alongAxes axes: [Int]) -> Moments<Scalar>

    Parameter

    axes

    Die Abmessungen zu reduzieren.

  • Returns the mean and variance of this tensor along the specified axes. The reduced dimensions are retained with value 1 .

    Voraussetzung

    Each value in axes must be in the range -rank..<rank .

    Erklärung

    @differentiable(wrt: self)
    public func moments(alongAxes axes: Int...) -> Moments<Scalar>

    Parameter

    axes

    Die Abmessungen zu reduzieren.

Available where `Scalar`: `Numeric`

  • Performs matrix multiplication between two tensors and produces the result.

    Erklärung

    @differentiable
    public static func  (lhs: Tensor, rhs: Tensor) -> Tensor

Available where `Scalar`: `TensorFlowFloatingPoint`

  • Erklärung

    static func vjpInitDeviceAndPrecisionLike(
      _ value: Scalar,
      deviceAndPrecisionLike tensor: Tensor
    ) -> (value: Tensor, pullback: (Tensor) -> (Scalar, Tensor))
  • Returns a tensor computed from batch-normalizing the input along the specified axis.

    Specifically, returns (self - mu) / (var + epsilon) * gamma + beta where mu and var are respectively the mean and variance of self along axis .

    Erklärung

    @differentiable(wrt: (self, offset, scale)
    public func batchNormalized(
      alongAxis axis: Int,
      offset: Tensor = Tensor(0),
      scale: Tensor = Tensor(1),
      epsilon: Scalar = 0.001
    ) -> Tensor

    Parameter

    axis

    The batch dimension.

    offset

    The offset, also known as beta.

    scale

    The scale, also known as gamma.

    epsilon

    A small value added to the denominator for numerical stability.

  • Concatenates two tensors along last axis.

    Erklärung

    @differentiable
    public static func concatenate(_ lhs: Tensor, _ rhs: Tensor) -> Tensor
  • Adds two values and produces their sum.

    Erklärung

    @differentiable
    public static func sum(_ lhs: Tensor, _ rhs: Tensor) -> Tensor
  • Averages two values.

    Erklärung

    @differentiable
    public static func average(_ lhs: Tensor, _ rhs: Tensor) -> Tensor
  • Multiplies two values.

    Erklärung

    @differentiable
    public static func multiply(_ lhs: Tensor, _ rhs: Tensor) -> Tensor
  • Stack two values.

    Erklärung

    @differentiable
    public static func stack(_ lhs: Tensor, _ rhs: Tensor) -> Tensor
  • Erklärung

    @derivative
    init(shape: scalars)

Available where `Scalar`: `Equatable`

  • Erklärung

    public static func == (lhs: Tensor, rhs: Tensor) -> Bool
  • Erklärung

    public static func != (lhs: Tensor, rhs: Tensor) -> Bool

Available where `Scalar`: `Codable`

  • Erklärung

    public func encode(to encoder: Encoder) throws
  • Erklärung

    public init(from decoder: Decoder) throws

Available where `Scalar`: `Numeric`

  • The scalar zero tensor.

  • Erklärung

    public static var zero: Tensor { get }
  • Adds two tensors and produces their sum.

    Note

    + supports broadcasting.

    Erklärung

    @differentiable
    public static func + (lhs: Tensor, rhs: Tensor) -> Tensor
  • Subtracts one tensor from another and produces their difference.

    Note

    - supports broadcasting.

    Erklärung

    @differentiable
    public static func - (lhs: Tensor, rhs: Tensor) -> Tensor
  • one

    The scalar one tensor.

    Erklärung

    public static var one: Tensor { get }
  • Returns the element-wise reciprocal of self .

    Erklärung

    public var reciprocal: Tensor { get }
  • Multiplies two tensors element-wise and produces their product.

    Note

    .* supports broadcasting.

    Erklärung

    public static func .* (lhs: Tensor, rhs: Tensor) -> Tensor

Available where `Scalar`: `TensorFlowFloatingPoint`

  • Erklärung

    public typealias TangentVector = Tensor
  • Erklärung

    public var zeroTangentVectorInitializer: () -> TangentVector { get }
  • Adds an annotation.

    Note: Only X10 is supported. For other backends, umodified self is returned.

    Erklärung

    @differentiable(wrt: self)
    public func annotate(_ annotation: String) -> Tensor<Scalar>

    Parameter

    annotation

    The annotation to be added.

    Rückgabewert

    The annotated tensor.

  • Erklärung

    @derivative
    func vjpAnnotate(_ annotation: String) -> (
      value: Tensor<Scalar>, pullback: (Tensor<Scalar>) -> Tensor<Scalar>
    )