Funkcje

Poniższe funkcje są dostępne globalnie.

• l1Strata(przewidywana:oczekiwana:)
  Zwraca stratę L1 pomiędzy przewidywaniami i oczekiwaniami.

  Deklaracja

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

  Parametry

  predicted	Przewidywane wyjścia z sieci neuronowej.
  expected	Oczekiwane wartości, tj. cele, które odpowiadają prawidłowemu wynikowi.

• l2Strata(przewidywana:oczekiwana:)
  Zwraca stratę L2 pomiędzy przewidywaniami i oczekiwaniami.

  Deklaracja

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

  Parametry

  predicted	Przewidywane wyjścia z sieci neuronowej.
  expected	Oczekiwane wartości, tj. cele, które odpowiadają prawidłowemu wynikowi.

• zawiasStrata(przewidywana:oczekiwana:)
  Zwraca utratę zawiasów między przewidywaniami i oczekiwaniami.

  Deklaracja

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

  Parametry

  predicted	Przewidywane wyjścia z sieci neuronowej.
  expected	Oczekiwane wartości, tj. cele, które odpowiadają prawidłowemu wynikowi.

• SquaredHingeStrata(przewidywana:oczekiwana:)
  Zwraca kwadratową utratę zawiasów między przewidywaniami i oczekiwaniami.

  Deklaracja

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

  Parametry

  predicted	Przewidywane wyjścia z sieci neuronowej.
  expected	Oczekiwane wartości, tj. cele, które odpowiadają prawidłowemu wynikowi.

• kategoryczneStrataZawiasu(przewidywane:oczekiwane:)
  Zwraca kategoryczną utratę zawiasów między przewidywaniami i oczekiwaniami.

  Deklaracja

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

  Parametry

  predicted	Przewidywane wyjścia z sieci neuronowej.
  expected	Oczekiwane wartości, tj. cele, które odpowiadają prawidłowemu wynikowi.

• logCoshLoss(przewidywana:oczekiwana:)
  Zwraca logarytm cosinusa hiperbolicznego błędu między przewidywaniami i oczekiwaniami.

  Deklaracja

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

  Parametry

  predicted	Przewidywane wyjścia z sieci neuronowej.
  expected	Oczekiwane wartości, tj. cele, które odpowiadają prawidłowemu wynikowi.

• poissonLoss(przewidywana:oczekiwana:)
  Zwraca stratę Poissona pomiędzy przewidywaniami i oczekiwaniami.

  Deklaracja

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

  Parametry

  predicted	Przewidywane wyjścia z sieci neuronowej.
  expected	Oczekiwane wartości, tj. cele, które odpowiadają prawidłowemu wynikowi.

• kullbackLeiblerRozbieżność(przewidywana:oczekiwana:)
  Zwraca rozbieżność Kullbacka-Leiblera (rozbieżność KL) między oczekiwaniami a przewidywaniami. Biorąc pod uwagę dwa rozkłady p i q , rozbieżność KL oblicza p * log(p / q) .

  Deklaracja

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

  Parametry

  predicted	Przewidywane wyjścia z sieci neuronowej.
  expected	Oczekiwane wartości, tj. cele, które odpowiadają prawidłowemu wynikowi.

• softmaxCrossEntropy(logity: prawdopodobieństwa:)
  Zwraca entropię krzyżową softmax (entropię krzyżową kategoryczną) pomiędzy logitami i etykietami.

  Deklaracja

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

  Parametry

  logits	Zakodowane w trybie one-hot wyjścia z sieci neuronowej.
  labels	Indeksy (indeksowane od zera) prawidłowych wyjść.

• sigmoidCrossEntropy(logity: etykiety:)
  Zwraca sigmoidalną entropię krzyżową (binarną entropię krzyżową) pomiędzy logitami i etykietami.

  Deklaracja

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

  Parametry

  logits	Nieskalowane wyjście sieci neuronowej.
  labels	Wartości całkowite odpowiadające poprawnym wynikom.

• tożsamość(_:)
  Zwraca tensor o tym samym kształcie i skalarach co określony tensor.

  Deklaracja

  @differentiable
  public func identity<Scalar>(_ x: Tensor<Scalar>) -> Tensor<Scalar> where Scalar : TensorFlowScalar

• z Kontekstem(_:_:)
  Wywołuje dane zamknięcie w kontekście, który ma wszystko identyczne z bieżącym kontekstem, z wyjątkiem danej fazy uczenia się.

  Deklaracja

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

  Parametry

  context	Kontekst, który zostanie ustawiony przed wywołaniem zamknięcia i przywrócony po powrocie zamknięcia.
  body	Zamknięcie nullowe. Jeśli zamknięcie ma wartość zwracaną, wartość ta jest również używana jako wartość zwracana przez funkcję withContext(_:_:) .

  Wartość zwracana

  Wartość zwracana, jeśli istnieje, zamknięcia body .

• z fazą nauki(_:_:)
  Wywołuje dane zamknięcie w kontekście, który ma wszystko identyczne z bieżącym kontekstem, z wyjątkiem danej fazy uczenia się.

  Deklaracja

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

  Parametry

  learningPhase	Faza uczenia się, która zostanie ustawiona przed wywołaniem zamknięcia i przywrócona po powrocie zamknięcia.
  body	Zamknięcie nullowe. Jeśli zamknięcie ma wartość zwracaną, wartość ta jest również używana jako wartość zwracana przez funkcję withLearningPhase(_:_:) .

  Wartość zwracana

  Wartość zwracana, jeśli istnieje, zamknięcia body .

• withRandomSeedForTensorFlow(_:_:)
  Wywołuje dane zamknięcie w kontekście, który ma wszystko identyczne z bieżącym kontekstem, z wyjątkiem danego losowego materiału siewnego.

  Deklaracja

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

  Parametry

  randomSeed	Losowe ziarno, które zostanie ustawione przed wywołaniem zamknięcia i przywrócone po powrocie zamknięcia.
  body	Zamknięcie nullowe. Jeśli zamknięcie ma wartość zwracaną, wartość ta jest również używana jako wartość zwracana przez funkcję withRandomSeedForTensorFlow(_:_:) .

  Wartość zwracana

  Wartość zwracana, jeśli istnieje, zamknięcia body .

• withRandomNumberGeneratorForTensorFlow(_:_:)
  Wywołuje dane zamknięcie w kontekście, który ma wszystko identyczne z bieżącym kontekstem, z wyjątkiem danego generatora liczb losowych.

  Deklaracja

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

  Parametry

  randomNumberGenerator	Generator liczb losowych, który zostanie ustawiony przed wywołaniem zamknięcia i przywrócony po powrocie zamknięcia.
  body	Zamknięcie nullowe. Jeśli zamknięcie ma wartość zwracaną, wartość ta jest również używana jako wartość zwracana przez funkcję withRandomNumberGeneratorForTensorFlow(_:_:) .

  Wartość zwracana

  Wartość zwracana, jeśli istnieje, zamknięcia body .

• zamek błyskawiczny(_:_:)
  Deklaracja

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

• LazyTensorBarrier(on:urządzenia:czekaj:)
  LazyTensorBarrier zapewnia, że ​​wszystkie aktywne tensory (na urządzeniu, jeśli są dostępne) są zaplanowane i działają. Jeśli Wait jest ustawione na true, to wywołanie jest blokowane do czasu zakończenia obliczeń.

  Deklaracja

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

• wartośćZGradientem(at:in:)
  Deklaracja

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

• wartośćZGradientem(at:_:in:)
  Deklaracja

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

• wartośćZGradientem(at:_:_:in:)
  Deklaracja

  public func valueWithGradient<T, U, V, R>(
    at x: T,
    _ y: U,
    _ z: V,
    in f: @differentiable (T, U, V) -> Tensor<R>
  ) -> (value: Tensor<R>, gradient: (T.TangentVector, U.TangentVector, V.TangentVector))
  where T: Differentiable, U: Differentiable, V: Differentiable, R: TensorFlowFloatingPoint

• wartośćZGradientem(z:)
  Deklaracja

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

• wartośćZGradientem(z:)
  Deklaracja

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

• wartośćZGradientem(z:)
  Deklaracja

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

• gradient(w:w:)
  Deklaracja

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

• gradient(at:_:in:)
  Deklaracja

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

• gradient(w:_:_:w:)
  Deklaracja

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

• gradient(z:)
  Deklaracja

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

• gradient(z:)
  Deklaracja

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

• gradient(z:)
  Deklaracja

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

• withRecomputationInPullbacks(_:)
  Spraw, aby funkcja została ponownie obliczona podczas jej wycofania, co w tradycyjnym automatycznym różnicowaniu nazywa się „punktem kontrolnym”.

  Deklaracja

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

• Funkcja różniczkowalna(z:)
  Utwórz funkcję różniczkowalną na podstawie funkcji iloczynu wektorowo-jakobiańskiego.

  Deklaracja

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

• Funkcja różniczkowalna(z:)
  Utwórz funkcję różniczkowalną na podstawie funkcji iloczynu wektorowo-jakobiańskiego.

  Deklaracja

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

• bez pochodnej (at :)
  Zwraca x jak funkcję tożsamości. Gdy zostanie użyta w kontekście, w którym x jest różniczkowane względem, funkcja ta nie da żadnej pochodnej przy x .

  Deklaracja

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

• bez pochodnej (at:in:)
  Stosuje daną body zamknięcia do x . Gdy zostanie użyta w kontekście, w którym x jest różniczkowane względem, funkcja ta nie da żadnej pochodnej przy x .

  Deklaracja

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

• z urządzeniem(_:_:wykonaj:)
  Wykonuje zamknięcie, dzięki czemu operacje TensorFlow działają na określonym rodzaju urządzenia.

  Deklaracja

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

  Parametry

  kind	Rodzaj urządzenia, na którym można uruchamiać operacje TensorFlow.
  index	Urządzenie, na którym można uruchamiać operacje.
  body	Zamknięcie, którego operacje TensorFlow mają być wykonywane na określonym rodzaju urządzenia.

• withDevice(o nazwie:wykonaj:)
  Wykonuje zamknięcie, dzięki czemu operacje TensorFlow są uruchamiane na urządzeniu o określonej nazwie.

  Kilka przykładów nazw urządzeń:

  • „/device:CPU:0”: Procesor Twojej maszyny.
  • „/GPU:0”: skrócona notacja pierwszego procesora graficznego Twojej maszyny widocznego dla TensorFlow
  • „/job:localhost/replica:0/task:0/device:GPU:1”: W pełni kwalifikowana nazwa drugiego procesora graficznego Twojej maszyny, która jest widoczna dla TensorFlow.

  Deklaracja

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

  Parametry

  name	Nazwa urządzenia.
  body	Zamknięcie, którego operacje TensorFlow mają być wykonywane na określonym rodzaju urządzenia.

• z urządzeniem domyślnym (wykonaj:)
  Wykonuje zamknięcie, umożliwiając TensorFlow umieszczanie operacji TensorFlow na dowolnym urządzeniu. To powinno przywrócić domyślne zachowanie miejsca docelowego.

  Deklaracja

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

  Parametry

  body	Zamknięcie, którego operacje TensorFlow mają być wykonywane na określonym rodzaju urządzenia.

• resize(images:size:method:antalias:)
  Zmień rozmiar obrazów do odpowiedniego rozmiaru, korzystając z określonej metody.

  Warunek wstępny

  Obrazy muszą mieć rangę 3 lub 4 .

  Warunek wstępny

  Rozmiar musi być dodatni.

  Deklaracja

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

  Parametry

  images	4-D Tensor kształtu [batch, height, width, channels] lub 3-D Tensor kształtu [height, width, channels] .
  size	Nowy rozmiar obrazów.
  method	Metoda zmiany rozmiaru. Wartość domyślna to .bilinear .
  antialias	Jeśli true , użyj filtra antyaliasingowego podczas próbkowania obrazu w dół.

• resizeArea(images:size:alignCorners:)
  Zmień rozmiar obrazów do rozmiaru za pomocą interpolacji obszaru.

  Warunek wstępny

  Obrazy muszą mieć rangę 3 lub 4 .

  Warunek wstępny

  Rozmiar musi być dodatni.

  Deklaracja

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

  Parametry

  images	4-D Tensor kształtu [batch, height, width, channels] lub 3-D Tensor kształtu [height, width, channels] .
  size	Nowy rozmiar obrazów.

• dylatacja2D(_:filter:kroki:stawki:wypełnienie:)
  Zwraca dylatację 2-W z określonymi danymi wejściowymi, filtrem, krokami i dopełnieniem.

  Warunek wstępny

  input muszą mieć rangę 4 .

  Warunek wstępny

  filter musi mieć rangę 3 .

  Deklaracja

  @differentiable(wrt: (input, filter)
  public func dilation2D<Scalar: TensorFlowFloatingPoint>(
    _ input: Tensor<Scalar>,
    filter: Tensor<Scalar>,
    strides: (Int, Int, Int, Int) = (1, 1, 1, 1),
    rates: (Int, Int, Int, Int) = (1, 1, 1, 1),
    padding: Padding = .valid
  ) -> Tensor<Scalar>

  Parametry

  input	Wejście.
  filter	Filtr dylatacyjny.
  strides	Kroki filtra przesuwnego dla każdego wymiaru sygnału wejściowego.
  padding	Wyściółka do operacji
  rates	Szybkości dylatacji dla każdego wymiaru wejścia.

• erosion2D(_:filter:kroki:stawki:wypełnienie:)
  Zwraca erozję 2-W z określonymi danymi wejściowymi, filtrem, krokami i dopełnieniem.

  Warunek wstępny

  input muszą mieć rangę 4 .

  Warunek wstępny

  filter musi mieć rangę 3.

  Deklaracja

  @differentiable(wrt: (input, filter)
  public func erosion2D<Scalar: TensorFlowFloatingPoint>(
    _ input: Tensor<Scalar>,
    filter: Tensor<Scalar>,
    strides: (Int, Int, Int, Int) = (1, 1, 1, 1),
    rates: (Int, Int, Int, Int) = (1, 1, 1, 1),
    padding: Padding = .valid
  ) -> Tensor<Scalar>

  Parametry

  input	Wejście.
  filter	Filtr erozyjny.
  strides	Kroki filtra przesuwnego dla każdego wymiaru sygnału wejściowego.
  padding	Wyściółka do operacji
  rates	Szybkości dylatacji dla każdego wymiaru wejścia.

• zera()
  Zwraca funkcję, która tworzy tensor, inicjując wszystkie jego wartości na zera.

  Deklaracja

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

• stałaInitializer(wartość:)
  Zwraca funkcję, która tworzy tensor, inicjując wszystkie jego wartości podaną wartością.

  Deklaracja

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

• stałaInitializer(wartość:)
  Zwraca funkcję, która tworzy tensor, inicjując go podaną wartością. Należy pamiętać, że rozgłaszanie podanej wartości nie jest obsługiwane.

  Deklaracja

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

• glorotUniform(nasiona:)
  Zwraca funkcję, która tworzy tensor, wykonując równomierną inicjalizację Glorota (Xaviera) dla określonego kształtu, losowo próbkując wartości skalarne z rozkładu jednorodnego pomiędzy -limit i limit , wygenerowanego przez domyślny generator liczb losowych, gdzie limit to sqrt(6 / (fanIn + fanOut)) i fanIn / fanOut reprezentują liczbę cech wejściowych i wyjściowych pomnożoną przez pole recepcyjne, jeśli występuje.

  Deklaracja

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

• glorotNormal(nasiono:)
  Zwraca funkcję, która tworzy tensor, wykonując inicjalizację normalną Glorota (Xaviera) dla określonego kształtu, losowo próbkując wartości skalarne z obciętego rozkładu normalnego wyśrodkowanego na 0 z odchyleniem standardowym sqrt(2 / (fanIn + fanOut)) , gdzie fanIn / fanOut reprezentują liczbę cech wejściowych i wyjściowych pomnożoną przez rozmiar pola recepcyjnego, jeśli występuje.

  Deklaracja

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

• onUniform(nasiona:)
  Zwraca funkcję, która tworzy tensor, wykonując równomierną inicjalizację He (Kaiminga) dla określonego kształtu, losowo próbkując wartości skalarne z rozkładu równomiernego pomiędzy -limit i limit , wygenerowanego przez domyślny generator liczb losowych, gdzie limit to sqrt(6 / fanIn) , a fanIn reprezentuje liczbę cech wejściowych pomnożoną przez pole recepcyjne, jeśli występuje.

  Deklaracja

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

• onNormalny(nasiono:)
  Zwraca funkcję, która tworzy tensor, wykonując inicjalizację normalną He (Kaiminga) dla określonego kształtu, losowo próbkując wartości skalarne z obciętego rozkładu normalnego wyśrodkowanego na 0 z odchyleniem standardowym sqrt(2 / fanIn) , gdzie fanIn reprezentuje liczbę cech wejściowych pomnożona przez wielkość pola recepcyjnego, jeśli występuje.

  Deklaracja

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

• leCunUniform(nasiono:)
  Zwraca funkcję, która tworzy tensor, wykonując równomierną inicjalizację LeCun dla określonego kształtu, losowo próbkując wartości skalarne z rozkładu równomiernego pomiędzy -limit i limit , wygenerowanego przez domyślny generator liczb losowych, gdzie limit to sqrt(3 / fanIn) i fanIn reprezentuje liczbę cech wejściowych pomnożoną przez pole recepcyjne, jeśli występuje.

  Deklaracja

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

• leCunNormal(nasiono:)
  Zwraca funkcję, która tworzy tensor, wykonując normalną inicjalizację LeCun dla określonego kształtu, losowo próbkując wartości skalarne z obciętego rozkładu normalnego wyśrodkowanego na 0 z odchyleniem standardowym sqrt(1 / fanIn) , gdzie fanIn reprezentuje liczbę cech wejściowych pomnożoną przez wielkość pola recepcyjnego, jeśli występuje.

  Deklaracja

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

• obciętyNormalInitializer(średnia:standardoweOdchylenie:nasiono:)
  Zwraca funkcję, która tworzy tensor, inicjując losowo wszystkie jego wartości z obciętego rozkładu normalnego. Wygenerowane wartości mają rozkład normalny ze średnią mean i odchyleniem standardowym standardDeviation , z tą różnicą, że wartości, których wielkość jest większa niż dwa odchylenia standardowe od średniej, są odrzucane i ponownie próbkowane.

  Deklaracja

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

  Parametry

  mean	Średnia rozkładu normalnego.
  standardDeviation	Odchylenie standardowe rozkładu normalnego.

  Wartość zwracana

  Obcięta funkcja inicjatora parametrów normalnych.

• ==(_:_:)
  Deklaracja

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

• oko(wierszIlość:kolumnaLiczba:partiaKształt:włączony:)
  Zwraca macierz tożsamości lub grupę macierzy.

  Deklaracja

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

  Parametry

  rowCount	Liczba wierszy w każdej macierzy wsadowej.
  columnCount	Liczba kolumn w każdej macierzy wsadowej.
  batchShape	Wiodące wymiary partii zwróconego tensora.

• namierzać(_:)
  Oblicza ślad opcjonalnie macierzy wsadowej. Ślad to suma wzdłuż głównej przekątnej każdej najbardziej wewnętrznej macierzy.

  Dane wejściowe to tensor o kształcie [..., M, N] . Wynikiem jest tensor o kształcie [...] .

  Warunek wstępny

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

  Deklaracja

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

  Parametry

  matrix

  Tensor kształtu [..., M, N] .

• choleski(_:)
  Zwraca rozkład Cholesky'ego jednej lub większej liczby macierzy kwadratowych.

  Dane wejściowe to tensor kształtu [..., M, M] , którego 2 najbardziej wewnętrzne wymiary tworzą macierze kwadratowe.

  Sygnał wejściowy musi być symetryczny i dodatnio określony. Do tej operacji zostanie użyta tylko dolna trójkątna część wejścia. Górna część trójkątna nie zostanie odczytana.

  Wyjściem jest tensor o tym samym kształcie co wejście zawierające rozkłady Choleskiego dla wszystkich wejściowych podmacierzy [..., :, :] .

  Deklaracja

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

  Parametry

  input

  Tensor kształtu [..., M, M] .

• trójkątnyRozwiąż(macierz:prawa:dolna:dołączona:)
  Zwraca rozwiązanie x do układu równań liniowych reprezentowanego przez Ax = b .

  Warunek wstępny

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

  Warunek wstępny

  rhs musi być tensorem o kształcie [..., M, K] .

  Deklaracja

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

  Parametry

  matrix	Wejściowa macierz współczynników trójkątnych reprezentująca A w Ax = b .
  rhs	Wartości po prawej stronie, reprezentujące b w Ax = b .
  lower	Określa, czy matrix jest dolna trójkątna ( true ), czy górna ( false ). Wartość domyślna to true .
  adjoint	Jeśli true , rozwiąż za pomocą sprzężenia matrix zamiast matrix . Wartość domyślna to false .

  Wartość zwracana

  Rozwiązanie x układu równań liniowych reprezentowanego przez Ax = b . x ma taki sam kształt jak b .

• l1Strata(przewidywana:oczekiwana:redukcja:)
  Oblicza stratę L1 pomiędzy expected i predicted . loss = reduction(abs(expected - predicted))

  Deklaracja

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

  Parametry

  predicted	Przewidywane wyjścia z sieci neuronowej.
  expected	Oczekiwane wartości, tj. cele, które odpowiadają prawidłowemu wynikowi.
  reduction	Redukcja stosowana do obliczonych wartości strat elementarnych.

• l2Strata(przewidywana:oczekiwana:redukcja:)
  Oblicza stratę L2 pomiędzy expected i predicted . loss = reduction(square(expected - predicted))

  Deklaracja

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

  Parametry

  predicted	Przewidywane wyjścia z sieci neuronowej.
  expected	Oczekiwane wartości, tj. cele, które odpowiadają prawidłowemu wynikowi.
  reduction	Redukcja stosowana do obliczonych wartości strat elementarnych.

• meanAbsoluteError (przewidywany: oczekiwany :)
  Oblicza średnią różnicę bezwzględną między etykietami i przewidywaniami. loss = mean(abs(expected - predicted))

  Deklaracja

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

  Parametry

  predicted	Przewidywane wyjścia z sieci neuronowej.
  expected	Oczekiwane wartości, tj. cele, które odpowiadają prawidłowemu wynikowi.

• meanSquaredError (przewidywany: oczekiwany :)
  Oblicza średnią kwadratów błędów między etykietami i przewidywaniami. loss = mean(square(expected - predicted))

  Deklaracja

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

  Parametry

  predicted	Przewidywane wyjścia z sieci neuronowej.
  expected	Oczekiwane wartości, tj. cele, które odpowiadają prawidłowemu wynikowi.

• meanSquaredLogarithmicError (przewidywany: oczekiwany :)
  Oblicza średniokwadratowy błąd logarytmiczny między loss = square(log(expected) - log(predicted)) predicted a expected = kwadrat (log(oczekiwany) - log(przewidywany))

  Notatka

  Ujemne wpisy tensora zostaną ograniczone do 0 , aby uniknąć niezdefiniowanego zachowania logarytmicznego, ponieważ log(_:) jest niezdefiniowany dla ujemnych liczb rzeczywistych.

  Deklaracja

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

  Parametry

  predicted	Przewidywane wyjścia z sieci neuronowej.
  expected	Oczekiwane wartości, tj. cele, które odpowiadają prawidłowemu wynikowi.

• meanAbsolutePercentageError (przewidywany: oczekiwany :)
  Oblicza średni bezwzględny błąd procentowy pomiędzy predicted a expected . loss = 100 * mean(abs((expected - predicted) / abs(expected)))

  Deklaracja

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

  Parametry

  predicted	Przewidywane wyjścia z sieci neuronowej.
  expected	Oczekiwane wartości, tj. cele, które odpowiadają prawidłowemu wynikowi.

• zawiasStrata(przewidywana:oczekiwana:redukcja:)
  Oblicza utratę zawiasów pomiędzy predicted a expected . loss = reduction(max(0, 1 - predicted * expected)) oczekuje się, że expected wartości będą wynosić -1 lub 1.

  Deklaracja

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

  Parametry

  predicted	Przewidywane wyjścia z sieci neuronowej.
  expected	Oczekiwane wartości, tj. cele, które odpowiadają prawidłowemu wynikowi.
  reduction	Redukcja stosowana do obliczonych wartości strat elementarnych.

• kwadrat StrataZawiasu(przewidywana:oczekiwana:redukcja:)
  Oblicza kwadratową utratę zawiasów między predicted a expected . loss = reduction(square(max(0, 1 - predicted * expected))) oczekuje się, że expected wartości będą wynosić -1 lub 1.

  Deklaracja

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

  Parametry

  predicted	Przewidywane wyjścia z sieci neuronowej.
  expected	Oczekiwane wartości, tj. cele, które odpowiadają prawidłowemu wynikowi.
  reduction	Redukcja stosowana do obliczonych wartości strat elementarnych.

• kategoryczneStrataZawiasu(przewidywana:oczekiwana:redukcja:)
  Oblicza kategoryczną utratę zawiasów pomiędzy predicted i expected . loss = maximum(negative - positive + 1, 0) gdzie negative = max((1 - expected) * predicted) i positive = sum(predicted * expected)

  Deklaracja

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

  Parametry

  predicted	Przewidywane wyjścia z sieci neuronowej.
  expected	Oczekiwane wartości, tj. cele, które odpowiadają prawidłowemu wynikowi.
  reduction	Redukcja stosowana do obliczonych wartości strat elementarnych.

• logCoshLoss(przewidywana:oczekiwana:redukcja:)
  Oblicza logarytm cosinusa hiperbolicznego błędu przewidywania. logcosh = log((exp(x) + exp(-x))/2) , gdzie x to predicted - expected

  Deklaracja

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

  Parametry

  predicted	Przewidywane wyjścia z sieci neuronowej.
  expected	Oczekiwane wartości, tj. cele, które odpowiadają prawidłowemu wynikowi.
  reduction	Redukcja stosowana do obliczonych wartości strat elementarnych.

• poissonLoss(przewidywana:oczekiwana:redukcja:)
  Oblicza stratę Poissona pomiędzy przewidywaną a oczekiwaną. Strata Poissona jest średnią elementów Tensor predicted - expected * log(predicted) .

  Deklaracja

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

  Parametry

  predicted	Przewidywane wyjścia z sieci neuronowej.
  expected	Oczekiwane wartości, tj. cele, które odpowiadają prawidłowemu wynikowi.
  reduction	Redukcja stosowana do obliczonych wartości strat elementarnych.

• kullbackLeiblerRozbieżność(przewidywana:oczekiwana:redukcja:)
  Oblicza stratę dywergencji Kullbacka-Leiblera pomiędzy expected i predicted . loss = reduction(expected * log(expected / predicted))

  Deklaracja

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

  Parametry

  predicted	Przewidywane wyjścia z sieci neuronowej.
  expected	Oczekiwane wartości, tj. cele, które odpowiadają prawidłowemu wynikowi.
  reduction	Redukcja stosowana do obliczonych wartości strat elementarnych.

• softmaxCrossEntropy(logity: etykiety: redukcja:)
  Oblicza rzadką entropię krzyżową softmax (kategoryczną entropię krzyżową) między logitami i etykietami. Użyj tej funkcji utraty entropii krzyżowej, jeśli istnieją dwie lub więcej klas etykiet. Oczekujemy, że etykiety będą podawane jako liczby całkowite. Powinno istnieć # classes wartości zmiennoprzecinkowych na cechę dla logits i pojedynczą wartość zmiennoprzecinkową na cechę w przypadku expected .

  Deklaracja

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

  Parametry

  logits	Zakodowane w trybie one-hot wyjścia z sieci neuronowej.
  labels	Indeksy (indeksowane od zera) prawidłowych wyjść.
  reduction	Redukcja stosowana do obliczonych wartości strat elementarnych.

• softmaxCrossEntropy(logity:prawdopodobieństwa:redukcja:)
  Oblicza rzadką entropię krzyżową softmax (kategoryczną entropię krzyżową) między logitami i etykietami. Użyj tej funkcji utraty entropii krzyżowej, jeśli istnieją dwie lub więcej klas etykiet. Oczekujemy, że etykiety będą dostarczane w reprezentacji one_hot . Na każdą funkcję powinno przypadać # classes wartości zmiennoprzecinkowych.

  Deklaracja

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

  Parametry

  logits	Nieskalowane prawdopodobieństwa dziennika z sieci neuronowej.
  probabilities	Wartości prawdopodobieństwa odpowiadające prawidłowemu wynikowi. Każdy wiersz musi być prawidłowym rozkładem prawdopodobieństwa.
  reduction	Redukcja stosowana do obliczonych wartości strat elementarnych.

• sigmoidCrossEntropy(logity:etykiety:redukcja:)
  Oblicza sigmoidalną entropię krzyżową (binarną entropię krzyżową) między logitami i etykietami. Użyj tej straty między entropią, gdy istnieją tylko dwie klasy etykiet (przyjmuje się, że są to 0 i 1). W każdym przykładzie powinna istnieć jedna wartość zmiennoprzecinkowa na prognozę.

  Deklaracja

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

  Parametry

  logits	Nieskalowane wyjście sieci neuronowej.
  labels	Wartości całkowite odpowiadające poprawnym wynikom.
  reduction	Redukcja stosowana do obliczonych wartości strat elementarnych.

• huberLoss(przewidywana:oczekiwana:delta:redukcja:)
  Oblicza stratę Hubera pomiędzy predicted i expected .

  Dla każdej wartości x w error = expected - predicted :

  • 0.5 * x^2 jeśli |x| <= δ .

  • 0.5 * δ^2 + δ * (|x| - δ) w przeciwnym razie.

  • Źródło: artykuł w Wikipedii .

  Deklaracja

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

  Parametry

  predicted	Przewidywane wyjścia z sieci neuronowej.
  expected	Oczekiwane wartości, tj. cele, które odpowiadają prawidłowemu wynikowi.
  delta	Skalar zmiennoprzecinkowy reprezentujący punkt, w którym funkcja straty Hubera zmienia się z kwadratowej na liniową.
  reduction	Redukcja stosowana do obliczonych wartości strat elementarnych.

• brzuch(_:)
  Zwraca wartość bezwzględną określonego elementu tensora.

  Deklaracja

  @differentiable
  public func abs<T>(_ x: Tensor<T>) -> Tensor<T> where T : SignedNumeric, T : TensorFlowScalar

• dziennik(_:)
  Zwraca logarytm naturalny określonego tensora według elementu.

  Deklaracja

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

• log2(_:)
  Zwraca logarytm o podstawie dwóch określonego elementu tensora.

  Deklaracja

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

• log10(_:)
  Zwraca logarytm dziesiętny określonego tensora w ujęciu elementowym.

  Deklaracja

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

• log1p(_:)
  Zwraca logarytm 1 + x w ujęciu elementowym.

  Deklaracja

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

• log1mexp(_:)
  Zwraca log(1 - exp(x)) przy użyciu metody stabilnej numerycznie.

  Notatka

  Podejście to pokazano w równaniu 7 w: https://cran.r-project.org/web/packages/Rmpfr/vignettes/log1mexp-note.pdf .

  Deklaracja

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

• grzech(_:)
  Zwraca sinus określonego tensora według elementu.

  Deklaracja

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

• sałata(_:)
  Zwraca cosinus określonego tensora według elementu.

  Deklaracja

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

• dębnik(_:)
  Zwraca tangens określonego elementu tensora.

  Deklaracja

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

• sinh(_:)
  Zwraca sinus hiperboliczny określonego elementu tensora.

  Deklaracja

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

• pałka(_:)
  Zwraca cosinus hiperboliczny określonego elementu tensora.

  Deklaracja

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

• taak(_:)
  Zwraca tangens hiperboliczny określonego elementu tensora.

  Deklaracja

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

• ako(_:)
  Zwraca odwrotny cosinus określonego elementu tensora.

  Deklaracja

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

• jak w(_:)
  Zwraca odwrotny sinus określonego elementu tensora.

  Deklaracja

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

• atan(_:)
  Zwraca odwrotną tangens określonego elementu tensora.

  Deklaracja

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

• akosz(_:)
  Zwraca odwrotny cosinus hiperboliczny określonego elementu tensora.

  Deklaracja

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

• asinh(_:)
  Zwraca odwrotny sinus hiperboliczny określonego elementu tensora.

  Deklaracja

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

• racja(_:)
  Zwraca odwrotny tangens hiperboliczny określonego elementu tensora.

  Deklaracja

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

• sqrt(_:)
  Zwraca pierwiastek kwadratowy z określonego elementu tensora.

  Deklaracja

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

• rsqrt(_:)
  Zwraca odwrotny pierwiastek kwadratowy określonego elementu tensora.

  Deklaracja

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

• do potęgi(_:)
  Zwraca wykładniczy określonego elementu tensora.

  Deklaracja

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

• eksp2(_:)
  Zwraca dwa podniesione do potęgi określonego tensora według elementu.

  Deklaracja

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

• exp10(_:)
  Zwraca dziesięć podniesionych do potęgi określonego tensora według elementu.

  Deklaracja

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

• expm1(_:)
  Zwraca wykładniczą x - 1 elementowo.

  Deklaracja

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

• okrągły(_:)
  Zwraca wartości określonego tensora zaokrąglone do najbliższej liczby całkowitej, według elementów.

  Deklaracja

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

• stropować(_:)
  Zwraca pułap określonego tensora według elementu.

  Deklaracja

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

• podłoga(_:)
  Zwraca podłogę określonego elementu tensora.

  Deklaracja

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

• podpisać(_:)
  Zwraca wskazanie znaku określonego tensora według elementu. W szczególności oblicza y = sign(x) = -1 jeśli x < 0 ; 0 jeśli x == 0 ; 1 jeśli x > 0 .

  Deklaracja

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

• esowata(_:)
  Zwraca sigmoidę określonego elementu tensora. W szczególności oblicza 1 / (1 + exp(-x)) .

  Deklaracja

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

• logSigmoid(_:)
  Zwraca log-esigmoidę określonego elementu tensora. W szczególności log(1 / (1 + exp(-x))) . Aby zapewnić stabilność numeryczną, używamy -softplus(-x) .

  Deklaracja

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

• miękkiplus(_:)
  Zwraca softplus określonego elementu tensora. W szczególności oblicza log(exp(features) + 1) .

  Deklaracja

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

• miękki znak(_:)
  Zwraca znak programowy określonego elementu tensora. W szczególności oblicza features/ (abs(features) + 1) .

  Deklaracja

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

• softmax(_:)
  Zwraca softmax określonego tensora wzdłuż ostatniej osi. W szczególności oblicza exp(x) / exp(x).sum(alongAxes: -1) .

  Deklaracja

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

• softmax(_:wzdłużOsi:)
  Zwraca softmax określonego tensora wzdłuż określonej osi. W szczególności oblicza exp(x) / exp(x).sum(alongAxes: axis) .

  Deklaracja

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

• logSoftmax(_:)
  Zwraca log-softmax określonego elementu tensora.

  Deklaracja

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

• elu(_:)
  Zwraca tensor poprzez zastosowanie wykładniczej jednostki liniowej. W szczególności oblicza exp(x) - 1 jeśli < 0, x w przeciwnym razie. Zobacz szybkie i dokładne uczenie się głębokiej sieci za pomocą wykładniczych jednostek liniowych (ELU)

  Deklaracja

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

• żel(_:)
  Zwraca aktywację jednostki liniowej błędu Gaussa (GELU) określonego elementu tensora.

  W szczególności gelu przybliża xP(X <= x) , gdzie P(X <= x) jest standardowym skumulowanym rozkładem Gaussa, obliczając: x * [0,5 * (1 + tanh[√(2/π) * (x + 0,044715 * x^3)])].

  Zobacz Jednostki liniowe błędu Gaussa .

  Deklaracja

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

• relu(_:)
  Zwraca tensor poprzez zastosowanie funkcji aktywacji ReLU do określonego elementu tensora. W szczególności oblicza max(0, x) .

  Deklaracja

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

• relu6(_:)
  Zwraca tensor poprzez zastosowanie funkcji aktywacji ReLU6, a mianowicie min(max(0, x), 6) .

  Deklaracja

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

• nieszczelnyRelu(_:alfa:)
  Zwraca tensor poprzez zastosowanie nieszczelnej funkcji aktywacji ReLU do określonego elementu tensora. W szczególności oblicza max(x, x * alpha) .

  Deklaracja

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

• selu(_:)
  Zwraca tensor poprzez zastosowanie funkcji aktywacji SeLU, a mianowicie scale * alpha * (exp(x) - 1) jeśli x < 0 i scale * x w przeciwnym razie.

  Notatka

  Jest to przeznaczone do użycia razem z inicjatorami warstwy skalowania wariancji. Więcej informacji można znaleźć w artykule Samonormalizujące się sieci neuronowe .

  Deklaracja

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

• śmigać(_:)
  Zwraca tensor poprzez zastosowanie funkcji aktywacji Swish, a mianowicie x * sigmoid(x) .

  Źródło: „Searching for Activation Functions” (Ramachandran et al. 2017) https://arxiv.org/abs/1710.05941

  Deklaracja

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

• twardySigmoid(_:)
  Zwraca tensor poprzez zastosowanie twardej funkcji aktywacji sigmoidy, a mianowicie Relu6(x+3)/6 .

  Źródło: „Searching for MobileNetV3” (Howard et al. 2019) https://arxiv.org/abs/1905.02244

  Deklaracja

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

• twardySwish(_:)
  Zwraca tensor poprzez zastosowanie funkcji aktywacji twardego swish, a mianowicie x * Relu6(x+3)/6 .

  Źródło: „Searching for MobileNetV3” (Howard et al. 2019) https://arxiv.org/abs/1905.02244

  Deklaracja

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

• mich(_:)
  Zwraca tensor poprzez zastosowanie funkcji aktywacji mish, a mianowicie x * tanh(softplus(x)) .

  Źródło: „Mish: samoregulująca, niemonotoniczna funkcja aktywacji neuronowej” https://arxiv.org/abs/1908.08681

  Deklaracja

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

• pow(_:_:)
  Zwraca potęgę pierwszego tensora do drugiego tensora.

  Deklaracja

  @differentiable
  public func pow<T>(_ lhs: Tensor<T>, _ rhs: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

• pow(_:_:)
  Zwraca moc skalara do tensora, emitując skalar.

  Deklaracja

  @differentiable(wrt: rhs)
  public func pow<T>(_ lhs: T, _ rhs: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

• pow(_:_:)
  Zwraca moc tensora do skalara, emitując skalar.

  Deklaracja

  @differentiable(wrt: lhs)
  public func pow<T>(_ lhs: Tensor<T>, _ rhs: T) -> Tensor<T> where T : TensorFlowFloatingPoint

• pow(_:_:)
  Zwraca moc tensora do skalara, emitując skalar.

  Deklaracja

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

• źródło(_:_:)
  Zwraca elementarny n ty pierwiastek tensora.

  Deklaracja

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

• kwadratowa różnica(_:_:)
  Zwraca kwadratową różnicę między x i y .

  Deklaracja

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

  Wartość zwracana

  (x - y) ^ 2 .

• maks.(_:_:)
  Zwraca elementowe maksimum dwóch tensorów.

  Notatka

  max obsługuje nadawanie.

  Deklaracja

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

• maks.(_:_:)
  Zwraca elementowe maksimum skalara i tensora, emitując skalar.

  Deklaracja

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

• maks.(_:_:)
  Zwraca elementowe maksimum skalara i tensora, emitując skalar.

  Deklaracja

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

• min(_:_:)
  Zwraca elementarne minimum dwóch tensorów.

  Notatka

  min obsługuje nadawanie.

  Deklaracja

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

• min(_:_:)
  Zwraca elementarne minimum skalara i tensora, emitując skalar.

  Deklaracja

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

• min(_:_:)
  Zwraca elementarne minimum skalara i tensora, emitując skalar.

  Deklaracja

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

• cosinusPodobieństwo(_:_:)
  Zwraca cosinus podobieństwa między x i y .

  Deklaracja

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

• cosinusOdległość(_:_:)
  Zwraca odległość cosinus między x i y . Odległość cosinus definiuje się jako 1 - cosineSimilarity(x, y) .

  Deklaracja

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

• matmul(_:transponowane:_:transponowane:)
  Wykonuje mnożenie macierzy przez inny tensor i daje wynik.

  Deklaracja

  @differentiable
  public func matmul<Scalar: Numeric>(
    _ lhs: Tensor<Scalar>,
    transposed transposeLhs: Bool = false,
    _ rhs: Tensor<Scalar>,
    transposed transposeRhs: Bool = false
  ) -> Tensor<Scalar>

• conv1D(_:filter:krok:wypełnienie:rozszerzenie:)
  Zwraca splot 1-D z określonymi danymi wejściowymi, filtrem, krokiem i dopełnieniem.

  Warunek wstępny

  input muszą mieć rangę 3 .

  Warunek wstępny

  filter musi mieć rangę 3.

  Deklaracja

  @differentiable(wrt: (input, filter)
  public func conv1D<Scalar: TensorFlowFloatingPoint>(
    _ input: Tensor<Scalar>,
    filter: Tensor<Scalar>,
    stride: Int = 1,
    padding: Padding = .valid,
    dilation: Int = 1
  ) -> Tensor<Scalar>

  Parametry

  input	Wejście.
  filter	Filtr splotowy.
  stride	Krok przesuwanego filtra.
  padding	Wyściółka do operacji.
  dilation	Współczynnik dylatacji.

• conv2D(_:filter:kroki:wypełnienie:rozszerzenia:)
  Zwraca splot 2-D z określonymi danymi wejściowymi, filtrem, krokami i dopełnieniem.

  Warunek wstępny

  input muszą mieć rangę 4 .

  Warunek wstępny

  filter musi mieć rangę 4.

  Deklaracja

  @differentiable(wrt: (input, filter)
  public func conv2D<Scalar: TensorFlowFloatingPoint>(
    _ input: Tensor<Scalar>,
    filter: Tensor<Scalar>,
    strides: (Int, Int, Int, Int) = (1, 1, 1, 1),
    padding: Padding = .valid,
    dilations: (Int, Int, Int, Int) = (1, 1, 1, 1)
  ) -> Tensor<Scalar>

  Parametry

  input	Wejście.
  filter	Filtr splotowy.
  strides	Kroki filtra przesuwnego dla każdego wymiaru sygnału wejściowego.
  padding	Wyściółka do operacji
  dilations	Współczynnik dylatacji dla każdego wymiaru wejściowego.

• transposedConv2D(_:shape:filter:kroki:wypełnienie:rozszerzenia:)
  Zwraca transponowany splot 2-D z określonymi danymi wejściowymi, filtrem, krokami i dopełnieniem.

  Warunek wstępny

  input muszą mieć rangę 4 .

  Warunek wstępny

  filter musi mieć rangę 4.

  Deklaracja

  @differentiable(wrt: (input, filter)
  public func transposedConv2D<Scalar: TensorFlowFloatingPoint>(
    _ input: Tensor<Scalar>,
    shape: [Int64],
    filter: Tensor<Scalar>,
    strides: (Int, Int, Int, Int) = (1, 1, 1, 1),
    padding: Padding = .valid,
    dilations: (Int, Int, Int, Int) = (1, 1, 1, 1)
  ) -> Tensor<Scalar>

  Parametry

  input	Wejście.
  shape	Kształt wyjściowy operacji dekonwolucji.
  filter	Filtr splotowy.
  strides	Kroki filtra przesuwnego dla każdego wymiaru sygnału wejściowego.
  padding	Wyściółka do operacji
  dilations	Współczynnik dylatacji dla każdego wymiaru wejściowego.

• conv3D(_:filter:kroki:wypełnienie:rozszerzenia:)
  Zwraca splot 3-W z określonymi danymi wejściowymi, filtrem, krokami, dopełnieniem i rozszerzeniami.

  Warunek wstępny

  input muszą mieć rangę 5 .

  Warunek wstępny

  filter musi mieć rangę 5.

  Deklaracja

  @differentiable(wrt: (input, filter)
  public func conv3D<Scalar: TensorFlowFloatingPoint>(
    _ input: Tensor<Scalar>,
    filter: Tensor<Scalar>,
    strides: (Int, Int, Int, Int, Int) = (1, 1, 1, 1, 1),
    padding: Padding = .valid,
    dilations: (Int, Int, Int, Int, Int) = (1, 1, 1, 1, 1)
  ) -> Tensor<Scalar>

  Parametry

  input	Wejście.
  filter	Filtr splotowy.
  strides	Kroki filtra przesuwnego dla każdego wymiaru sygnału wejściowego.
  padding	Wyściółka do operacji.
  dilations	Współczynnik dylatacji dla każdego wymiaru wejściowego.

• deepwiseConv2D(_:filter:kroki:wypełnienie:)
  Zwraca splot wgłębny 2-D z określonymi danymi wejściowymi, filtrem, krokami i dopełnieniem.

  Warunek wstępny

  input muszą mieć rangę 4.

  Warunek wstępny

  filter musi mieć rangę 4.

  Deklaracja

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

  Parametry

  input	Wejście.
  filter	Głęboko filtr splotowy.
  strides	Kroki filtra przesuwnego dla każdego wymiaru sygnału wejściowego.
  padding	Wyściółka do operacji.

• maxPool2D(_:filterSize:kroki:wypełnienie:)
  Zwraca maksymalną pulę 2-D z określonymi rozmiarami filtrów, krokami i dopełnieniem.

  Deklaracja

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

  Parametry

  input	Wejście.
  filterSize	Wymiary jądra łączenia.
  strides	Kroki filtra przesuwnego dla każdego wymiaru sygnału wejściowego.
  padding	Wyściółka do operacji.

• maxPool3D(_:filterSize:kroki:wypełnienie:)
  Zwraca maksymalną pulę 3-D z określonymi rozmiarami filtrów, krokami i dopełnieniem.

  Deklaracja

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

  Parametry

  input	Wejście.
  filterSize	Wymiary jądra łączenia.
  strides	Kroki filtra przesuwnego dla każdego wymiaru sygnału wejściowego.
  padding	Wyściółka do operacji.

• avgPool2D(_:filterSize:kroki:wypełnienie:)
  Zwraca średnią pulę 2-D z określonymi rozmiarami filtrów, krokami i dopełnieniem.

  Deklaracja

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

  Parametry

  input	Wejście.
  filterSize	Wymiary jądra łączenia.
  strides	Kroki filtra przesuwnego dla każdego wymiaru sygnału wejściowego.
  padding	Wyściółka do operacji.

• avgPool3D(_:filterSize:kroki:wypełnienie:)
  Zwraca średnią pulę 3-W z określonymi rozmiarami filtrów, krokami i dopełnieniem.

  Deklaracja

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

  Parametry

  input	Wejście.
  filterSize	Wymiary jądra łączenia.
  strides	Kroki filtra przesuwnego dla każdego wymiaru sygnału wejściowego.
  padding	Wyściółka do operacji.

• FractionalMaxPool2D(_:poolingRatio:pseudoRandom:overlapping:deterministic:seed:seed2:)
  Zwraca ułamkową maksymalną pulę 2-D z określonymi współczynnikami puli.

  Uwaga: fractionalMaxPool nie ma implementacji XLA i dlatego może mieć wpływ na wydajność.

  Deklaracja

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

  Parametry

  input	Tensor. 4-D z kształtem [batch, height, width, channels] .
  poolingRatio	Lista Doubles . Współczynnik łączenia dla każdego wymiaru input , obecnie obsługuje tylko wymiar wierszy i kolumn i powinien wynosić >= 1,0.
  pseudoRandom	Opcjonalny Bool . Domyślnie jest to false . Po ustawieniu na true generuje sekwencję łączenia w sposób pseudolosowy, w przeciwnym razie w sposób losowy.
  overlapping	Opcjonalny Bool . Domyślnie jest to false . Ustawienie na true oznacza, że ​​podczas łączenia wartości na granicy sąsiednich komórek łączenia są używane przez obie komórki.
  deterministic	Opcjonalny Bool . Po ustawieniu na true podczas iteracji po węźle FractionalMaxPool2D na wykresie obliczeniowym używany będzie stały region puli.
  seed	Opcjonalny Int64 . Domyślnie 0 . Jeśli ustawiona jest na wartość różną od zera, generator liczb losowych jest zaszczepiany danym ziarnem.
  seed2	Opcjonalny Int64 . Domyślnie 0 . Drugie ziarno, aby uniknąć kolizji nasion.

• głębokośćDo Przestrzeni(_:blockSize:)
  Zwraca kopię input , w których wartości z wymiaru głębokości są przenoszone w blokach przestrzennych do wymiarów wysokość i szerokość.

  Na przykład, biorąc pod uwagę dane wejściowe kształtu [1, 2, 2, 1] , data_format = „NHWC” i block_size = 2:

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

  Ta operacja wygeneruje tensor kształtu [1, 1, 1, 4] :

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

  Tutaj dane wejściowe mają partię 1, a każdy element partii ma kształt [2, 2, 1] , odpowiednie wyjście będzie miało pojedynczy element (tzn. szerokość i wysokość wynoszą 1) i będzie miało głębokość 4 kanałów (1 * rozmiar_bloku * rozmiar_bloku). Kształt elementu wyjściowego to [1, 1, 4] .

  Dla tensora wejściowego o większej głębokości, tutaj o kształcie [1, 2, 2, 3] , np.

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

  Ta operacja, dla block_size równej 2, zwróci następujący tensor kształtu [1, 1, 1, 12]

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

  Podobnie dla następującego wprowadzenia kształtu [1 4 4 1] i rozmiaru bloku wynoszącego 2:

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

  operator zwróci następujący tensor kształtu [1 2 2 4] :

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

  Warunek wstępny

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

  Warunek wstępny

  Liczba cech musi być podzielna przez kwadrat b .

  Deklaracja

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

• spaceToDepth(_:blockSize:)
  Zwraca kopię input , w których wartości z wymiarów wysokości i szerokości są przenoszone do wymiaru głębokości.

  Na przykład, biorąc pod uwagę dane wejściowe kształtu [1, 2, 2, 1] , data_format = „NHWC” i block_size = 2:

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

  Ta operacja wygeneruje tensor kształtu [1, 1, 1, 4] :

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

  Tutaj dane wejściowe mają partię 1, a każdy element partii ma kształt [2, 2, 1] , odpowiednie wyjście będzie miało pojedynczy element (tzn. szerokość i wysokość wynoszą 1) i będzie miało głębokość 4 kanałów (1 * rozmiar_bloku * rozmiar_bloku). Kształt elementu wyjściowego to [1, 1, 4] .

  Dla tensora wejściowego o większej głębokości, tutaj o kształcie [1, 2, 2, 3] , np.

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

  Ta operacja, dla block_size równej 2, zwróci następujący tensor kształtu [1, 1, 1, 12]

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

  Podobnie dla następującego wprowadzenia kształtu [1 4 4 1] i rozmiaru bloku wynoszącego 2:

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

  operator zwróci następujący tensor kształtu [1 2 2 4] :

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

  Warunek wstępny

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

  Warunek wstępny

  Wysokość danych wejściowych musi być podzielna przez b .

  Warunek wstępny

  Szerokość danych wejściowych musi być podzielna przez b .

  Deklaracja

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

• makeLARS(learningRate:momentum:trustCooperative:nesterov:epsilon:weightDecay:)
  Tworzy optymalizator wagowy dla LARS ( https://arxiv.org/pdf/1708.03888.pdf ).

  Deklaracja

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

• makeSGD(learningRate:pęd:wagaDecay:nesterov:)
  Tworzy optymalizator wagowy oparty na SGD.

  Deklaracja

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

• makeAdam(learningRate:beta1:beta2:weightDecayRate:epsilon:)
  Tworzy optymalizator wagowy dla Adama ze spadkiem masy ciała.

  Odniesienie: „Adam – metoda optymalizacji stochastycznej”

  Deklaracja

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

• randomSeedForTensorFlow (używając:)
  Generuje nowe losowe ziarno dla TensorFlow.

  Deklaracja

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

• powiązać(_:_:)
  Łączy dwie wartości.

  Deklaracja

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

• suma(_:_:)
  Dodaje dwie wartości i generuje ich sumę.

  Deklaracja

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

• przeciętny(_:_:)
  Średnia dwie wartości.

  Deklaracja

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

• zwielokrotniać(_:_:)
  Mnoży dwie wartości.

  Deklaracja

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

• stos(_:_:)
  Ułóż dwie wartości.

  Deklaracja

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

• Printx10metrics ()
  Deklaracja

  public func PrintX10Metrics()

• FormatStatistics (_ :)
  Tworzy podsumowanie ciągów listy statystyk szkoleniowych i testowych.

  Deklaracja

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

• FormatStatistics (Train: Test :)
  Deklaracja

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

• RunnThreads (_: _ :)
  Mapuje funkcję nad n wątkami.

  Deklaracja

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