Tensor 

@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
extension Tensor: Equatable where Scalar: Equatable
extension Tensor: Codable where Scalar: Codable
extension Tensor: AdditiveArithmetic where Scalar: Numeric
extension Tensor: PointwiseMultiplicative where Scalar: Numeric
extension Tensor: Differentiable & EuclideanDifferentiable where Scalar: TensorFlowFloatingPoint
extension Tensor: DifferentiableTensorProtocol
where Scalar: TensorFlowFloatingPoint

Wielowymiarowa tablica elementów będąca uogólnieniem wektorów i macierzy na potencjalnie wyższe wymiary.

Parametr ogólny Scalar opisuje typ skalarów w tensorze (taki jak Int32 , Float itp.).

  • Podstawowy TensorHandle .

    Notatka

    handle jest publiczny, aby umożliwić operacje zdefiniowane przez użytkownika, ale zwykle nie powinien być używany.

    Deklaracja 

    public let handle: TensorHandle<Scalar>

  • Deklaracja 

    public init(handle: TensorHandle<Scalar>)

  • Rozpakowuje dany wymiar tensora rangi R na wiele tensorów rangi (R-1) . Rozpakowuje N tensorów z tego tensora, dzieląc go wzdłuż wymiaru axis , gdzie N wynika z kształtu tego tensora. Na przykład, biorąc pod uwagę tensor o kształcie [A, B, C, D] :

    • Jeśli axis == 0 , to i -ty tensor w zwróconej tablicy jest self[i, :, :, :] i każdy tensor w tej tablicy będzie miał kształt [B, C, D] . (Zauważ, że wymiar rozpakowany wzdłuż zniknął, w przeciwieństwie do Tensor.split(numSplits:alongAxis) lub Tensor.split(sizes:alongAxis) ).
    • Jeśli axis == 1 , to i -ty tensor w zwróconej tablicy jest value[:, i, :, :] i każdy tensor w tej tablicy będzie miał kształt [A, C, D] .
    • Itp.

    Jest to przeciwieństwo Tensor.init(stacking:alongAxis:) .

    Warunek wstępny

    axis musi należeć do zakresu [-rank, rank) , gdzie rank jest rangą podanych tensorów.

    Deklaracja 

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

    Parametry

    axis

    Wymiar wzdłuż którego należy rozpakować. Wartości ujemne zawijają się.

    Wartość zwracana

    Tablica zawierająca nieskumulowane tensory.

  • Dzieli tensor na wiele tensorów. Tensor jest dzielony wzdłuż axis wymiaru count mniejsze tensory. Wymaga to, aby count równomiernie dzieliła shape[axis] .

    Na przykład: 

    // '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]

    Warunek wstępny

    count musi równomiernie dzielić rozmiar axis wymiaru.

    Warunek wstępny

    axis musi należeć do zakresu [-rank, rank) , gdzie rank jest rangą podanych tensorów.

    Deklaracja 

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

    Parametry

    count

    Liczba podziałów do utworzenia.

    axis

    Wymiar, wzdłuż którego należy podzielić ten tensor. Wartości ujemne zawijają się.

    Wartość zwracana

    Tablica zawierająca część tensorową.

  • Dzieli tensor na wiele tensorów. Tensor jest podzielony na części sizes.shape[0] . Kształt i -tego elementu ma taki sam kształt jak ten tensor, z wyjątkiem wzdłuż axis wymiaru, gdzie rozmiar wynosi sizes[i] .

    Na przykład: 

    // '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]

    Warunek wstępny

    Wartości w sizes muszą się sumować do rozmiaru axis wymiaru.

    Warunek wstępny

    axis musi należeć do zakresu [-rank, rank) , gdzie rank jest rangą podanych tensorów.

    Deklaracja 

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

    Parametry

    sizes

    Tensor 1-D zawierający rozmiar każdego podziału.

    axis

    Wymiar, wzdłuż którego należy podzielić tensor. Wartości ujemne zawijają się.

    Wartość zwracana

    Tablica zawierająca części tensorowe.

  • Deklaracja 

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

  • Zwraca tensor kafelkowy skonstruowany przez ułożenie tego tensora kafelkowo.

    Konstruktor ten tworzy nowy tensor poprzez multiples replikację tensora. Skonstruowany i -ty wymiar tensora ma elementy self.shape[i] * multiples[i] , a wartości tego tensora są replikowane multiples[i] razy wzdłuż i -tego wymiaru. Na przykład ułożenie [abcd] przez [2] daje [abcdabcd] .

    Warunek wstępny

    Oczekiwana rank wielokrotności musi wynosić 1 .

    Warunek wstępny

    Kształt multiples musi mieć postać [tensor.rank] .

    Warunek wstępny

    Wszystkie skalary będące multiples muszą być nieujemne.

    Deklaracja 

    @differentiable(wrt: self)
public func tiled(multiples: [Int]) -> Tensor

  • Zwraca tensor kafelkowy skonstruowany przez ułożenie tego tensora kafelkowo.

    Konstruktor ten tworzy nowy tensor poprzez multiples replikację tensora. Skonstruowany i -ty wymiar tensora ma elementy self.shape[i] * multiples[i] , a wartości tego tensora są replikowane multiples[i] razy wzdłuż i -tego wymiaru. Na przykład ułożenie [abcd] przez [2] daje [abcdabcd] .

    Warunek wstępny

    Oczekiwana rank wielokrotności musi wynosić 1 .

    Warunek wstępny

    Kształt multiples musi mieć postać [tensor.rank] .

    Deklaracja 

    @differentiable(wrt: self)
public func tiled(multiples: Tensor<Int32>) -> Tensor

  • Zmień kształt na kształt określonego Tensor .

    Warunek wstępny

    Liczba skalarów odpowiada nowemu kształtowi.

    Deklaracja 

    @differentiable(wrt: self)
public func reshaped<T>(like other: Tensor<T>) -> Tensor where T : TensorFlowScalar

  • Zmień kształt na określony.

    Warunek wstępny

    Liczba skalarów odpowiada nowemu kształtowi.

    Deklaracja 

    @differentiable(wrt: self)
public func reshaped(to newShape: TensorShape) -> Tensor

  • Zmień kształt na określony Tensor reprezentujący kształt.

    Warunek wstępny

    Liczba skalarów odpowiada nowemu kształtowi.

    Deklaracja 

    @differentiable(wrt: self)
public func reshaped(toShape newShape: Tensor<Int32>) -> Tensor

  • Zwróć kopię tensora zwiniętą w Tensor 1-D, w kolejności od głównych wierszy.

    Deklaracja 

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

  • Zwraca Tensor o rozszerzonym kształcie z wymiarem 1 wstawionym w określonych indeksach kształtu.

    Deklaracja 

    @differentiable(wrt: self)
public func expandingShape(at axes: Int...) -> Tensor

  • Zwraca Tensor o rozszerzonym kształcie z wymiarem 1 wstawionym w określonych indeksach kształtu.

    Deklaracja 

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

  • Zwraca Tensor o podniesionym rankingu z wymiarem wiodącym równym 1.

    Deklaracja 

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

  • Usuwa określone wymiary rozmiaru 1 z kształtu tensora. Jeśli nie zostaną określone żadne wymiary, wówczas wszystkie wymiary rozmiaru 1 zostaną usunięte.

    Deklaracja 

    @differentiable(wrt: self)
public func squeezingShape(at axes: Int...) -> Tensor

  • Usuwa określone wymiary rozmiaru 1 z kształtu tensora. Jeśli nie zostaną określone żadne wymiary, wówczas wszystkie wymiary rozmiaru 1 zostaną usunięte.

    Deklaracja 

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

  • Zwraca transponowany tensor z wymiarami permutowanymi w określonej kolejności.

    Deklaracja 

    @differentiable(wrt: self)
public func transposed(permutation: Tensor<Int32>) -> Tensor

  • Zwraca transponowany tensor z wymiarami permutowanymi w określonej kolejności.

    Deklaracja 

    @available(*, deprecated, renamed: "transposed(permutation:﹚")
@differentiable(wrt: self)
public func transposed(withPermutations permutations: Tensor<Int32>) -> Tensor

  • Zwraca transponowany tensor z wymiarami permutowanymi w określonej kolejności.

    Deklaracja 

    @differentiable(wrt: self)
public func transposed(permutation: [Int]) -> Tensor

  • Zwraca transponowany tensor z wymiarami permutowanymi w określonej kolejności.

    Deklaracja 

    @available(*, deprecated, renamed: "transposed(permutation:﹚")
@differentiable(wrt: self)
public func transposed(withPermutations permutations: [Int]) -> Tensor

  • Zwraca transponowany tensor z wymiarami permutowanymi w określonej kolejności.

    Deklaracja 

    @differentiable(wrt: self)
public func transposed(permutation: Int...) -> Tensor

  • Zwraca transponowany tensor z wymiarami permutowanymi w określonej kolejności.

    Deklaracja 

    @available(*, deprecated, renamed: "transposed(permutation:﹚")
@differentiable(wrt: self)
public func transposed(withPermutations permutations: Int...) -> Tensor

  • Zwraca transponowany tensor z wymiarami permutowanymi w odwrotnej kolejności.

    Deklaracja 

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

  • Zwraca tensor z odwróconymi określonymi wymiarami.

    Warunek wstępny

    Każda wartość na axes musi należeć do zakresu -rank..<rank .

    Warunek wstępny

    Nie może być duplikacji w axes .

    Deklaracja 

    @differentiable(wrt: self)
public func reversed(inAxes axes: Tensor<Int32>) -> Tensor

  • Zwraca tensor z odwróconymi określonymi wymiarami.

    Warunek wstępny

    Każda wartość na axes musi należeć do zakresu -rank..<rank .

    Warunek wstępny

    Nie może być duplikacji w axes .

    Deklaracja 

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

  • Zwraca tensor z odwróconymi określonymi wymiarami.

    Warunek wstępny

    Każda wartość na axes musi należeć do zakresu -rank..<rank .

    Warunek wstępny

    Nie może być duplikacji w axes .

    Deklaracja 

    @differentiable(wrt: self)
public func reversed(inAxes axes: Int...) -> Tensor

  • Zwraca połączony tensor wzdłuż określonej osi.

    Warunek wstępny

    Tensory muszą mieć te same wymiary, z wyjątkiem określonej osi.

    Warunek wstępny

    Oś musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

  • Operator konkatenacji.

    Notatka

    ++ to niestandardowy operator, który nie istnieje w Swift, ale istnieje w Haskell/Scala. Jej dodanie nie jest nieistotną zmianą językową i może budzić kontrowersje. Istnienie/nazewnictwo ++ zostanie omówione w późniejszej fazie projektowania interfejsu API.

    Deklaracja 

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

  • Zwraca tensor, zbierając wycinki danych wejściowych w indices wzdłuż wymiaru axis

    Dla indices 0-D (skalarnych): 

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

    Dla indices 1-D (wektorowych): 

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

    W ogólnym przypadku tworzy wynikowy tensor, gdzie: 

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

    gdzie N = self.rank i M = indices.rank .

    Kształt powstałego tensora to: self.shape[..<axis] + indices.shape + self.shape[(axis + 1)...] .

    Notatka

    Jeśli na procesorze zostanie znaleziony indeks spoza zakresu, zgłaszany jest błąd. Na GPU, jeśli zostanie znaleziony indeks spoza zakresu, w odpowiednich wartościach wyjściowych zostanie zapisane 0.

    Warunek wstępny

    axis musi należeć do zakresu [-rank, rank) .

    Deklaracja 

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

    Parametry

    indices

    Zawiera indeksy, przy których można gromadzić.

    axis

    Wymiar, wzdłuż którego należy się gromadzić. Wartości ujemne zawijają się.

    Wartość zwracana

    Zebrany tensor.

  • Zwraca wycinki tego tensora w indices wzdłuż wymiaru axis , ignorując pierwsze wymiary batchDimensionCount , które odpowiadają wymiarom partii. Gromadzenie jest wykonywane wzdłuż pierwszego wymiaru niewsadowego.

    Wykonuje podobne funkcje jak gathering , z tą różnicą, że wynikowy kształt tensora ma teraz shape[..<axis] + indices.shape[batchDimensionCount...] + shape[(axis + 1)...] .

    Warunek wstępny

    axis musi należeć do zakresu -rank..<rank , a jednocześnie być większa lub równa batchDimensionCount .

    Warunek wstępny

    batchDimensionCount musi być mniejszy niż indices.rank .

    Deklaracja 

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

    Parametry

    indices

    Zawiera indeksy do zebrania.

    axis

    Wymiar, wzdłuż którego należy się gromadzić. Wartości ujemne zawijają się.

    batchDimensionCount

    Liczba wiodących wymiarów wsadowych do zignorowania.

    Wartość zwracana

    Zebrany tensor.

  • Zwraca tensor, zbierając wartości po zastosowaniu dostarczonej maski logicznej na wejściu.

    Na przykład: 

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

    Ogólnie rzecz biorąc, 0 < mask.rank = K <= tensor.rank , a kształt mask musi odpowiadać pierwszym K wymiarom kształtu tensor . Mamy wtedy: tensor.gathering(where: mask)[i, j1, ..., jd] = tensor[i1, ..., iK, j1, ..., jd] , gdzie [i1, ..., iK] jest i tym true wpisem mask (kolejność główna wiersza).

    axis może być używana z mask , aby wskazać oś, z której ma być maskowana. W takim przypadku axis + mask.rank <= tensor.rank i kształt mask muszą odpowiadać dimensions of the 's shape must match the first osi + mask.rank kształtu tensora.

    Warunek wstępny

    mask nie może być skalarem: mask.rank != 0 .

    Deklaracja 

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

    Parametry

    mask

    KD tensor boolowski, gdzie K <= self.rank .

    axis

    Tensor całkowity 0-D reprezentujący oś w self , z której należy maskować, gdzie K + axis <= self.rank .

    Wartość zwracana

    (self.rank - K + 1) - tensor wymiarowy wypełniany wpisami w tym tensorze odpowiadającymi true wartościom w mask .

  • Zwraca lokalizacje wartości niezerowych/prawdziwych w tym tensorze.

    Współrzędne są zwracane w tensorze 2-D, gdzie pierwszy wymiar (wiersze) reprezentuje liczbę niezerowych elementów, a drugi wymiar (kolumny) reprezentuje współrzędne niezerowych elementów. Należy pamiętać, że kształt tensora wyjściowego może się różnić w zależności od liczby wartości prawdziwych w tym tensorze. Indeksy są wyświetlane w kolejności od głównych wierszy.

    Na przykład: 

    // '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]]

    Deklaracja 

    public func nonZeroIndices() -> Tensor<Int64>

    Wartość zwracana

    Tensor o kształcie (num_true, rank(condition)) .

  • Deklaracja 

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

  • Deklaracja 

    @differentiable(wrt: self)
public func broadcasted(to shape: TensorShape) -> Tensor

  • Emisja do tego samego kształtu co określony Tensor .

    Warunek wstępny

    Określony kształt musi być kompatybilny z transmisją.

    Deklaracja 

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

  • Deklaracja 

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

  • Wyodrębnia wycinek z tensora określonego przez dolną i górną granicę dla każdego wymiaru.

    Deklaracja 

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

    Parametry

    lowerBounds

    Dolne granice w każdym wymiarze.

    upperBounds

    Górne granice w każdym wymiarze.

  • Deklaracja 

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

  • Deklaracja 

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

  • Deklaracja 

    @differentiable(wrt: self)
public subscript(ranges: TensorRangeExpression...) -> Tensor { get set }

  • Sprawdza, czy każdy element axes oznacza oś self i w przeciwnym razie zatrzymuje program z diagnostyką.

    Deklaracja 

    func ensureValid(
  axes: Tensor<Int32>,
  function: StaticString = #function,
  file: StaticString = #file,
  line: UInt = #line
)

  • Sprawdza, czy każdy element axes oznacza oś self i w przeciwnym razie zatrzymuje program z diagnostyką.

    Deklaracja 

    func ensureValid(
  axes: [Int],
  function: StaticString = #function,
  file: StaticString = #file,
  line: UInt = #line
)

  • Sprawdza, czy k oznacza oś self i w przeciwnym razie zatrzymuje program z diagnostyką.

    Deklaracja 

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

  • Deklaracja 

    public init<BatchSamples: Collection>(collating samples: BatchSamples)
where BatchSamples.Element == Self

  • Tworzy kopię other na danym Device .

    Deklaracja 

    public init(copying other: Tensor, to device: Device)

  • Tworzy tensor o określonym kształcie i pojedynczej, powtarzanej wartości skalarnej.

    Deklaracja 

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

    Parametry

    shape

    Wymiary tensora.

    repeatedValue

    Wartość skalarna do powtórzenia.

  • Tworzy tensor o określonym kształcie i pojedynczej, powtarzanej wartości skalarnej.

    Deklaracja 

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

    Parametry

    repeatedValue

    Wartość skalarna do powtórzenia.

    shape

    Wymiary tensora.

  • Tworzy tensor, rozgłaszając dany skalar do danej rangi, przy czym wszystkie wymiary wynoszą 1.

    Deklaracja 

    public init(broadcasting scalar: Scalar, rank: Int, on device: Device = .default)

  • Tworzy tensor z tablicy tensorów (które same mogą być skalarami).

    Deklaracja 

    @differentiable
public init(_ elements: [Tensor])

  • Układa tensors wzdłuż wymiaru axis w nowy tensor o randze o jeden wyższej niż bieżący tensor i każdy tensor w tensors .

    Biorąc pod uwagę, że wszystkie tensors mają kształt [A, B, C] i tensors.count = N , wówczas:

    • jeśli axis == 0 to wynikowy tensor będzie miał postać [N, A, B, C] .
    • jeśli axis == 1 to wynikowy tensor będzie miał postać [A, N, B, C] .
    • itp.

    Na przykład: 

    // '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]]

    Jest to przeciwieństwo Tensor.unstacked(alongAxis:) .

    Warunek wstępny

    Wszystkie tensory muszą mieć ten sam kształt.

    Warunek wstępny

    axis musi należeć do zakresu [-rank, rank) , gdzie rank jest rangą podanych tensorów.

    Deklaracja 

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

    Parametry

    tensors

    Tensory do układania w stos.

    axis

    Wymiar, wzdłuż którego należy układać stosy. Wartości ujemne zawijają się.

    Wartość zwracana

    Tensor skumulowany.

  • Łączy tensors wzdłuż wymiaru axis .

    Biorąc pod uwagę, że tensors[i].shape = [D0, D1, ... Daxis(i), ...Dn] , to połączony wynik ma kształt [D0, D1, ... Raxis, ...Dn] , gdzie Raxis = sum(Daxis(i)) . Oznacza to, że dane z tensorów wejściowych są łączone wzdłuż wymiaru axis .

    Na przykład: 

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

    Notatka

    Jeśli łączysz wzdłuż nowej osi, rozważ użycie Tensor.init(stacking:alongAxis:) .

    Warunek wstępny

    Wszystkie tensory muszą mieć tę samą rangę, a wszystkie wymiary oprócz axis muszą być równe.

    Warunek wstępny

    axis musi należeć do zakresu [-rank, rank) , gdzie rank jest rangą podanych tensorów.

    Deklaracja 

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

    Parametry

    tensors

    Tensory do łączenia.

    axis

    Wymiar wzdłuż którego należy połączyć. Wartości ujemne zawijają się.

    Wartość zwracana

    Połączony tensor.

  • Zastępuje elementy tego tensora other na ścieżkach, gdzie mask ma true .

    Warunek wstępny

    self i other muszą mieć ten sam kształt. Jeśli self i other są skalarne, mask ​​również musi być skalarna. Jeśli self i other mają rangę większą lub równą 1 , wówczas mask ​​musi albo mieć taki sam kształt jak self , albo być Tensor 1-D takim, że mask.scalarCount == self.shape[0] .

    Deklaracja 

    @differentiable(wrt: (self, other)
) public func replacing(with other: Tensor, where mask: Tensor<Bool>) -> Tensor

  • Zwraca wartość true, jeśli fizyczny typ skalarny ma zmniejszoną precyzję.

    Obecnie fizyczne typy skalarne o zmniejszonej precyzji obejmują tylko BFloat16 .

    Deklaracja 

    public var isReducedPrecision: Bool { get }

  • Awansuje skalar do tensora z tym samym urządzeniem i precyzją co dany tensor.

    Deklaracja 

    @differentiable
public init(_ value: Scalar, deviceAndPrecisionLike tensor: Tensor)

  • Zwraca kopię self przekonwertowaną na fizyczny typ skalarny BFloat16 .

    Deklaracja 

    public var toReducedPrecision: `Self` { get }

  • Zwraca kopię typu self skonwertowanego na fizyczny typ skalarny Scalar .

    Deklaracja 

    public var toFullPrecision: `Self` { get }

  • Liczba wymiarów Tensor .

    Deklaracja 

    public var rank: Int { get }

  • Kształt Tensor .

    Deklaracja 

    public var shape: TensorShape { get }

  • Liczba skalarów w Tensor .

  • Deklaracja 

    public var scalarCount: Int { get }

  • Ranga tensora reprezentowana jako Tensor<Int32> .

    Deklaracja 

    public var rankTensor: Tensor<Int32> { get }

  • Wymiary tensora reprezentowane jako Tensor<Int32> .

    Deklaracja 

    public var shapeTensor: Tensor<Int32> { get }

  • Liczba skalarów w tensorze reprezentowana jako Tensor<Int32> .

    Deklaracja 

    public var scalarCountTensor: Tensor<Int32> { get }

  • Zwraca true , jeśli rank jest równa 0, w przeciwnym razie zwraca false .

    Deklaracja 

    public var isScalar: Bool { get }

  • Zwraca pojedynczy element skalarny, jeśli rank jest równa 0, a w przeciwnym razie nil .

    Deklaracja 

    public var scalar: Scalar? { get }

  • Zmień kształt na skalarny.

    Warunek wstępny

    Tensor ma dokładnie jeden skalar.

    Deklaracja 

    @differentiable
public func scalarized() -> Scalar

  • Deklaracja 

    public var array: ShapedArray<Scalar> { get }

  • Deklaracja 

    @differentiable
public var scalars: [Scalar] { get }

  • Tworzy tensor 0-D na podstawie wartości skalarnej.

    Deklaracja 

    @differentiable
public init(_ value: Scalar, on device: Device = .default)

  • Tworzy tensor 1D ze skalarów.

    Deklaracja 

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

  • Tworzy tensor 1D ze skalarów.

    Deklaracja 

    public init<C: Collection>(
  _ vector: C, on device: Device = .default
) where C.Element == Scalar

  • Tworzy tensor o określonym kształcie i sąsiadujących skalarach w kolejności głównych wierszy.

    Warunek wstępny

    Iloczyn wymiarów kształtu musi być równy liczbie skalarów.

    Deklaracja 

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

    Parametry

    shape

    Kształt tensora.

    scalars

    Zawartość skalarna tensora.

  • Tworzy tensor o określonym kształcie i sąsiadujących skalarach w kolejności głównych wierszy.

    Warunek wstępny

    Iloczyn wymiarów kształtu musi być równy liczbie skalarów.

    Deklaracja 

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

    Parametry

    shape

    Kształt tensora.

    scalars

    Zawartość skalarna tensora.

  • Tworzy tensor o określonym kształcie i sąsiadujących skalarach w kolejności głównych wierszy.

    Warunek wstępny

    Iloczyn wymiarów kształtu musi być równy liczbie skalarów.

  • Tworzy tensor o określonym kształcie i sąsiadujących skalarach w kolejności głównych wierszy.

    Warunek wstępny

    Iloczyn wymiarów kształtu musi być równy liczbie skalarów.

    Deklaracja 

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

    Parametry

    shape

    Kształt tensora.

    scalars

    Zawartość skalarna tensora.

  • Typ elementów literału tablicowego.

    Deklaracja 

    public typealias ArrayLiteralElement = _TensorElementLiteral<Scalar>

  • Tworzy tensor zainicjowany podanymi elementami.

    Deklaracja 

    public init(arrayLiteral elements: _TensorElementLiteral<Scalar>...)

  • Tekstowa reprezentacja tensora.

    Notatka

    użyj fullDescription dla niezbyt wydrukowanego opisu pokazującego wszystkie skalary.

    Deklaracja 

    public var description: String { get }

  • Tekstowa reprezentacja tensora. Zwraca podsumowany opis, jeśli summarize ma wartość true i liczba elementów przekracza dwukrotnie wartość edgeElementCount .

    Deklaracja 

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

    Parametry

    lineWidth

    Maksymalna szerokość linii do druku. Służy do określenia liczby skalarów do wydrukowania w wierszu.

    edgeElementCount

    Maksymalna liczba elementów do wydrukowania przed i po podsumowaniu poprzez elipsy ( ... ).

    summarizing

    Jeśli prawda, podsumuj opis, jeśli liczba elementów przekracza dwukrotnie edgeElementCount .

  • Pełna, niezbyt wydrukowana tekstowa reprezentacja tensora, pokazująca wszystkie skalary.

    Deklaracja 

    public var fullDescription: String { get }

  • Deklaracja 

    public var playgroundDescription: Any { get }

  • Deklaracja 

    public var customMirror: Mirror { get }

  • Adnotacje opisujące ten tensor.

    Deklaracja 

    public var annotations: String { get }

  • Alias ​​dla adnotacji.

    Deklaracja 

    public var summary: String { get }

  • Deklaracja 

    public init(_owning tensorHandles: UnsafePointer<CTensorHandle>?)

  • Deklaracja 

    public init<C: RandomAccessCollection>(
  _handles: C
) where C.Element: _AnyTensorHandle

  • Deklaracja 

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

  • Deklaracja 

    init(_xla: XLATensor)

  • Deklaracja 

    init(_xlaHandle: UnsafeMutablePointer<OpaqueXLATensor>)

  • Deklaracja 

    var xlaHandle: UnsafeMutablePointer<OpaqueXLATensor> { get }

  • Deklaracja 

    var xlaTensor: XLATensor { get }
Dostępne gdzie `Skalarny`: `Numeryczny`

  • Deklaracja 

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

  • Deklaracja 

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

  • Deklaracja 

    @differentiable(wrt: self)
public func unbroadcasted(to shape: TensorShape) -> Tensor

  • Tryb określający sposób dopełnienia tensora.

    Deklaracja 

    public enum PaddingMode

  • Zwraca tensor dopełniony stałą zgodnie z określonymi rozmiarami dopełnienia.

    Deklaracja 

    @differentiable(wrt: self)
public func padded(forSizes sizes: [(before: Int, after: Int)], with value: Scalar = 0)
  -> Tensor

  • Zwraca dopełniony tensor zgodnie z określonymi rozmiarami i trybem dopełnienia.

    Deklaracja 

    @differentiable(wrt: self)
public func padded(forSizes sizes: [(before: Int, after: Int)], mode: PaddingMode) -> Tensor
Dostępne, gdy „Skalarny”: „Numeryczny” i „Porównywalny”.

  • Zwraca tensor skalarów logicznych, obliczając elementarnie lhs < rhs .

    Deklaracja 

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

  • Zwraca tensor skalarów logicznych, obliczając elementarnie lhs <= rhs .

    Deklaracja 

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

  • Zwraca tensor skalarów Boole’a, obliczając element lhs > rhs .

    Deklaracja 

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

  • Zwraca tensor skalarów logicznych, obliczając elementarnie lhs >= rhs .

    Deklaracja 

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

  • Zwraca tensor skalarów logicznych, obliczając elementarnie lhs < rhs .

    Notatka

    .< obsługuje nadawanie.

    Deklaracja 

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

  • Zwraca tensor skalarów logicznych, obliczając elementarnie lhs <= rhs .

    Notatka

    .<= obsługuje nadawanie.

    Deklaracja 

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

  • Zwraca tensor skalarów Boole’a, obliczając element lhs > rhs .

    Notatka

    .> obsługuje nadawanie.

    Deklaracja 

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

  • Zwraca tensor skalarów logicznych, obliczając elementarnie lhs >= rhs .

    Notatka

    .>= obsługuje nadawanie.

    Deklaracja 

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

  • Zwraca tensor skalarów logicznych, obliczając elementarnie lhs < rhs .

    Notatka

    .< obsługuje nadawanie.

    Deklaracja 

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

  • Zwraca tensor skalarów logicznych, obliczając elementarnie lhs <= rhs .

    Notatka

    .<= obsługuje nadawanie.

    Deklaracja 

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

  • Zwraca tensor skalarów Boole’a, obliczając element lhs > rhs .

    Notatka

    .> obsługuje nadawanie.

    Deklaracja 

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

  • Zwraca tensor skalarów logicznych, obliczając elementarnie lhs >= rhs .

    Notatka

    .>= obsługuje nadawanie.

    Deklaracja 

    public static func .>= (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
Dostępne, gdy `Skalarne`: `Równe`

  • Zwraca tensor skalarów logicznych, obliczając elementarnie lhs == rhs .

    Notatka

    .== obsługuje nadawanie.

    Deklaracja 

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

  • Zwraca tensor skalarów logicznych, obliczając elementarnie lhs != rhs .

    Notatka

    .!= obsługuje nadawanie.

    Deklaracja 

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

  • Zwraca tensor skalarów logicznych, obliczając elementarnie lhs == rhs .

    Notatka

    .== obsługuje nadawanie.

    Deklaracja 

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

  • Zwraca tensor skalarów logicznych, obliczając elementarnie lhs != rhs .

    Notatka

    .!= obsługuje nadawanie.

    Deklaracja 

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

  • Zwraca tensor skalarów logicznych, obliczając elementarnie lhs == rhs .

    Notatka

    .== obsługuje nadawanie.

    Deklaracja 

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

  • Zwraca tensor skalarów logicznych, obliczając elementarnie lhs != rhs .

    Notatka

    .!= obsługuje nadawanie.

    Deklaracja 

    public static func .!= (lhs: Tensor, rhs: Scalar) -> Tensor<Bool>
Dostępne, gdy `Scalar`: `TensorFlowFloatingPoint` i `Equatable`

  • Zwraca tensor wartości logicznych wskazujący, czy elementy self są w przybliżeniu równe elementom other .

    Warunek wstępny

    self i other muszą mieć ten sam kształt.

    Deklaracja 

    public func elementsAlmostEqual(
  _ other: Tensor,
  tolerance: Scalar = Scalar.ulpOfOne.squareRoot()
) -> Tensor<Bool>
Dostępne, gdy `Scalar`: `TensorFlowFloatingPoint`

  • Zwraca true , jeśli wszystkie elementy self są w przybliżeniu równe elementom other .

    Warunek wstępny

    self i other muszą mieć ten sam kształt.

    Deklaracja 

    public func isAlmostEqual(
  to other: Tensor,
  tolerance: Scalar = Scalar.ulpOfOne.squareRoot()
) -> Bool
Dostępne, gdy `Skalar`: `TensorFlowNumeric`

  • Uruchamia sumę replik krzyżowych dla tego tensora. Ta sama suma replik krzyżowych musi wystąpić na każdym z pozostałych urządzeń uczestniczących w sumie.

    Deklaracja 

    public mutating mutating func crossReplicaSum(_ scale: Double)
Dostępne, gdy `Scalar`: `TensorFlowFloatingPoint`
Dostępne gdzie `Skalarny`: `Numeryczny`

  • Wykonaj elementową konwersję typu z tensora Bool .

    Deklaracja 

    public init(_ other: Tensor<Bool>)

  • Wykonaj konwersję elementową z innego Tensor .

    Deklaracja 

    @differentiable
public init<OtherScalar>(_ other: Tensor<OtherScalar>) where OtherScalar : Numeric, OtherScalar : TensorFlowScalar
Dostępne, gdy `Scalar`: `TensorFlowFloatingPoint`
Dostępne gdzie `Skalarny`: `Numeryczny`

  • Tworzy tensor ze wszystkimi skalarami ustawionymi na zero.

    Deklaracja 

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

    Parametry

    shape

    Kształt tensora.

  • Tworzy tensor ze wszystkimi skalarami ustawionymi na jeden.

    Deklaracja 

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

    Parametry

    shape

    Kształt tensora.

  • Tworzy tensor ze wszystkimi skalarami ustawionymi na zero, który ma ten sam kształt i typ co podany tensor.

    Deklaracja 

    public init(zerosLike other: Tensor)

    Parametry

    other

    Tensor, którego kształtu i typu danych należy użyć.

  • Tworzy tensor ze wszystkimi skalarami ustawionymi na taki, który ma ten sam kształt i typ co podany tensor.

    Deklaracja 

    public init(onesLike other: Tensor)

    Parametry

    other

    Tensor, którego kształtu i typu danych należy użyć.

  • Tworzy tensor 1-D reprezentujący sekwencję od wartości początkowej do wartości końcowej, ale bez wartości końcowej, ze stopniowaniem o określoną wartość.

    Deklaracja 

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

    Parametry

    start

    Wartość początkowa, która ma być używana w sekwencji. Jeśli sekwencja zawiera jakiekolwiek wartości, pierwszą z nich jest start .

    end

    Wartość końcowa ograniczająca sekwencję. end nigdy nie jest elementem wynikowej sekwencji.

    stride

    Kwota, którą należy przekroczyć w każdej iteracji. stride musi być pozytywny.

  • Tworzy tensor 1-D reprezentujący sekwencję od wartości początkowej do wartości końcowej, ale bez wartości końcowej, ze stopniowaniem o określoną wartość.

    Deklaracja 

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

    Parametry

    start

    Wartość początkowa, która ma być używana w sekwencji. Jeśli sekwencja zawiera jakiekolwiek wartości, pierwszą z nich jest start .

    end

    Wartość końcowa ograniczająca sekwencję. end nigdy nie jest elementem wynikowej sekwencji.

    stride

    Kwota, którą należy przekroczyć w każdej iteracji. stride musi być pozytywny.

  • Tworzy jeden gorący tensor przy danych indeksach. Lokalizacje reprezentowane przez indices przyjmują wartość onValue (domyślnie 1 ), podczas gdy wszystkie inne lokalizacje przyjmują wartość offValue (domyślnie 0 ). Jeśli indices wejściowe mają rangę n , nowy tensor będzie miał rangę n+1 . Nowa oś tworzona jest na axis wymiarowej (domyślnie nowa oś jest dodawana na końcu).

    Jeśli indices są skalarami, kształt nowego tensora będzie wektorem długości depth .

    Jeśli indices są wektorami features długości, wyjściowym kształtem będzie: cechy x głębokość, jeśli oś == -1 głębokość x cechy, jeśli oś == 0

    Jeśli indices jest macierz (partia) o kształcie [batch, features] , wyjściowym kształtem będzie: partia x cechy x głębokość, jeśli oś == -1 partia x głębokość x cechy, jeśli oś == 1 głębokość x partia x cechy , jeśli oś == 0

    Deklaracja 

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

    Parametry

    indices

    Tensor indeksów.

    depth

    Skalar określający głębokość jednego gorącego wymiaru.

    onValue

    Skalar określający wartość w miejscu, do którego odnosi się jakiś indeks w indices .

    offValue

    Skalar określający wartość w lokalizacji, do której nie odwołuje się żaden indeks w indices .

    axis

    Oś do wypełnienia. Wartość domyślna to -1 , nowa, najbardziej wewnętrzna oś.

Dostępne, gdy `Scalar`: `TensorFlowFloatingPoint`

  • Tworzy tensor 1-D reprezentujący sekwencję od wartości początkowej do wartości końcowej włącznie, rozmieszczonych równomiernie w celu wygenerowania określonej liczby wartości.

    Deklaracja 

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

    Parametry

    start

    Wartość początkowa, która ma być używana w sekwencji. Jeśli sekwencja zawiera jakiekolwiek wartości, pierwszą z nich jest start .

    end

    Wartość końcowa ograniczająca sekwencję. end jest ostatnim elementem wynikowej sekwencji.

    count

    Liczba wartości w wynikowej sekwencji. count musi być dodatnia.

  • Tworzy tensor 1-D reprezentujący sekwencję od wartości początkowej do wartości końcowej włącznie, rozmieszczonych równomiernie w celu wygenerowania określonej liczby wartości.

    Warunek wstępny

    start , to i count muszą być tensorami zawierającymi pojedynczą wartość skalarną.

    Deklaracja 

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

    Parametry

    start

    Wartość początkowa, która ma być używana w sekwencji. Jeśli sekwencja zawiera jakiekolwiek wartości, pierwszą z nich jest start .

    end

    Wartość końcowa ograniczająca sekwencję. end jest ostatnim elementem wynikowej sekwencji.

    count

    Liczba wartości w wynikowej sekwencji. count musi być dodatnia.

Dostępne, gdy `Scalar`: `TensorFlowIndex`

  • Tworzy tensor o określonym kształcie, losowo próbkując wartości skalarne z jednolitego rozkładu między lowerBound i upperBound .

    Deklaracja 

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

    Parametry

    shape

    Wymiary tensora.

    lowerBound

    Dolna granica rozkładu.

    upperBound

    Górna granica rozkładu.

    seed

    Wartość nasion.

Dostępne, gdy `Scalar`: `TensorFlowFloatingPoint`

  • Tworzy tensor o określonym kształcie, losowo próbkując wartości skalarne z jednolitego rozkładu między lowerBound i upperBound .

    Deklaracja 

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

    Parametry

    shape

    Wymiary tensora.

    lowerBound

    Dolna granica rozkładu.

    upperBound

    Górna granica rozkładu.

    seed

    Wartość nasion.

  • Tworzy tensor o określonym kształcie, losowo próbkując wartości skalarne z rozkładu normalnego.

    Deklaracja 

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

    Parametry

    shape

    Wymiary tensora.

    mean

    Średnia dystrybucji.

    standardDeviation

    Odchylenie standardowe rozkładu.

    seed

    Wartość nasion.

  • Tworzy tensor o określonym kształcie, losowo próbkując wartości skalarne z obciętego rozkładu normalnego.

    Deklaracja 

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

    Parametry

    shape

    Wymiary tensora.

    mean

    Średnia dystrybucji.

    standardDeviation

    Odchylenie standardowe rozkładu.

    seed

    Wartość nasion.

Dostępne, gdy `Scalar`: `TensorFlowIndex`

  • Tworzy tensor, rysując próbki z rozkładu kategorycznego.

    Deklaracja 

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

    Parametry

    randomCategorialLogits

    Tensor 2-D z kształtem [batchSize, classCount] . Każdy wycinek [i, :] reprezentuje nieznormalizowane prawdopodobieństwa logarytmiczne dla wszystkich klas.

    sampleCount

    0-D. Liczba niezależnych próbek do pobrania dla każdego wycinka rzędu.

    seed

    Wartość nasion.

    Wartość zwracana

    Tensor 2-D z kształtem [batchSize, sampleCount] . Każdy plasterek [i, :] zawiera narysowane etykiety klas z zakresem [0, classCount) .

Dostępne, gdy `Scalar`: `TensorFlowFloatingPoint`

  • Tworzy tensor o określonym kształcie, wykonując jednolitą inicjalizację Glorot (Xavier).

    Rysuje losowe próbki z jednolitego rozkładu pomiędzy -limit i limit wygenerowanym przez domyślny generator liczb losowych, gdzie limit to sqrt(6 / (fanIn + fanOut)) a fanIn / fanOut reprezentuje liczbę cech wejściowych i wyjściowych pomnożoną przez receptywność rozmiar pola.

    Odniesienie: „Zrozumienie trudności w szkoleniu sieci neuronowych z głębokim wyprzedzeniem”

    Deklaracja 

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

    Parametry

    shape

    Wymiary tensora.

    seed

    Wartość nasion.

  • Tworzy tensor o określonym kształcie, wykonując normalną inicjalizację Glorot (Xavier).

    Rysuje losowe próbki z obciętego rozkładu normalnego wyśrodkowanego na 0 z odchyleniem standardowym sqrt(2 / (fanIn + fanOut)) generowanym przez domyślny generator liczb losowych, gdzie fanIn / fanOut reprezentuje liczbę cech wejściowych i wyjściowych pomnożoną przez pole recepcyjne rozmiar.

    Odniesienie: „Zrozumienie trudności w szkoleniu sieci neuronowych z głębokim wyprzedzeniem”

    Deklaracja 

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

    Parametry

    shape

    Wymiary tensora.

    seed

    Wartość nasion.

  • Tworzy tensor o określonym kształcie, wykonując równomierną inicjalizację He (Kaiming).

    Rysuje losowe próbki z jednolitego rozkładu pomiędzy -limit i limit wygenerowany przez domyślny generator liczb losowych, gdzie limit to sqrt(6 / fanIn) a fanIn reprezentuje liczbę cech wejściowych pomnożoną przez rozmiar pola receptywnego.

    Odniesienie: „Wgłębienie się w prostowniki: przewyższająca wydajność na poziomie ludzkim w klasyfikacji ImageNet”

    Deklaracja 

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

    Parametry

    shape

    Wymiary tensora.

    seed

    Wartość nasion.

  • Tworzy tensor o określonym kształcie, wykonując normalną inicjalizację He (Kaiming).

    Rysuje losowe próbki z obciętego rozkładu normalnego wyśrodkowanego na 0 z odchyleniem standardowym sqrt(2 / fanIn)) generowanym przez domyślny generator liczb losowych, gdzie fanIn reprezentuje liczbę cech wejściowych pomnożoną przez rozmiar pola receptywnego.

    Odniesienie: „Wgłębienie się w prostowniki: przewyższająca wydajność na poziomie ludzkim w klasyfikacji ImageNet”

    Deklaracja 

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

    Parametry

    shape

    Wymiary tensora.

    seed

    Wartość nasion.

  • Tworzy tensor o określonym kształcie, wykonując równomierną inicjalizację LeCun.

    Rysuje losowe próbki z jednolitego rozkładu pomiędzy -limit i limit wygenerowany przez domyślny generator liczb losowych, gdzie limit to sqrt(3 / fanIn) a fanIn reprezentuje liczbę cech wejściowych pomnożoną przez rozmiar pola receptywnego.

    Odniesienie: „Efektywna podpora tylna”

    Deklaracja 

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

    Parametry

    shape

    Wymiary tensora.

    seed

    Wartość nasion.

  • Tworzy tensor o określonym kształcie, wykonując normalną inicjalizację LeCun.

    Rysuje losowe próbki z obciętego rozkładu normalnego wyśrodkowanego na 0 z odchyleniem standardowym sqrt(1 / fanIn) generowanym przez domyślny generator liczb losowych, gdzie fanIn reprezentuje liczbę cech wejściowych pomnożoną przez rozmiar pola receptywnego.

    Odniesienie: „Efektywna podpora tylna”

    Deklaracja 

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

    Parametry

    shape

    Wymiary tensora.

    seed

    Wartość nasion.

  • Tworzy macierz ortogonalną lub tensor.

    Jeżeli kształt inicjowanego tensora jest dwuwymiarowy, jest on inicjowany macierzą ortogonalną uzyskaną z rozkładu QR macierzy liczb losowych pochodzących z rozkładu normalnego. Jeśli macierz ma mniej wierszy niż kolumn, wówczas wynik będzie zawierał wiersze ortogonalne. W przeciwnym razie dane wyjściowe będą miały kolumny ortogonalne.

    Jeżeli kształt inicjowanego tensora jest więcej niż dwuwymiarowy, inicjalizowana jest macierz kształtu [shape[0] * ... * shape[rank - 2], shape[rank - 1]] . Następnie macierz jest przekształcana w celu uzyskania tensora o pożądanym kształcie.

    Deklaracja 

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

    Parametry

    shape

    Kształt tensora.

    gain

    Współczynnik mnożenia, który należy zastosować do tensora ortogonalnego.

    seed

    Krotka dwóch liczb całkowitych, która ma zapełnić generator liczb losowych.

Dostępne, gdy `Skalar`: `TensorFlowNumeric`

  • Zwraca [wsadową] część przekątną [wsadowego] tensora. Dla instancji tensora kształtu [..., M, N] wynikiem jest tensor kształtu [..., K] , gdzie K równa się min(N, M) .

    Na przykład: 

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

    Deklaracja 

    @differentiable
public func diagonalPart() -> Tensor

  • Konstruuje [wsadową] tablicę diagonalną. W przypadku instancji tensora kształtu [..., M] wynikiem jest tensor kształtu [..., M, M] .

    Na przykład: 

    // 't' is [1, 2, 3, 4]

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

    Deklaracja 

    @differentiable
public func diagonal() -> Tensor

  • Zwraca self z nowymi wartościami diagonalnymi, pod warunkiem, że self jest macierzą opcjonalnie wsadową.

    Zwrócony tensor ma taki sam kształt i wartości jak self , z wyjątkiem określonych przekątnych najbardziej wewnętrznych macierzy, które są nadpisywane przez wartości diagonal .

    Parametr diagonal: Tensor o randze rangi rank - 1 reprezentujący nowe wartości przekątnej.

    Deklaracja 

    public func withDiagonal(_ diagonal: Tensor<Scalar>) -> Tensor

  • Deklaracja 

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

  • Zwraca kopię najbardziej wewnętrznego tensora określonego przez centralne granice pasma. Dane wyjściowe to tensor o tym samym kształcie co instancja [..., :, :] .

    Na przykład: 

    // '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]]

    Deklaracja 

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

    Parametry

    subdiagonalCount

    Liczba podprzekątnych do zachowania. Jeżeli wynik jest ujemny, zachowaj cały dolny trójkąt.

    superdiagonalCount

    Liczba superprzekątnych do zachowania. Jeśli wynik jest ujemny, zachowaj cały górny trójkąt.

Dostępne, gdy `Scalar`: `TensorFlowFloatingPoint`

  • Zwraca rozkład QR każdej macierzy wewnętrznej w tensorze, tensora z wewnętrznymi macierzami ortogonalnymi q i tensora z wewnętrznymi górnymi macierzami trójkątnymi r , tak że tensor jest równy matmul(q, r) .

    Deklaracja 

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

    Parametry

    fullMatrices

    Jeśli true , oblicz pełnowymiarowe q i r . W przeciwnym razie oblicz tylko wiodące kolumny min(shape[rank - 1], shape[rank - 2]) kolumny q .

  • Zwraca rozkład wartości pojedynczej self , biorąc pod uwagę, że self jest macierzą opcjonalnie wsadową.

    Rozkład wartości osobliwych (SVD) opcjonalnie wsadowej macierzy self to wartości s , u i v , takie że: 

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

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

    Warunek wstępny

    self musi być tensorem o kształcie [..., M, N] .

    Deklaracja 

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

    Parametry

    computeUV

    Jeśli true , lewy i prawy wektor osobliwy są obliczane i zwracane odpowiednio jako u i v . Jeśli false , zwracane są wartości nil jako u i v .

    fullMatrices

    Jeśli true , u i v mają odpowiednio kształty [..., M, M] i [..., N, N] . Jeśli false , u i v mają odpowiednio kształty [..., M, K] i [..., K, N] . Ignorowane, gdy computeUV ma wartość false.

    Wartość zwracana

    • s: Wartości osobliwe o kształcie [..., K] . W obrębie każdego wektora wartości osobliwe są sortowane w kolejności malejącej.
    • u: Lewe wektory osobliwe.
    • v: Prawe wektory osobliwe.

  • Pierwiastek kwadratowy z x .

    W przypadku typów rzeczywistych, jeśli x jest ujemne, wynikiem jest .nan . W przypadku typów złożonych następuje odcięcie gałęzi na ujemnej osi rzeczywistej.

    Deklaracja 

    @differentiable
public static func sqrt(_ x: `Self`) -> Tensor<Scalar>

  • Cosinus x , interpretowany jako kąt w radianach.

    Deklaracja 

    @differentiable
public static func cos(_ x: `Self`) -> Tensor<Scalar>

  • Sinus x , interpretowany jako kąt w radianach.

    Deklaracja 

    @differentiable
public static func sin(_ x: `Self`) -> Tensor<Scalar>

  • Tangens x , interpretowany jako kąt w radianach.

    Deklaracja 

    @differentiable
public static func tan(_ x: `Self`) -> Tensor<Scalar>

  • Odwrotny cosinus x w radianach.

    Deklaracja 

    @differentiable
public static func acos(_ x: `Self`) -> Tensor<Scalar>

  • Odwrotny sinus x w radianach.

    Deklaracja 

    @differentiable
public static func asin(_ x: `Self`) -> Tensor<Scalar>

  • Odwrotny tangens x w radianach.

    Deklaracja 

    @differentiable
public static func atan(_ x: `Self`) -> Tensor<Scalar>

  • Cosinus hiperboliczny x .

    Deklaracja 

    @differentiable
public static func cosh(_ x: `Self`) -> Tensor<Scalar>

  • Sinus hiperboliczny x .

    Deklaracja 

    @differentiable
public static func sinh(_ x: `Self`) -> Tensor<Scalar>

  • Tangens hiperboliczny x .

    Deklaracja 

    @differentiable
public static func tanh(_ x: `Self`) -> Tensor<Scalar>

  • Odwrotny cosinus hiperboliczny x .

    Deklaracja 

    @differentiable
public static func acosh(_ x: `Self`) -> Tensor<Scalar>

  • Odwrotny sinus hiperboliczny x .

    Deklaracja 

    @differentiable
public static func asinh(_ x: `Self`) -> Tensor<Scalar>

  • Odwrotny tangens hiperboliczny x .

    Deklaracja 

    @differentiable
public static func atanh(_ x: `Self`) -> Tensor<Scalar>

  • Funkcja wykładnicza zastosowana do x lub e**x .

    Deklaracja 

    @differentiable
public static func exp(_ x: `Self`) -> Tensor<Scalar>

  • Dwa podniesione do potęgi x .

    Deklaracja 

    @differentiable
public static func exp2(_ x: `Self`) -> Tensor<Scalar>

  • Dziesięć podniesione do potęgi x .

    Deklaracja 

    @differentiable
public static func exp10(_ x: `Self`) -> Tensor<Scalar>

  • exp(x) - 1 oceniane tak, aby zachować dokładność bliską zeru.

    Deklaracja 

    @differentiable
public static func expm1(_ x: `Self`) -> Tensor<Scalar>

  • Logarytm naturalny x .

    Deklaracja 

    @differentiable
public static func log(_ x: `Self`) -> Tensor<Scalar>

  • Logarytm o podstawie dwóch z x .

    Deklaracja 

    @differentiable
public static func log2(_ x: `Self`) -> Tensor<Scalar>

  • Logarytm dziesiętny z x .

    Deklaracja 

    @differentiable
public static func log10(_ x: `Self`) -> Tensor<Scalar>

  • log(1 + x) oceniany tak, aby zachować dokładność bliską zeru.

    Deklaracja 

    @differentiable
public static func log1p(_ x: `Self`) -> Tensor<Scalar>

  • exp(y log(x)) obliczone bez utraty precyzji pośredniej.

    W przypadku typów rzeczywistych, jeśli x jest ujemne, wynikiem jest NaN, nawet jeśli y ma wartość całkowitą. W przypadku typów złożonych istnieje odgałęzienie ujemnej osi rzeczywistej.

    Deklaracja 

    @differentiable
public static func pow(_ x: `Self`, _ y: `Self`) -> Tensor<Scalar>

  • x podniesiony do mocy n th.

    Produkt n kopii x .

    Deklaracja 

    @differentiable
public static func pow(_ x: `Self`, _ n: Int) -> Tensor<Scalar>

  • Korzeń n . x

    W przypadku rzeczywistych typów, jeśli x jest ujemne, a n jest równe, wynik jest NAN. W przypadku typów złożonych znajduje się gałąźna wzdłuż ujemnej osi rzeczywistej.

    Deklaracja 

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

  • Deklaracja 

    public typealias VectorSpaceScalar = Float

  • Deklaracja 

    public func scaled(by scale: Float) -> Tensor<Scalar>

  • Deklaracja 

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

  • Deklaracja 

    public func subtracting(_ scalar: Float) -> Tensor<Scalar>
Dostępne tam, gdzie `scallar`:` numeryczne '

  • Dodaje skalar do każdego skalarnego tensora i wytwarza sumę.

    Deklaracja 

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

  • Dodaje skalar do każdego skalarnego tensora i wytwarza sumę.

    Deklaracja 

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

  • Odejmuje skalar od każdego skalarnego tensora i wytwarza różnicę.

    Deklaracja 

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

  • Odejmuje skalar od każdego skalaru tensora i wytwarza różnicę

    Deklaracja 

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

  • Dodaje dwa tensory i przechowuje wynik zmiennej po lewej stronie.

    Notatka

    += obsługuje transmisję.

    Deklaracja 

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

  • Dodaje skalar do każdego skalarnego tensora i przechowuje wynik zmiennej po lewej stronie.

    Deklaracja 

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

  • Odejmuje drugi tensor od pierwszego i przechowuje wynik zmiennej po lewej stronie.

    Notatka

    -= obsługuje transmisję.

    Deklaracja 

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

  • Odejmuje skalar od każdego skalarnego tensora i przechowuje wynik zmiennej po lewej stronie.

    Deklaracja 

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

  • Zwraca tensor wytwarzany przez pomnożenie dwóch tensorów.

    Notatka

    * Obsługuje transmisję.

    Deklaracja 

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

  • Zwraca tensor poprzez pomnożenie go z każdym skalarnym tensor.

    Deklaracja 

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

  • Mnoży skalar z każdym skalarnym tensorem i wytwarza produkt.

    Deklaracja 

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

  • Mnoży dwa tensory i przechowuje wynik zmiennej po lewej stronie.

    Notatka

    *= obsługuje transmisję.

    Deklaracja 

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

  • Mnoży tensor za pomocą skalarnego, nadając skalar i przechowuje wynik w zmiennej po lewej stronie.

    Deklaracja 

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

  • Zwraca iloraz podzielenia pierwszego tensora przez drugi.

    Notatka

    / obsługuje transmisję.

    Deklaracja 

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

  • Zwraca iloraz podzielenia skalarnego przez tensor, nadawanie skalaru.

    Deklaracja 

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

  • Zwraca iloraz podzielenia tensora przez skalar, nadawanie skalaru.

    Deklaracja 

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

  • Dzieli pierwszy tensor przez drugi i przechowuje iloraz w zmiennej po lewej stronie.

    Deklaracja 

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

  • Dzieli tensor przez skalar, nadaje skalar i przechowuje iloraz w zmiennej po lewej stronie.

    Deklaracja 

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

  • Zwraca resztę podziału pierwszego tensora przez drugi.

    Notatka

    % obsługuje transmisję.

    Deklaracja 

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

  • Zwraca resztę podziału tensora przez skalar, nadając skalar.

    Deklaracja 

    public static func % (lhs: Tensor, rhs: Scalar) -> Tensor

  • Zwraca resztę podziału skalarnego przez tensor, nadawanie skalaru.

    Deklaracja 

    public static func % (lhs: Scalar, rhs: Tensor) -> Tensor

  • Dzieli pierwszy tensor przez drugi i przechowuje pozostałą część zmiennej po lewej stronie.

    Deklaracja 

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

  • Dzieli tensor przez skalar i przechowuje resztę w zmiennej po lewej stronie.

    Deklaracja 

    public static func %= (lhs: inout Tensor, rhs: Scalar)
Dostępne tam, gdzie `scallar` ==` bool`

  • Powraca !self Pod względem elementu.

    Deklaracja 

    public func elementsLogicalNot() -> Tensor

  • Zwraca self && other elementy.

    Notatka

    && obsługuje transmisję.

    Deklaracja 

    public func elementsLogicalAnd(_ other: Tensor) -> Tensor

  • Zwraca self && other element, nadawanie other .

    Deklaracja 

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

  • Zwraca self || other pod względem elementów.

    Deklaracja 

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

  • Zwraca self || other elementowe, nadawane other .

    Deklaracja 

    public func elementsLogicalOr(_ other: Scalar) -> Tensor
Dostępne tam, gdzie `scallar`:` TensorflowNumer`

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

    Deklaracja 

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

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

    Deklaracja 

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

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

    Deklaracja 

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

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

    Deklaracja 

    @differentiable(wrt: self)
public func clipped(min: Scalar, max: Scalar) -> Tensor
Dostępne tam, gdzie `scallar`:` signednumeric`

  • Zwraca negację określonego elementu tensora.

    Deklaracja 

    @differentiable
public prefix static func - (rhs: Tensor) -> Tensor
Dostępne tam, gdzie `scallar`:` numeryczne '

  • Deklaracja 

    @differentiable(wrt: self)
public func squared() -> Tensor
Dostępne tam, gdzie `scallar`:` TensorflowfloatingPoint`

  • Zwraca tensor booletowy wskazujący, które elementy x są skończone.

    Deklaracja 

    public var isFinite: Tensor<Bool> { get }

  • Zwraca tensor logiczny wskazujący, które elementy x są nieskończone.

    Deklaracja 

    public var isInfinite: Tensor<Bool> { get }

  • Zwraca tensor booletowy wskazujący, które elementy x są wartościowe NAN.

    Deklaracja 

    public var isNaN: Tensor<Bool> { get }
Dostępne tam, gdzie `scallar` ==` bool`

  • Zwraca true , jeśli wszystkie skalary są równe true . W przeciwnym razie zwraca false .

    Deklaracja 

    public func all() -> Bool

  • Zwraca true , jeśli jakiekolwiek skalary są równe true . W przeciwnym razie zwraca false .

    Deklaracja 

    public func any() -> Bool

  • Wykonuje logikę i działanie wzdłuż określonych osi. Zmniejszone wymiary są usuwane.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Wykonuje logikę i działanie wzdłuż określonych osi. Zmniejszone wymiary są usuwane.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Wykonuje logikę i działanie wzdłuż określonych osi. Zmniejszone wymiary są zatrzymywane w wartości 1.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Wykonuje logiczną lub operację wzdłuż określonych osi. Zmniejszone wymiary są zatrzymywane w wartości 1.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

Dostępne tam, gdzie `scallar`:` numeryczne '&' porównywalne '

  • Deklaracja 

    @differentiable
public func min() -> Tensor

  • Deklaracja 

    @differentiable
public func max() -> Tensor

  • Zwraca maksymalne wartości wzdłuż określonych osi. Zmniejszone wymiary są usuwane.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca maksymalne wartości wzdłuż określonych osi. Zmniejszone wymiary są usuwane.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca maksymalne wartości wzdłuż określonych osi. Zmniejszone wymiary są usuwane.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca minimalne wartości wzdłuż określonych osi. Zmniejszone wymiary są usuwane.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca minimalne wartości wzdłuż określonych osi. Zmniejszone wymiary są usuwane.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca minimalne wartości wzdłuż określonych osi. Zmniejszone wymiary są usuwane.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca wskaźniki maksymalnych wartości wzdłuż określonych osi. Zmniejszone wymiary są usuwane.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca wskaźniki wartości minimalnych wzdłuż określonych osi. Zmniejszone wymiary są usuwane.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca minimum wzdłuż określonych osi. Zmniejszone wymiary są zatrzymywane w wartości 1.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca minimum wzdłuż określonych osi. Zmniejszone wymiary są zatrzymywane w wartości 1.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca minimum wzdłuż określonych osi. Zmniejszone wymiary są zatrzymywane w wartości 1.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca minimum wzdłuż określonych osi. Zmniejszone wymiary są zatrzymywane w wartości 1.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca minimum wzdłuż określonych osi. Zmniejszone wymiary są zatrzymywane w wartości 1.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca minimum wzdłuż określonych osi. Zmniejszone wymiary są zatrzymywane w wartości 1.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca wskaźnik maksymalnej wartości spłaszczonych skalar.

    Deklaracja 

    public func argmax() -> Tensor<Int32>

  • Zwraca wskaźnik minimalnej wartości spłaszczonych skalar.

    Deklaracja 

    public func argmin() -> Tensor<Int32>
Dostępne tam, gdzie `scallar`:` numeryczne '

  • Zwraca sumę wzdłuż określonych osi. Zmniejszone wymiary są usuwane.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank...rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca sumę wzdłuż określonych osi. Zmniejszone wymiary są usuwane.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank...rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca sumę wzdłuż określonych osi. Zmniejszone wymiary są usuwane.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank...rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Deklaracja 

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

  • Zwraca sumę wzdłuż określonych osi. Zmniejszone wymiary są zatrzymywane w wartości 1.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca sumę wzdłuż określonych osi. Zmniejszone wymiary są zatrzymywane w wartości 1.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca sumę wzdłuż określonych osi. Zmniejszone wymiary są zatrzymywane w wartości 1.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca produkt wzdłuż określonych osi. Zmniejszone wymiary są usuwane.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank...rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca produkt wzdłuż określonych osi. Zmniejszone wymiary są usuwane.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank...rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca produkt wzdłuż określonych osi. Zmniejszone wymiary są usuwane.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank...rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Deklaracja 

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

  • Zwraca produkt wzdłuż określonych osi. Zmniejszone wymiary są zatrzymywane w wartości 1.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca produkt wzdłuż określonych osi. Zmniejszone wymiary są zatrzymywane w wartości 1.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca produkt wzdłuż określonych osi. Zmniejszone wymiary są zatrzymywane w wartości 1.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca średnią arytmetyczną wzdłuż określonych osi. Zmniejszone wymiary są usuwane.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank...rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca średnią arytmetyczną wzdłuż określonych osi. Zmniejszone wymiary są usuwane.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank...rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca średnią arytmetyczną wzdłuż określonych osi. Zmniejszone wymiary są usuwane.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank...rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Deklaracja 

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

  • Zwraca średnią arytmetyczną wzdłuż określonych osi. Zmniejszone wymiary są zatrzymywane w wartości 1.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca średnią arytmetyczną wzdłuż określonych osi. Zmniejszone wymiary są zatrzymywane w wartości 1.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca średnią arytmetyczną wzdłuż określonych osi. Zmniejszone wymiary są zatrzymywane w wartości 1.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca wariancję wzdłuż określonych osi. Zmniejszone wymiary są usuwane. Nie stosuje korekty Bessela.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca wariancję wzdłuż określonych osi. Zmniejszone wymiary są usuwane. Nie stosuje korekty Bessela.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca wariancję wzdłuż określonych osi. Zmniejszone wymiary są zachowywane z wartością 1. nie stosuje korekty Bessela.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Deklaracja 

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

  • Zwraca wariancję wzdłuż określonych osi. Zmniejszone wymiary są zachowywane z wartością 1. nie stosuje korekty Bessela.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca wariancję wzdłuż określonych osi. Zmniejszone wymiary są zachowywane z wartością 1. nie stosuje korekty Bessela.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca wariancję wzdłuż określonych osi. Zmniejszone wymiary są zachowywane z wartością 1. nie stosuje korekty Bessela.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca skumulowaną sumę tego tensora wzdłuż określonej osi. Domyślnie ta funkcja wykonuje inkluzyjną sumę skumulowaną, co oznacza, że ​​pierwszy element wejścia jest identyczny z pierwszym elementem wyjścia: 

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

    Ustawiając exclusive argument do true , zamiast tego wykonuje się ekskluzywna suma skumulowana: 

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

    Ustawiając reverse argument na true , suma skumulowana jest wykonywana w przeciwnym kierunku: 

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

    Jest to bardziej wydajne niż osobno odwracanie powstałego tensora.

    Warunek wstępny

    axis musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axis

    Oś wzdłuż której można wykonać skumulowaną operację suma.

    exclusive

    Wskazuje, czy wykonać wyłączną sumę skumulowaną.

    reverse

    Wskazuje, czy wykonać skumulowaną sumę w kolejności odwróconej.

    Wartość zwracana

    Wynik skumulowanej operacji suma.

  • Zwraca skumulowaną sumę tego tensora wzdłuż określonej osi. Domyślnie ta funkcja wykonuje inkluzyjną sumę skumulowaną, co oznacza, że ​​pierwszy element wejścia jest identyczny z pierwszym elementem wyjścia: 

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

    Ustawiając exclusive argument do true , zamiast tego wykonuje się ekskluzywna suma skumulowana: 

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

    Ustawiając reverse argument na true , suma skumulowana jest wykonywana w przeciwnym kierunku: 

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

    Jest to bardziej wydajne niż osobno odwracanie powstałego tensora.

    Warunek wstępny

    axis.rank musi wynosić 0 .

    Warunek wstępny

    axis musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axis

    Oś wzdłuż której można wykonać skumulowaną operację suma.

    exclusive

    Wskazuje, czy wykonać wyłączną sumę skumulowaną.

    reverse

    Wskazuje, czy wykonać skumulowaną sumę w kolejności odwróconej.

    Wartość zwracana

    Wynik skumulowanej operacji suma.

  • Zwraca skumulowany produkt tego tensora wzdłuż określonej osi. Domyślnie ta funkcja wykonuje inkluzywny produkt skumulowany, co oznacza, że ​​pierwszy element wejścia jest identyczny z pierwszym elementem wyjścia: 

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

    Ustawiając exclusive argument w true , zamiast tego wykonuje się ekskluzywny produkt skumulowany: 

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

    Ustawiając reverse argument do true , skumulowany produkt jest wykonywany w przeciwnym kierunku: 

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

    Jest to bardziej wydajne niż osobno odwracanie powstałego tensora.

    Warunek wstępny

    axis musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axis

    Oś wzdłuż której można wykonać skumulowane działanie produktu.

    exclusive

    Wskazuje, czy wykonać ekskluzywny produkt skumulowany.

    reverse

    Wskazuje, czy wykonać skumulowany produkt w kolejności odwróconej.

    Wartość zwracana

    Wynik skumulowanej działalności produktu.

  • Zwraca skumulowany produkt tego tensora wzdłuż określonej osi. Domyślnie ta funkcja wykonuje inkluzywny produkt skumulowany, co oznacza, że ​​pierwszy element wejścia jest identyczny z pierwszym elementem wyjścia: 

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

    Ustawiając exclusive argument w true , zamiast tego wykonuje się ekskluzywny produkt skumulowany: 

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

    Ustawiając reverse argument do true , skumulowany produkt jest wykonywany w przeciwnym kierunku: 

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

    Jest to bardziej wydajne niż osobno odwracanie powstałego tensora.

    Warunek wstępny

    axis musi mieć ranga 0 .

    Warunek wstępny

    axis musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axis

    Oś wzdłuż której można wykonać skumulowane działanie produktu.

    exclusive

    Wskazuje, czy wykonać ekskluzywny produkt skumulowany.

    reverse

    Wskazuje, czy wykonać skumulowany produkt w kolejności odwróconej.

    Wartość zwracana

    Wynik skumulowanej działalności produktu.

Dostępne tam, gdzie `scallar`:` TensorflowfloatingPoint`

  • Zwraca odchylenie standardowe elementów wzdłuż określonych osi. Zmniejszone wymiary są zatrzymywane w wartości 1 . Nie stosuje korekty Bessela.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca odchylenie standardowe elementów wzdłuż określonych osi. Zmniejszone wymiary są zatrzymywane w wartości 1 . Nie stosuje korekty Bessela.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca odchylenie standardowe elementów wzdłuż określonych osi. Zmniejszone wymiary są zatrzymywane w wartości 1 . Nie stosuje korekty Bessela.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca odchylenie standardowe wszystkich elementów w tym tensorze. Nie stosuje korekty Bessela.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

  • Zwraca odchylenie standardowe elementów wzdłuż określonych osi. Zmniejszone wymiary są zatrzymywane w wartości 1 . Nie stosuje korekty Bessela.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca odchylenie standardowe elementów wzdłuż określonych osi. Zmniejszone wymiary są zatrzymywane w wartości 1 . Nie stosuje korekty Bessela.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca odchylenie standardowe elementów wzdłuż określonych osi. Zmniejszone wymiary są zatrzymywane w wartości 1 . Nie stosuje korekty Bessela.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca log(exp(self).sum(squeezingAxes: axes)) . Zmniejszone wymiary są usuwane.

    Ta funkcja jest bardziej stabilna liczbowo niż log(exp(self).sum(squeezingAxes: axes)) bezpośrednio. Unika przepełnień spowodowanych obliczeniem exp dużych wejść i niedociągnięć spowodowanych obliczeniem log małych wejść.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca log(exp(self).sum(squeezingAxes: axes)) . Zmniejszone wymiary są usuwane.

    Ta funkcja jest bardziej stabilna liczbowo niż log(exp(self).sum(squeezingAxes: axes)) bezpośrednio. Unika przepełnień spowodowanych obliczeniem exp dużych wejść i niedociągnięć spowodowanych obliczeniem log małych wejść.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca log(exp(self).sum(squeezingAxes: axes)) . Zmniejszone wymiary są usuwane.

    Ta funkcja jest bardziej stabilna liczbowo niż log(exp(self).sum(squeezingAxes: axes)) bezpośrednio. Unika przepełnień spowodowanych obliczeniem exp dużych wejść i niedociągnięć spowodowanych obliczeniem log małych wejść.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca log(exp(self).sum()) . Rezultatem jest skalar.

    Ta funkcja jest bardziej stabilna liczbowo niż log(exp(self).sum()) bezpośrednio. Unika przepełnień spowodowanych obliczeniem exp dużych wejść i niedociągnięć spowodowanych obliczeniem log małych wejść.

    Deklaracja 

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

  • Zwraca log(exp(self).sum(alongAxes: axes)) . Zmniejszone wymiary są zatrzymywane w wartości 1 .

    Ta funkcja jest bardziej stabilna liczbowo niż log(exp(self).sum(alongAxes: axes)) . Unika przepełnień spowodowanych obliczeniem exp dużych wejść i niedociągnięć spowodowanych obliczeniem log małych wejść.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca log(exp(self).sum(alongAxes: axes)) . Zmniejszone wymiary są zatrzymywane w wartości 1 .

    Ta funkcja jest bardziej stabilna liczbowo niż log(exp(self).sum(alongAxes: axes)) . Unika przepełnień spowodowanych obliczeniem exp dużych wejść i niedociągnięć spowodowanych obliczeniem log małych wejść.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca log(exp(self).sum(alongAxes: axes)) . Zmniejszone wymiary są zatrzymywane w wartości 1 .

    Ta funkcja jest bardziej stabilna liczbowo niż log(exp(self).sum(alongAxes: axes)) . Unika przepełnień spowodowanych obliczeniem exp dużych wejść i niedociągnięć spowodowanych obliczeniem log małych wejść.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca średnią i wariancję tego tensora wzdłuż określonych osi. Zmniejszone wymiary są usuwane.

    Warunek wstępny

    axes muszą mieć ranga 1 .

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca średnią i wariancję tego tensora wzdłuż określonych osi. Zmniejszone wymiary są usuwane.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca średnią i wariancję tego tensora wzdłuż określonych osi. Zmniejszone wymiary są usuwane.

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca średnią i wariancję elementów tego tensora.

    Deklaracja 

    @differentiable(wrt: self)
public func moments() -> Moments<Scalar>

  • Zwraca średnią i wariancję tego tensora wzdłuż określonych osi. Zmniejszone wymiary są zatrzymywane w wartości 1 .

    Warunek wstępny

    axes muszą mieć ranga 1 .

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca średnią i wariancję tego tensora wzdłuż określonych osi. Zmniejszone wymiary są zatrzymywane w wartości 1 .

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

  • Zwraca średnią i wariancję tego tensora wzdłuż określonych osi. Zmniejszone wymiary są zatrzymywane w wartości 1 .

    Warunek wstępny

    Każda wartość w axes musi znajdować się w zakresie -rank..<rank .

    Deklaracja 

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

    Parametry

    axes

    Wymiary do zmniejszenia.

Dostępne tam, gdzie `scallar`:` numeryczne '

  • Wykonuje mnożenie macierzy między dwoma tensorami i wytwarza wynik.

    Deklaracja 

    @differentiable
public static func • (lhs: Tensor, rhs: Tensor) -> Tensor
Dostępne tam, gdzie `scallar`:` TensorflowfloatingPoint`

  • Deklaracja 

    static func vjpInitDeviceAndPrecisionLike(
  _ value: Scalar,
  deviceAndPrecisionLike tensor: Tensor
) -> (value: Tensor, pullback: (Tensor) -> (Scalar, Tensor))

  • Zwraca tensor obliczony z normalizowania wsadowego wejścia wzdłuż określonej osi.

    W szczególności zwraca (self - mu) / (var + epsilon) * gamma + beta gdzie mu i var są odpowiednio średnią i wariancją self wzdłuż axis .

    Deklaracja 

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

    Parametry

    axis

    Wymiar partii.

    offset

    Przesunięcie, znane również jako beta.

    scale

    Skala, znana również jako gamma.

    epsilon

    Niewielka wartość dodana do mianownika dla stabilności numerycznej.

  • Łączy dwa tensory wzdłuż ostatniej osi.

    Deklaracja 

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

  • Dodaje dwie wartości i wytwarza swoją sumę.

    Deklaracja 

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

  • Średnia dwie wartości.

    Deklaracja 

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

  • Mnoży dwie wartości.

    Deklaracja 

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

  • Ułóż dwie wartości.

    Deklaracja 

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

  • Deklaracja 

    @derivative
init(shape: scalars)
Dostępne tam, gdzie `scallar`:` endatable`

  • Deklaracja 

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

  • Deklaracja 

    public static func != (lhs: Tensor, rhs: Tensor) -> Bool
Dostępne tam, gdzie `scallar`:` Codable`

  • Deklaracja 

    public func encode(to encoder: Encoder) throws

  • Deklaracja 

    public init(from decoder: Decoder) throws
Dostępne tam, gdzie `scallar`:` numeryczne '

  • Tensor skalarny.

  • Deklaracja 

    public static var zero: Tensor { get }

  • Dodaje dwa tensory i wytwarza swoją sumę.

    Notatka

    + Obsługuje transmisję.

    Deklaracja 

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

  • Odejmuje jeden tensor od drugiego i wytwarza swoją różnicę.

    Notatka

    - Obsługuje transmisję.

    Deklaracja 

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

  • Tensor skalarny jeden.

    Deklaracja 

    public static var one: Tensor { get }

  • Zwraca elementarne wzajemność self .

    Deklaracja 

    public var reciprocal: Tensor { get }

  • Mnoży dwa tensory pod względem elementarnym i produkuje ich produkt.

    Notatka

    .* Obsługuje transmisję.

    Deklaracja 

    public static func .* (lhs: Tensor, rhs: Tensor) -> Tensor
Dostępne tam, gdzie `scallar`:` TensorflowfloatingPoint`

  • Deklaracja 

    public typealias TangentVector = Tensor

  • Deklaracja 

    public var zeroTangentVectorInitializer: () -> TangentVector { get }

  • Dodaje adnotację.

    Uwaga: Obsługiwane jest tylko x10. W przypadku innych backendów zwracane jest self .

    Deklaracja 

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

    Parametry

    annotation

    Adnotacja do dodania.

    Wartość zwracana

    Adnotowany tensor.

  • Deklaracja 

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