Funkcje

Następujące funkcje są dostępne globalnie.

• l1Loss (przewidywane: oczekiwane :)

  Zwraca stratę L1 między przewidywaniami a 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 dane wyjściowe z sieci neuronowej.
  expected	Oczekiwane wartości, tj. Cele, które odpowiadają poprawnemu wynikowi.

• l2Loss (przewidywane: oczekiwane :)

  Zwraca stratę L2 między przewidywaniami a 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 dane wyjściowe z sieci neuronowej.
  expected	Oczekiwane wartości, tj. Cele, które odpowiadają poprawnemu wynikowi.

• hingeLoss (przewidywane: oczekiwane :)

  Zwraca utratę zawiasów między przewidywaniami a 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 dane wyjściowe z sieci neuronowej.
  expected	Oczekiwane wartości, tj. Cele, które odpowiadają poprawnemu wynikowi.

• squaredHingeLoss (przewidywany: oczekiwany :)

  Zwraca kwadratową utratę zawiasów między przewidywaniami a 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 dane wyjściowe z sieci neuronowej.
  expected	Oczekiwane wartości, tj. Cele, które odpowiadają poprawnemu wynikowi.

• categoricalHingeLoss (przewidywane: oczekiwane :)

  Zwraca kategoryczną utratę zawiasów między przewidywaniami a 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 dane wyjściowe z sieci neuronowej.
  expected	Oczekiwane wartości, tj. Cele, które odpowiadają poprawnemu wynikowi.

• logCoshLoss (przewidywane: oczekiwane :)

  Zwraca logarytm cosinusa hiperbolicznego błędu między przewidywaniami a 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 dane wyjściowe z sieci neuronowej.
  expected	Oczekiwane wartości, czyli cele, które odpowiadają poprawnemu wynikowi.

• poissonLoss (przewidywany: oczekiwany :)

  Zwraca stratę Poissona między przewidywaniami a 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 dane wyjściowe z sieci neuronowej.
  expected	Oczekiwane wartości, tj. Cele, które odpowiadają poprawnemu wynikowi.

• kullbackLeiblerDivergence (przewidywane: oczekiwane :)

  Zwraca dywergencję Kullbacka-Leiblera (dywergencję KL) między oczekiwaniami a przewidywaniami. Mając dwa rozkłady p i q , dywergencja 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 dane wyjściowe z sieci neuronowej.
  expected	Oczekiwane wartości, tj. Cele, które odpowiadają poprawnemu wynikowi.

• softmaxCrossEntropy (logity: prawdopodobieństwa :)

  Zwraca entropię krzyżową softmax (kategoryczną entropię krzyżową) między logitami i etykietami.

  Deklaracja

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

  Parametry

  logits	Zakodowane na gorąco wyjścia z sieci neuronowej.
  labels	Indeksy (indeksowane zerami) prawidłowych wyników.

• sigmoidCrossEntropy (logity: etykiety :)

  Zwraca sigmoidalną entropię krzyżową (binarną entropię krzyżową) mię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	Nieskalowany wynik sieci neuronowej.
  labels	Wartości całkowite, które odpowiadają poprawnemu wyjściu.

• 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

• withContext (_: _ :)

  Wywołuje dane zamknięcie w kontekście, który ma wszystko identyczne z obecnym 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 zerowe. Jeśli zamknięcie ma wartość zwracaną, ta wartość jest również używana jako wartość zwracana przez funkcję withContext(_:_:) .

  Wartość zwracana

  Wartość powrotnego, jeżeli występuje, body zamknięcia.

• withLearningPhase (_: _ :)

  Wywołuje dane zamknięcie w kontekście, który ma wszystko identyczne z obecnym 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 zerowe. Jeśli zamknięcie zwraca wartość, ta wartość jest również używana jako wartość zwracana przez funkcję withLearningPhase(_:_:) .

  Wartość zwracana

  Wartość powrotnego, jeżeli występuje, body zamknięcia.

• withRandomSeedForTensorFlow (_: _ :)

  Wywołuje dane zamknięcie w kontekście, który ma wszystko identyczne z bieżącym kontekstem, z wyjątkiem danego losowego ziarna.

  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 zerowe. Jeśli zamknięcie ma wartość zwracaną, ta wartość jest również używana jako wartość zwracana przez funkcję withRandomSeedForTensorFlow(_:_:) .

  Wartość zwracana

  Wartość powrotnego, jeżeli występuje, body zamknięcia.

• withRandomNumberGeneratorForTensorFlow (_: _ :)

  Wywołuje dane zamknięcie w kontekście, który ma wszystko identyczne z bieżącym kontekstem, z wyjątkiem podanego 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 zerowe. Jeśli zamknięcie ma wartość zwracaną, ta wartość jest również używana jako wartość zwracana przez funkcję withRandomNumberGeneratorForTensorFlow(_:_:) .

  Wartość zwracana

  Wartość powrotnego, jeżeli występuje, body zamknięcia.

• zamek błyskawiczny(_:_:)

  Deklaracja

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

• LazyTensorBarrier (na: urządzenia: czekaj :)

  LazyTensorBarrier zapewnia, że ​​wszystkie tensory na żywo (na urządzeniu, jeśli są dostępne) są zaplanowane i działają. Jeśli parametr wait jest ustawiony na true, to wywołanie blokuje się do zakończenia obliczeń.

  Deklaracja

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

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

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

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

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

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

• valueWithGradient (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 (o: w :)

  Deklaracja

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

• gradient (o: _: 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 (o: _: _: 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 w jej wycofaniu, znanym jako „punkt kontrolny” w tradycyjnym automatycznym różnicowaniu.

  Deklaracja

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

• różniczkowalna funkcja (od :)

  Utwórz różniczkowalną funkcję z wektorowo-jakobianowej funkcji iloczynu.

  Deklaracja

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

• różniczkowalna funkcja (od :)

  Utwórz różniczkowalną funkcję z wektorowo-jakobianowej funkcji iloczynu.

  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

• withoutDerivative (at :)

  Zwraca x jak funkcję tożsamości. W przypadku użycia w kontekście, w którym różnicuje się x w odniesieniu do, funkcja ta nie wytworzy żadnej pochodnej przy x .

  Deklaracja

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

• withoutDerivative (at: in :)

  Stosuje danego zamknięcia body do x . W przypadku użycia w kontekście, w którym różnicuje się x w odniesieniu do, funkcja ta nie wytworzy żadnej pochodnej przy x .

  Deklaracja

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

• withDevice (_: _: perform :)

  Wykonuje zamknięcie, dzięki czemu operacje TensorFlow są uruchamiane 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 do uruchamiania operacji.
  body	Zamknięcie, którego operacje TensorFlow mają być wykonywane na określonym rodzaju urządzenia.

• withDevice (o nazwie: perform :)

  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 twojego komputera.
  • „/ GPU: 0”: notacja krótka wskazująca na pierwszy GPU w komputerze, który jest widoczny dla TensorFlow
  • „/ Job: localhost / replica: 0 / task: 0 / device: GPU: 1”: w pełni kwalifikowana nazwa drugiego procesora graficznego w komputerze, 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.

• withDefaultDevice (wykonaj :)

  Wykonuje zamknięcie, umożliwiając TensorFlow umieszczenie operacji TensorFlow na dowolnym urządzeniu. Powinno to przywrócić domyślne zachowanie umieszczania.

  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: metoda: antialias :)

  Zmień rozmiar obrazów do rozmiaru przy użyciu 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 antyaliasingu podczas próbkowania obrazu w dół.

• resizeArea (images: size: alignCorners :)

  Zmień rozmiar obrazów na rozmiar za pomocą interpolacji obszarów.

  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.

• dilation2D (_: filter: strides: rate: padding :)

  Zwraca dylatację 2-w z określonymi danymi wejściowymi, filtrem, krokami i dopełnieniem.

  Warunek wstępny

  input musi 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 rozszerzający.
  strides	Kroki filtra ślizgowego dla każdego wymiaru wejścia.
  padding	Wypełnienie dla operacji
  rates	Współczynniki dylatacji dla każdego wymiaru wkładu.

• erosion2D (_: filter: strides: rate: padding :)

  Zwraca erozję 2-w z określonymi danymi wejściowymi, filtrem, krokami i dopełnieniem.

  Warunek wstępny

  input musi 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 erozji.
  strides	Kroki filtra ślizgowego dla każdego wymiaru wejścia.
  padding	Wypełnienie dla operacji
  rates	Współczynniki dylatacji dla każdego wymiaru wkładu.

• zera ()

  Zwraca funkcję, która tworzy tensor, inicjując wszystkie jego wartości zerami.

  Deklaracja

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

• constantInitializer (wartość :)

  Zwraca funkcję, która tworzy tensor, inicjując wszystkie jego wartości do podanej wartości.

  Deklaracja

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

• constantInitializer (wartość :)

  Zwraca funkcję, która tworzy tensor, inicjując go do podanej wartości. Należy pamiętać, że nadawanie podanej wartości nie jest obsługiwane.

  Deklaracja

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

• glorotUniform (ziarno :)

  Zwraca funkcję, która tworzy tensor, wykonując jednorodną inicjalizację Glorota (Xavier) dla określonego kształtu, losowo próbkując wartości skalarne z jednolitego rozkładu między -limit i limit , generowane przez domyślny generator liczb losowych, gdzie limit to sqrt(6 / (fanIn + fanOut)) i fanIn / fanOut reprezentują liczbę funkcji wejściowych i wyjściowych pomnożoną przez pole odbiorcze, jeśli występuje.

  Deklaracja

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

• glorotNormal (ziarno :)

  Zwraca funkcję, która tworzy tensor, wykonując normalną inicjalizację Glorota (Xavier) 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ę funkcji wejściowych i wyjściowych pomnożoną przez rozmiar pola odbiorczego, jeśli występuje.

  Deklaracja

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

• heUniform (ziarno :)

  Zwraca funkcję, która tworzy tensor, wykonując inicjalizację jednolitą He (Kaiming) dla określonego kształtu, losowo próbkując wartości skalarne z jednolitego rozkładu między -limit i limit , generowane przez domyślny generator liczb losowych, gdzie limit to sqrt(6 / fanIn) , a fanIn reprezentuje liczbę funkcji wejściowych pomnożoną przez pole odbiorcze, jeśli występuje.

  Deklaracja

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

• heNormal (seed :)

  Zwraca funkcję, która tworzy tensor, wykonując normalną inicjalizację He (Kaiming) 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ę funkcji wejściowych pomnożone przez rozmiar pola receptywnego, jeśli występuje.

  Deklaracja

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

• leCunUniform (ziarno :)

  Zwraca funkcję, która tworzy tensor, wykonując jednorodną inicjalizację LeCun dla określonego kształtu, losowo próbkując wartości skalarne z jednolitego rozkładu między -limit i limit , generowane przez domyślny generator liczb losowych, gdzie limit to sqrt(3 / fanIn) , oraz fanIn reprezentuje liczbę funkcji wejściowych pomnożoną przez pole receptywne, jeśli występuje.

  Deklaracja

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

• leCunNormal (nasiona :)

  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ę funkcji wejściowych pomnożoną przez wielkość pola receptywnego, jeśli występuje.

  Deklaracja

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

• truncatedNormalInitializer (mean: standardDeviation: seed :)

  Zwraca funkcję, która tworzy tensor, inicjując losowo wszystkie jego wartości z obciętego rozkładu normalnego. Wygenerowane wartości są zgodne z rozkładem normalnym ze średnią mean i odchyleniem standardowym odchylenia standardDeviation , z tym wyjątkiem, że wartości, których wielkość jest większa niż dwa odchylenia standardowe od średniej, są pomijane 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 normalna funkcja inicjatora parametrów.

• == (_: _ :)

  Deklaracja

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

• eye (rowCount: columnCount: batchShape: on :)

  Zwraca macierz tożsamości lub zestaw 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 partii.
  columnCount	Liczba kolumn w każdej macierzy partii.
  batchShape	Wiodące wymiary partii zwracanego tensora.

• ślad(_:)

  Oblicza ślad opcjonalnej macierzy wsadowej. Ślad jest sumą wzdłuż głównej przekątnej każdej najbardziej wewnętrznej macierzy.

  Wejście to tensor o kształcie [..., M, N] . Wyjście to 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] .

• cholesky (_ :)

  Zwraca rozkład Choleskiego jednej lub więcej macierzy kwadratowych.

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

  Wejście musi być symetryczne i określone dodatnio. Do tej operacji będzie używana tylko dolna trójkątna część wejścia. Górna trójkątna część nie zostanie odczytana.

  Dane wyjściowe to tensor o tym samym kształcie, co wejście zawierające dekompozycje Choleskiego dla wszystkich podmacierzy wejściowych [..., :, :] .

  Deklaracja

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

  Parametry

  input

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

• triangularSolve (matrix: rhs: lower: adjoint :)

  Zwraca rozwiązanie x do układu równań liniowych reprezentowanych 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	Trójkątna macierz współczynników wejściowych, reprezentująca A w Ax = b .
  rhs	Wartości po prawej stronie, reprezentujące b w Ax = b .
  lower	Czy matrix jest dolna trójkątna ( true ) czy górna trójkątna ( false ). Wartość domyślna to true .
  adjoint	Jeśli true , rozwiąż z łącznikiem matrix zamiast matrix . Wartość domyślna to false .

  Wartość zwracana

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

• l1 Strata (przewidywana: oczekiwana: redukcja :)

  Oblicza stratę L1 między expected a 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 dane wyjściowe z sieci neuronowej.
  expected	Oczekiwane wartości, tj. Cele, które odpowiadają poprawnemu wynikowi.
  reduction	Redukcja do zastosowania na obliczonych wartościach strat elementarnych.

• l2Loss (przewidywane: oczekiwane: redukcja :)

  Oblicza stratę L2 między expected a 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 dane wyjściowe z sieci neuronowej.
  expected	Oczekiwane wartości, czyli cele, które odpowiadają poprawnemu wynikowi.
  reduction	Redukcja do zastosowania na obliczonych wartościach strat elementarnych.

• meanAbsoluteError (przewidywane: oczekiwane :)

  Oblicza średnią bezwzględną różnicę 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 dane wyjściowe z sieci neuronowej.
  expected	Oczekiwane wartości, tj. Cele, które odpowiadają poprawnemu wynikowi.

• meanSquaredError (przewidywane: oczekiwane :)

  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 dane wyjściowe z sieci neuronowej.
  expected	Oczekiwane wartości, tj. Cele, które odpowiadają poprawnemu wynikowi.

• meanSquaredLogarithmicError (przewidywane: oczekiwane :)

  Oblicza średni kwadratowy błąd logarytmiczny między predicted a expected loss = square(log(expected) - log(predicted))

  Uwaga

  Ujemne wpisy tensorów zostaną obcięte na 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 dane wyjściowe z sieci neuronowej.
  expected	Oczekiwane wartości, tj. Cele, które odpowiadają poprawnemu wynikowi.

• meanAbsolutePercentageError (przewidywane: oczekiwane :)

  Oblicza średni bezwzględny błąd procentowy mię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 dane wyjściowe z sieci neuronowej.
  expected	Oczekiwane wartości, tj. Cele, które odpowiadają poprawnemu wynikowi.

• hingeLoss (przewidywane: oczekiwane: redukcja :)

  Oblicza utratę zawiasów między predicted a expected . loss = reduction(max(0, 1 - predicted * expected)) expected wartości to -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 dane wyjściowe z sieci neuronowej.
  expected	Oczekiwane wartości, tj. Cele, które odpowiadają poprawnemu wynikowi.
  reduction	Redukcja, która ma zastosowanie do obliczonych wartości strat elementarnych.

• squaredHingeLoss (przewidywany: oczekiwany: redukcja :)

  Oblicza kwadratową utratę zawiasów między predicted a expected . loss = reduction(square(max(0, 1 - predicted * expected))) expected wartości to -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 dane wyjściowe z sieci neuronowej.
  expected	Oczekiwane wartości, tj. Cele, które odpowiadają poprawnemu wynikowi.
  reduction	Redukcja, która ma zastosowanie do obliczonych wartości strat elementarnych.

• categoricalHingeLoss (przewidywane: oczekiwane: redukcja :)

  Oblicza kategoryczną utratę zawiasów między predicted a 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 dane wyjściowe z sieci neuronowej.
  expected	Oczekiwane wartości, tj. Cele, które odpowiadają poprawnemu wynikowi.
  reduction	Redukcja, która ma zastosowanie do obliczonych wartości strat elementarnych.

• logCoshLoss (przewidywane: oczekiwane: redukcja :)

  Oblicza logarytm cosinusa hiperbolicznego błędu przewidywania. logcosh = log((exp(x) + exp(-x))/2) , gdzie x to predicted - expected błąd 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 dane wyjściowe z sieci neuronowej.
  expected	Oczekiwane wartości, tj. Cele, które odpowiadają poprawnemu wynikowi.
  reduction	Redukcja, która ma zastosowanie do obliczonych wartości strat elementarnych.

• poissonLoss (przewidywane: oczekiwane: redukcja :)

  Oblicza stratę Poissona między przewidywaną a oczekiwaną Strata Poissona jest średnią elementów predicted - expected * log(predicted) 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 dane wyjściowe z sieci neuronowej.
  expected	Oczekiwane wartości, tj. Cele, które odpowiadają poprawnemu wynikowi.
  reduction	Redukcja, która ma zastosowanie do obliczonych wartości strat elementarnych.

• kullbackLeiblerDivergence (przewidywane: oczekiwane: redukcja :)

  Oblicza stratę dywergencji Kullbacka-Leiblera między expected a 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 dane wyjściowe z sieci neuronowej.
  expected	Oczekiwane wartości, tj. Cele, które odpowiadają poprawnemu wynikowi.
  reduction	Redukcja do zastosowania na obliczonych wartościach 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 crossentropy, gdy istnieją co najmniej dwie klasy etykiet. Oczekujemy, że etykiety będą dostarczane jako liczby całkowite. Powinno istnieć # classes wartości zmiennoprzecinkowych na funkcję dla logits i jedna wartość zmiennoprzecinkowa na cechę dla 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 na gorąco wyjścia z sieci neuronowej.
  labels	Indeksy (indeksowane zerami) prawidłowych wyników.
  reduction	Redukcja do zastosowania na obliczonych wartościach 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 krzyżowej, gdy istnieją co najmniej dwie klasy etykiet. Oczekujemy, że etykiety będą dostarczane w postaci reprezentacji one_hot . Dla każdego elementu powinno być # 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 w dzienniku z sieci neuronowej.
  probabilities	Wartości prawdopodobieństwa, które odpowiadają poprawnemu wynikowi. Każdy wiersz musi być prawidłowym rozkładem prawdopodobieństwa.
  reduction	Redukcja, która ma zastosowanie do obliczonych wartości strat elementarnych.

• sigmoidCrossEntropy (logity: etykiety: redukcja :)

  Oblicza sigmoidalną entropię krzyża (binarną entropię krzyżową) między logitami i etykietami. Użyj tej utraty entropii krzyżowej, gdy istnieją tylko dwie klasy etykiet (zakładane jako 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	Nieskalowany wynik sieci neuronowej.
  labels	Wartości całkowite, które odpowiadają poprawnemu wyjściu.
  reduction	Redukcja do zastosowania na obliczonych wartościach strat elementarnych.

• huberLoss (przewidywane: oczekiwane: delta: redukcja :)

  Oblicza stratę Hubera między predicted a expected .

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

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

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

  • Ź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 dane wyjściowe z sieci neuronowej.
  expected	Oczekiwane wartości, tj. Cele, które odpowiadają poprawnemu wynikowi.
  delta	Zmiennoprzecinkowy skalar reprezentujący punkt, w którym funkcja straty Hubera zmienia się z kwadratowej na liniową.
  reduction	Redukcja, która ma zastosowanie do obliczonych wartości strat elementarnych.

• abs (_ :)

  Zwraca wartość bezwzględną określonego elementu tensora.

  Deklaracja

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

• log(_:)

  Zwraca logarytm naturalny określonego elementu tensora.

  Deklaracja

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

• log2 (_ :)

  Zwraca logarytm o podstawie dwa określonego elementu tensora.

  Deklaracja

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

• log10 (_ :)

  Zwraca logarytm dziesiętny z określonego elementu tensora.

  Deklaracja

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

• log1p (_ :)

  Zwraca logarytm 1 + x elementarny.

  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.

  Uwaga

  Podejście to pokazano w równaniu 7 z: 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 elementu tensora.

  Deklaracja

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

• sałata(_:)

  Zwraca cosinus określonego elementu tensora.

  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

• tanh (_ :)

  Zwraca styczną hiperboliczną określonego elementu tensora.

  Deklaracja

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

• acos (_ :)

  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

• acosh (_ :)

  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

• atanh (_ :)

  Zwraca odwrotną styczną hiperboliczną 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 z określonego elementu tensora.

  Deklaracja

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

• exp (_ :)

  Zwraca wykładniczą wartość określonego elementu tensora.

  Deklaracja

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

• exp2 (_ :)

  Zwraca dwa podniesione do potęgi określonego elementu tensora.

  Deklaracja

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

• exp10 (_ :)

  Zwraca dziesięć podniesionych do potęgi określonego elementu tensora.

  Deklaracja

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

• expm1 (_ :)

  Zwraca wykładniczą wartość x - 1 elementarnie.

  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 elementu tensora.

  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

• znak(_:)

  Zwraca wskazanie znaku określonego elementu tensora. 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

• sigmoid (_ :)

  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 logarytmiczną sigmoidę określonego elementu tensora. W szczególności log(1 / (1 + exp(-x))) . Aby uzyskać stabilność numeryczną, używamy -softplus(-x) .

  Deklaracja

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

• softplus (_ :)

  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

• softsign (_ :)

  Zwraca miękki znak 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 (_: alongAxis :)

  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, stosując wykładniczą jednostkę liniową. W szczególności oblicza exp(x) - 1 jeśli <0, w przeciwnym razie x . Zobacz szybkie i dokładne głębokie uczenie sieciowe według wykładniczych jednostek liniowych (ELU)

  Deklaracja

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

• gelu (_ :)

  Zwraca aktywacje Gaussian Error Linear Unit (GELU) dla określonego elementu tensora.

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

  Zobacz błąd Gaussian Error Linear Units .

  Deklaracja

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

• relu (_ :)

  Zwraca tensor, stosując funkcję 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

• leakyRelu (_: alpha :)

  Zwraca tensor, stosując nieszczelną funkcję 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 przez zastosowanie funkcji aktywacji SeLU, a mianowicie scale * alpha * (exp(x) - 1) if x < 0 , oraz scale * x inaczej.

  Uwaga

  Jest to przeznaczone do użytku 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 przez 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

• hardSigmoid (_ :)

  Zwraca tensor przez zastosowanie funkcji aktywacji twardej esicy, 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

• hardSwish (_ :)

  Zwraca tensor przez zastosowanie funkcji aktywacji hard 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

• mish (_ :)

  Zwraca tensor przez zastosowanie funkcji aktywacji mish, a mianowicie x * tanh(softplus(x)) .

  Źródło: „Mish: Samouregulowana, niemonotoniczna funkcja aktywacji neuronów” https://arxiv.org/abs/1908.08681

  Deklaracja

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

• pow (_: _ :)

  Zwraca moc 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, transmitują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, transmitują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, transmitując skalar.

  Deklaracja

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

• korzeń(_:_:)

  Zwraca n ty pierwiastek tensora pod względem elementu.

  Deklaracja

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

• squaredDifference (_: _ :)

  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 .

• max (_: _ :)

  Zwraca maksymalnie dwa tensory w odniesieniu do elementów.

  Uwaga

  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

• max (_: _ :)

  Zwraca elementarne maksimum skalara i tensora, transmitując skalar.

  Deklaracja

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

• max (_: _ :)

  Zwraca elementarne maksimum skalara i tensora, transmitują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 minimum dwóch tensorów pod względem elementu.

  Uwaga

  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, transmitują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, transmitując skalar.

  Deklaracja

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

• cosineSimilarity (_: _ :)

  Zwraca podobieństwo cosinusowe między x i y .

  Deklaracja

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

• cosineDistance (_: _ :)

  Zwraca odległość cosinusa między x i y . Odległość cosinusowa definiowana jest jako 1 - cosineSimilarity(x, y) .

  Deklaracja

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

• matmul (_: transposed: _: transposed :)

  Wykonuje mnożenie macierzy z innym tensorem i zwraca 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: stride: padding: dilation :)

  Zwraca splot 1-D z określonym wejściem, filtrem, krokiem i dopełnieniem.

  Warunek wstępny

  input musi 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 splotu.
  stride	Krok przesuwanego filtra.
  padding	Wypełnienie dla operacji.
  dilation	Współczynnik dylatacji.

• conv2D (_: filter: strides: padding: dilations :)

  Zwraca splot dwuwymiarowy z określonym wejściem, filtrem, krokami i dopełnieniem.

  Warunek wstępny

  input musi 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 splotu.
  strides	Kroki filtra ślizgowego dla każdego wymiaru wejścia.
  padding	Wypełnienie dla operacji
  dilations	Współczynnik dylatacji dla każdego wymiaru wejścia.

• transposedConv2D (_: shape: filter: strides: padding: dilations :)

  Zwraca transponowany splot 2-w z określonym wejściem, filtrem, krokami i dopełnieniem.

  Warunek wstępny

  input musi 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	Wyjściowy kształt operacji dekonwolucji.
  filter	Filtr splotu.
  strides	Kroki filtra ślizgowego dla każdego wymiaru wejścia.
  padding	Wypełnienie dla operacji
  dilations	Współczynnik dylatacji dla każdego wymiaru wejścia.

• conv3D (_: filter: strides: padding: dilations :)

  Zwraca trójwymiarowy splot z określonym wejściem, filtrem, krokami, dopełnieniem i dylatacjami.

  Warunek wstępny

  input musi 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 splotu.
  strides	Kroki filtra ślizgowego dla każdego wymiaru wejścia.
  padding	Wypełnienie dla operacji.
  dilations	Współczynnik dylatacji dla każdego wymiaru wejścia.

• depthwiseConv2D (_: filter: strides: padding :)

  Zwraca dwuwymiarowy splot wgłębny z określonym wejściem, filtrem, krokami i dopełnieniem.

  Warunek wstępny

  input musi 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	Filtr splotu wgłębnego.
  strides	Kroki filtra ślizgowego dla każdego wymiaru wejścia.
  padding	Wypełnienie dla operacji.

• maxPool2D (_: filterSize: strides: padding :)

  Zwraca maksymalne pule 2-w z określonymi rozmiarami filtrów, krokami i dopełnieniem.

  Declaration

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

  Parameters

  input	The input.
  filterSize	The dimensions of the pooling kernel.
  strides	The strides of the sliding filter for each dimension of the input.
  padding	The padding for the operation.

• maxPool3D(_:filterSize:strides:padding:)

  Returns a 3-D max pooling, with the specified filter sizes, strides, and padding.

  Declaration

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

  Parameters

  input	The input.
  filterSize	The dimensions of the pooling kernel.
  strides	The strides of the sliding filter for each dimension of the input.
  padding	The padding for the operation.

• avgPool2D(_:filterSize:strides:padding:)

  Returns a 2-D average pooling, with the specified filter sizes, strides, and padding.

  Declaration

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

  Parameters

  input	The input.
  filterSize	The dimensions of the pooling kernel.
  strides	The strides of the sliding filter for each dimension of the input.
  padding	The padding for the operation.

• avgPool3D(_:filterSize:strides:padding:)

  Returns a 3-D average pooling, with the specified filter sizes, strides, and padding.

  Declaration

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

  Parameters

  input	The input.
  filterSize	The dimensions of the pooling kernel.
  strides	The strides of the sliding filter for each dimension of the input.
  padding	The padding for the operation.

• fractionalMaxPool2D(_:poolingRatio:pseudoRandom:overlapping:deterministic:seed:seed2:)

  Returns a 2-D fractional max pooling, with the specified pooling ratios.

  Note: fractionalMaxPool does not have an XLA implementation, and thus may have performance implications.

  Declaration

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

  Parameters

  input	A Tensor. 4-D with shape [batch, height, width, channels] .
  poolingRatio	A list of Doubles . Pooling ratio for each dimension of input , currently only supports row and col dimension and should be >= 1.0.
  pseudoRandom	An optional Bool . Defaults to false . When set to true , generates the pooling sequence in a pseudorandom fashion, otherwise, in a random fashion.
  overlapping	An optional Bool . Defaults to false . When set to true , it means when pooling, the values at the boundary of adjacent pooling cells are used by both cells.
  deterministic	An Optional Bool . When set to true , a fixed pooling region will be used when iterating over a fractionalMaxPool2D node in the computation graph.
  seed	An optional Int64 . Defaults to 0 . If set to be non-zero, the random number generator is seeded by the given seed.
  seed2	An optional Int64 . Defaults to 0 . A second seed to avoid seed collision.

• depthToSpace(_:blockSize:)

  Returns a copy of input where values from the depth dimension are moved in spatial blocks to the height and width dimensions.

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

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

  This operation will output a tensor of shape [1, 1, 1, 4] :

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

  Here, the input has a batch of 1 and each batch element has shape [2, 2, 1] , the corresponding output will have a single element (ie width and height are both 1) and will have a depth of 4 channels (1 * block_size * block_size). The output element shape is [1, 1, 4] .

  For an input tensor with larger depth, here of shape [1, 2, 2, 3] , eg

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

  This operation, for block_size of 2, will return the following tensor of shape [1, 1, 1, 12]

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

  Similarly, for the following input of shape [1 4 4 1] , and a block size of 2:

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

  the operator will return the following tensor of shape [1 2 2 4] :

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

  Precondition

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

  Precondition

  The number of the features must be divisible by square of b .

  Declaration

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

• spaceToDepth(_:blockSize:)

  Returns a copy of input where values from the height and width dimensions are moved to the depth dimension.

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

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

  This operation will output a tensor of shape [1, 1, 1, 4] :

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

  Here, the input has a batch of 1 and each batch element has shape [2, 2, 1] , the corresponding output will have a single element (ie width and height are both 1) and will have a depth of 4 channels (1 * block_size * block_size). The output element shape is [1, 1, 4] .

  For an input tensor with larger depth, here of shape [1, 2, 2, 3] , eg

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

  This operation, for block_size of 2, will return the following tensor of shape [1, 1, 1, 12]

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

  Similarly, for the following input of shape [1 4 4 1] , and a block size of 2:

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

  the operator will return the following tensor of shape [1 2 2 4] :

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

  Precondition

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

  Precondition

  The height of the input must be divisible by b .

  Precondition

  The width of the input must be divisible by b .

  Declaration

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

• makeLARS(learningRate:momentum:trustCoefficient:nesterov:epsilon:weightDecay:)

  Builds a per-weight optimizer for LARS ( https://arxiv.org/pdf/1708.03888.pdf ).

  Declaration

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

• makeSGD(learningRate:momentum:weightDecay:nesterov:)

  Builds a SGD based per-weight optimizer.

  Declaration

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

• makeAdam(learningRate:beta1:beta2:weightDecayRate:epsilon:)

  Builds a per-weight optimizer for Adam with weight decay.

  Reference: “Adam - A Method for Stochastic Optimization”

  Declaration

  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(using:)

  Generates a new random seed for TensorFlow.

  Declaration

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

• concatenate(_:_:)

  Concatenates two values.

  Declaration

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

• sum(_:_:)

  Adds two values and produces their sum.

  Declaration

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

• average(_:_:)

  Averages two values.

  Declaration

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

• multiply(_:_:)

  Multiplies two values.

  Declaration

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

• stack(_:_:)

  Stack two values.

  Declaration

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

• PrintX10Metrics()

  Declaration

  public func PrintX10Metrics()

• formatStatistics(_:)

  Creates a string summary of a list of training and testing stats.

  Declaration

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

• formatStatistics(train:test:)

  Declaration

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

• runOnNThreads(_:_:)

  Maps a function over n threads.

  Declaration

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