Funkcje

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

• l1Strata(przewidywana:oczekiwana:)

  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 wyjścia z sieci neuronowej.
  expected	Oczekiwane wartości, tj. cele, które odpowiadają poprawnym wynikom.

• 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 wyjścia z sieci neuronowej.
  expected	Oczekiwane wartości, tj. cele, które odpowiadają poprawnym wynikom.

• zawiasLoss(przewidywany:oczekiwany:)

  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 wyjścia z sieci neuronowej.
  expected	Oczekiwane wartości, tj. cele, które odpowiadają poprawnym wynikom.

• squaredHingeLoss(przewidywane:oczekiwane:)

  Zwraca kwadratową stratę zawiasu między prognozami 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 wyjścia z sieci neuronowej.
  expected	Oczekiwane wartości, tj. cele, które odpowiadają poprawnym wynikom.

• kategoryczna utrata zawiasów (przewidywana: oczekiwana:)

  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 wyjścia z sieci neuronowej.
  expected	Oczekiwane wartości, tj. cele, które odpowiadają poprawnym wynikom.

• 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 wyjścia z sieci neuronowej.
  expected	Oczekiwane wartości, tj. cele, które odpowiadają poprawnym wynikom.

• poissonLoss(przewidywane:oczekiwane:)

  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 wyjścia z sieci neuronowej.
  expected	Oczekiwane wartości, tj. cele, które odpowiadają poprawnym wynikom.

• kullbackLeiblerDivergence(przewidywane:oczekiwane:)

  Zwraca rozbieżność Kullbacka-Leiblera (rozbieżność KL) między oczekiwaniami a przewidywaniami. Biorąc pod uwagę dwie dystrybucje p i q , KL rozbieżność 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ą poprawnym wynikom.

• softmaxCrossEntropy(logity:prawdopodobieństwa:)

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

  Deklaracja

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

  Parametry

  logits	Wyjścia zakodowane na gorąco z sieci neuronowej.
  labels	Indeksy (indeksowane do zera) prawidłowych wyjść.

• sigmoidCrossEntropy(logity:etykiety:)

  Zwraca sigmoidalną entropię krzyżową (binarną entropię krzyżową) między logitami a 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ą 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

• zKontekstem(_:_:)

  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ócenie po powrocie zamknięcia.
  body	Zamknięcie nuklearne. Jeżeli zamknięcie ma zwracanej wartości, wartość ta jest również stosowana jako wartość powrotnej withContext(_:_:) funkcji.

  Wartość zwrotu

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

• 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, która zostanie ustawiona przed wywołaniem zamknięcia i przywrócona po powrocie zamknięcia.
  body	Zamknięcie nuklearne. Jeżeli zamknięcie ma zwracanej wartości, wartość ta jest również stosowana jako wartość powrotnej withLearningPhase(_:_:) funkcji.

  Wartość zwrotu

  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 inicjatora.

  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 nuklearne. Jeżeli zamknięcie ma zwracanej wartości, wartość ta jest również stosowana jako wartość powrotnej withRandomSeedForTensorFlow(_:_:) funkcji.

  Wartość zwrotu

  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 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 nuklearne. Jeżeli zamknięcie ma zwracanej wartości, wartość ta jest również stosowana jako wartość powrotnej withRandomNumberGeneratorForTensorFlow(_:_:) funkcji.

  Wartość zwrotu

  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(on:urządzenia:czekaj:)

  LazyTensorBarrier zapewnia, że ​​wszystkie tensory na żywo (na urządzeniu, jeśli są dostępne) są zaplanowane i uruchomione. Jeśli wait ma wartość 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

• wartośćZGradientem(w:_:_:w:)

  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(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(w:_:w:)

  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

• withRecommputationInPulllbacks(_:)

  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

• funkcja różniczkowalna(od:)

  Utwórz funkcję różniczkowalną z funkcji iloczynów wektorowych-jacobian.

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

  Utwórz funkcję różniczkowalną z funkcji iloczynów wektorowych-jacobian.

  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

• bezpochodnej(at:)

  Zwraca x jak funkcja tożsamości. Gdy stosuje się w kontekście, w którym x jest zróżnicowane w odniesieniu do tej funkcji, nie występują w przypadku pochodnych w x .

  Deklaracja

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

• bezpochodnej(at:in:)

  Stosuje danego zamknięcia body do x . Gdy stosuje się w kontekście, w którym x jest zróżnicowane w odniesieniu do tej funkcji, nie występują w przypadku pochodnych w x .

  Deklaracja

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

• zUrządzeniem(_:_:wykonaj:)

  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 do uruchamiania operacji TensorFlow.
  index	Urządzenie do uruchamiania operacji.
  body	Zamknięcie, którego operacje TensorFlow mają zostać wykonane na określonym rodzaju urządzenia.

• zUrządzeniem(nazwa: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 komputera.
  • „/GPU:0”: skrócona notacja dla pierwszego procesora graficznego Twojej maszyny, który jest widoczny dla TensorFlow
  • „/job:localhost/replica:0/task:0/device:GPU:1”: W pełni kwalifikowana nazwa drugiego procesora graficznego komputera, który jest widoczny 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ą zostać wykonane 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 miejsca docelowego.

  Deklaracja

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

  Parametry

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

• zmień rozmiar(obrazy:rozmiar: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	4D Tensor kształtu [batch, height, width, channels] lub 3-D Tensor kształtu [height, width, channels] .
  size	Nowy rozmiar zdjęć.
  method	Metoda zmiany rozmiaru. Domyślną wartością jest .bilinear .
  antialias	IFF true , użyj filtra antyaliasingu, kiedy zmniejsza próbkowanie obrazu.

• resizeArea(obrazy:rozmiar:wyrównaj narożniki:)

  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	4D Tensor kształtu [batch, height, width, channels] lub 3-D Tensor kształtu [height, width, channels] .
  size	Nowy rozmiar zdjęć.

• dylatacja2D(_:filtr:kroki:stawki:dopełnienie:)

  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 dylatacyjny.
  strides	Kroki filtru przesuwnego dla każdego wymiaru danych wejściowych.
  padding	Wyściółka do operacji
  rates	Współczynniki dylatacji dla każdego wymiaru wejścia.

• erozja2D(_:filtr:kroki:stawki:dopełnienie:)

  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 filtru przesuwnego dla każdego wymiaru danych wejściowych.
  padding	Wyściółka do operacji
  rates	Współczynniki dylatacji dla każdego wymiaru wejścia.

• zera()

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

  Deklaracja

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

• stałyInicjalizator(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>

• stałyInicjalizator(wartość:)

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

  Deklaracja

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

• glorotUniform(nasionko:)

  Zwraca funkcja, która tworzy tensor wykonując Glorot (Xavier) jednolitej inicjalizacji dla określonego kształtu, losowo próbek wartości skalarne z rozkładu równomiernego między -limit i limit , generowane przez generator liczb losowych domyślny, gdzie granica jest sqrt(6 / (fanIn + fanOut)) i fanIn / fanOut reprezentują liczbę funkcji wejścia i wyjścia pomnożonej przez pole chłonnego, jeśli są obecne.

  Deklaracja

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

• glorotNormal(nasiona:)

  Zwraca funkcja, która tworzy tensor wykonując Glorot (Xavier) normalnego inicjalizacji dla określonego kształtu, losowo próbek wartości skalarne z obciętego rozkładu normalnego na środku 0 z odchyleniem standardowym sqrt(2 / (fanIn + fanOut)) , gdzie fanIn / fanOut reprezentują liczbę funkcji wejściowych i wyjściowych pomnożoną przez rozmiar pola receptywnego, jeśli występuje.

  Deklaracja

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

• heUniform(nasionko:)

  Zwraca funkcja, która tworzy tensor wykonując on (Kaiming) Uniform inicjalizacji dla określonego kształtu, losowo próbek wartości skalarne z rozkładu równomiernego między -limit i limit , generowane przez generator liczb losowych domyślny, gdzie granica jest sqrt(6 / fanIn) i fanIn oznacza liczbę cech wejściowych pomnożonych przez pola chłonnego, jeśli są obecne.

  Deklaracja

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

• heNormalna(nasiona:)

  Zwraca funkcja, która tworzy tensor wykonując on (Kaiming) normalnego inicjalizacji dla określonego kształtu, losowo próbek wartości skalarne z obciętego rozkładu normalnego na środku 0 z odchyleniem standardowym sqrt(2 / fanIn) , gdzie fanIn reprezentuje liczbę cech wejściowych pomnożone przez rozmiar pola receptywnego, jeśli jest obecny.

  Deklaracja

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

• leCunUniform(nasionko:)

  Zwraca funkcja, która tworzy tensor wykonując LeCun jednolitej inicjalizacji dla określonego kształtu, losowo próbek wartości skalarne z rozkładu równomiernego między -limit i limit , generowane przez generator liczb losowych domyślny, gdzie granica jest sqrt(3 / fanIn) , a fanIn oznacza liczbę cech wejściowych pomnożonych przez pola otwarci, jeśli są obecne.

  Deklaracja

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

• leCunNormal(nasiona:)

  Zwraca funkcja, która tworzy tensor wykonując LeCun normalnego inicjalizacji dla określonego kształtu, losowo próbek wartości skalarne z obciętego rozkładu normalnego na środku 0 z odchyleniem standardowym sqrt(1 / fanIn) , gdzie fanIn reprezentuje liczbę wejściowych funkcji pomnożonej przez odbiorczy rozmiar pola, jeśli jest obecny.

  Deklaracja

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

• truncatedNormalInitializer(średnia:odchylenie standardowe:nasion:)

  Zwraca funkcję, która tworzy tensor, inicjując wszystkie jego wartości losowo z obciętego rozkładu normalnego. Generowane wartości śledzić rozkład normalny ze średnią mean i odchylenia standardowego standardDeviation wyjątkiem, że wartości, których wielkość jest więcej niż dwa odchylenia standardowe od średniej są opuszczane i resampled.

  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 z rozkładu normalnego.
  standardDeviation	Odchylenie standardowe rozkładu normalnego.

  Wartość zwrotu

  Obcięta funkcja inicjatora parametrów normalnych.

• ==(_:_:)

  Deklaracja

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

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

  Zwraca macierz tożsamości lub partię 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 jest sumą wzdłuż głównej przekątnej każdej najbardziej wewnętrznej macierzy.

  Wejście jest napinacz w kształcie [..., M, N] . Wyjście jest tensor z kształtu [...] .

  Warunek wstępny

  matrix musi być napinacz w kształcie [..., M, N] .

  Deklaracja

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

  Parametry

  matrix

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

• cholesky(_:)

  Zwraca rozkład Cholesky'ego co najmniej jednej macierzy kwadratowej.

  Wejście jest napinacz kształtu [..., M, M] którego najbardziej wewnętrznych 2 wymiary tworząc macierze kwadratowe.

  Wejście musi być symetryczne i dodatnie. Do tej operacji zostanie wykorzystana tylko trójkątna dolna część wejścia. Część w kształcie trójkąta górnego nie zostanie odczytana.

  Wyjście jest napinacz o takim samym kształcie jak wejściowy zawierający rozkładowi Cholesky'iego wszystkich podmatryc wejściowych [..., :, :] .

  Deklaracja

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

  Parametry

  input

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

• triangularSolve(macierz:prawa oś:dolna:sprzężenie:)

  Zwraca rozwiązanie x do układu równań liniowych przedstawiony Ax = b .

  Warunek wstępny

  matrix musi być napinacz w kształcie [..., M, M] .

  Warunek wstępny

  rhs powinien być w kształcie napinacz [..., 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ście matryca trójkątna współczynnik reprezentujący A w Ax = b .
  rhs	Wartości po prawej stronie, co stanowi b w Ax = b .
  lower	Czy matrix jest mniejsza trójkątny ( true ) lub górnej trójkątnej ( false ). Domyślną wartością jest true .
  adjoint	Jeśli true , rozwiązywać z adjoint z matrix zamiast matrix . Wartością domyślną jest false .

  Wartość zwrotu

  Roztwór x do układu równań liniowych przedstawiony Ax = b . x ma ten sam kształt co b .

• l1Strata(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 wyjścia z sieci neuronowej.
  expected	Oczekiwane wartości, tj. cele, które odpowiadają poprawnym wynikom.
  reduction	Redukcja stosowana do obliczonych wartości strat elementarnych.

• l2Loss(przewidywane:oczekiwane:redukcja:)

  Oblicza straty 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 wyjścia z sieci neuronowej.
  expected	Oczekiwane wartości, tj. cele, które odpowiadają poprawnym wynikom.
  reduction	Redukcja stosowana do obliczonych wartości strat elementarnych.

• meanAbsoluteError(przewidywane:oczekiwane:)

  Oblicza średnią bezwzględną różnicy między etykietami a prognozami. 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ą poprawnym wynikom.

• meanSquaredError(przewidywane:oczekiwane:)

  Oblicza średnią kwadratów błędów między etykietami a prognozami. 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ą poprawnym wynikom.

• meanSquaredLogarithmicError(przewidywane:oczekiwane:)

  Oblicza błąd średniokwadratowy logarytmicznej między predicted i expected loss = square(log(expected) - log(predicted))

  Notatka

  Negatywne wpisy tensor zostanie zaciśnięta na 0 , aby uniknąć niezdefiniowane zachowanie logarytmicznej, jak log(_:) jest niezdefiniowana 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ą poprawnym wynikom.

• meanAbsolutePercentageError(przewidywane:oczekiwane:)

  Oblicza się średni bezwzględny błąd procentowy między predicted i 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ą poprawnym wynikom.

• zawiasLoss(przewidywany:oczekiwany:redukcja:)

  Oblicza straty zawias pomiędzy predicted i expected . loss = reduction(max(0, 1 - predicted * expected)) expected się spodziewać się wartości 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ą poprawnym wynikom.
  reduction	Redukcja stosowana do obliczonych wartości strat elementarnych.

• squaredHingeLoss(przewidywane:oczekiwane:redukcja:)

  Oblicza kwadrat straty zawiasu pomiędzy predicted i expected . loss = reduction(square(max(0, 1 - predicted * expected))) expected oczekuje się wartości 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ą poprawnym wynikom.
  reduction	Redukcja stosowana do obliczonych wartości strat elementarnych.

• kategoryczna utrata zawiasów(przewidywana:oczekiwana:redukcja:)

  Oblicza kategoryczne straty zawias 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ą poprawnym wynikom.
  reduction	Redukcja stosowana do obliczonych wartości strat elementarnych.

• logCoshLoss(przewidywane:oczekiwane:redukcja:)

  Oblicza logarytm cosinusa hiperbolicznego błędu prognozy. logcosh = log((exp(x) + exp(-x))/2) , gdzie X jest 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 wyjścia z sieci neuronowej.
  expected	Oczekiwane wartości, tj. cele, które odpowiadają poprawnym wynikom.
  reduction	Redukcja stosowana do obliczonych wartości strat elementarnych.

• poissonLoss(przewidywane:oczekiwane:redukcja:)

  Oblicza straty Poissona między przewidywanymi i oczekuje się, że straty Poissona jest średnią z elementami 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ą poprawnym wynikom.
  reduction	Redukcja stosowana do obliczonych wartości strat elementarnych.

• kullbackLeiblerDivergence(przewidywane:oczekiwane:redukcja:)

  Oblicza Kullback-Leiblera strata rozbieżność mię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ą poprawnym wynikom.
  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 a etykietami. Użyj tej funkcji straty entropii krzyżowej, gdy istnieją dwie lub więcej klas etykiet. Oczekujemy, że etykiety będą dostarczane jako liczby całkowite. Nie powinno być # classes zmiennoprzecinkowych za cecha dla logits i pojedynczej wartości zmiennoprzecinkowej jednej funkcji 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	Wyjścia zakodowane na gorąco z sieci neuronowej.
  labels	Indeksy (indeksowane do 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 a etykietami. Użyj tej funkcji straty entropii krzyżowej, gdy istnieją dwie lub więcej klas etykiet. Oczekujemy, że etykiety mają być dostarczone dostarczone w one_hot reprezentacji. Nie powinno być # classes zmiennoprzecinkowych za funkcją.

  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 logów z sieci neuronowej.
  probabilities	Wartości prawdopodobieństwa, które odpowiadają poprawnym wynikom. 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 a etykietami. Użyj tej straty entropii krzyżowej, gdy istnieją tylko dwie klasy etykiet (zakładając, że są to 0 i 1). Dla każdego przykładu 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 odpowiadające poprawnym wynikom.
  reduction	Redukcja stosowana do obliczonych wartości strat elementarnych.

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

  Oblicza straty Huber między predicted i expected .

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

  • 0.5 * x^2 , jeżeli |x| <= δ .

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

  • Źródło: Wikipedia article .

  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ą poprawnym wynikom.
  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.

• 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

• Dziennik(_:)

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

  Deklaracja

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

• log1p(_:)

  Zwraca logarytm 1 + x elementem mądry.

  Deklaracja

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

• log1mexp(_:)

  Zwraca log(1 - exp(x)) , stosując podejście numerycznie stabilny.

  Notatka

  Podejście to przedstawiono w równaniu 7: 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

• sinus(_:)

  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

• tan (_:)

  Zwraca tangens hiperboliczny 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 sinus odwrotny określonego elementu tensora.

  Deklaracja

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

• atan(_:)

  Zwraca tangens odwrotny 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

• asin (_:)

  Zwraca odwrotny sinus hiperboliczny określonego elementu tensora.

  Deklaracja

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

• atan (_:)

  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ładnik 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ładniczy z x - 1 element mądry.

  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 z uwzględnieniem 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

• piętro(_:)

  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żeli x == 0 ; 1, jeśli x > 0 .

  Deklaracja

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

• esicy(_:)

  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 logarytmiczny sigmoid określonego elementu tensora. W szczególności, log(1 / (1 + exp(-x))) . Dla większej stabilności numerycznej 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. Konkretnie, obliczy log(exp(features) + 1) .

  Deklaracja

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

• softznak(_:)

  Zwraca softsign 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, stosując wykładniczą jednostkę liniową. W szczególności, Oblicza exp(x) - 1 , jeżeli <0, x inaczej. Zobacz Szybkie i dokładne rozbudowanej sieci Uczenie się przez wykładnicze jednostek liniowych (ELUs)

  Deklaracja

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

• żółto(_:)

  Zwraca aktywacje jednostki liniowej błędu Gaussa (GELU) określonego elementu tensora.

  W szczególności, gelu zbliżona xP(X <= x) , w którym P(X <= x) jest skumulowany rozkład standardowe Gaussa, obliczając: X * [0,5 * (1 + tanh [√ (2 / π) * (x + 0,044715 * x^3)])].

  Zobacz błędu Gaussa jednostek liniowych .

  Deklaracja

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

• relu(_:)

  Zwraca tensor przez 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 napinacz przez zastosowanie funkcji aktywacji ReLU6, mianowicie min(max(0, x), 6) .

  Deklaracja

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

• nieszczelnyRelu(_:alfa:)

  Zwraca tensor przez 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 napinacz przez zastosowanie funkcji aktywacji Selu, mianowicie scale * alpha * (exp(x) - 1) , jeśli x < 0 i scale * x inaczej.

  Notatka

  Jest to przeznaczone do użycia razem z inicjatorami warstwy skalowania wariancji. Proszę odnieść się do Self-normalizujący Neural Networks , aby uzyskać więcej informacji.

  Deklaracja

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

• śmigać(_:)

  Zwraca napinacz przez zastosowanie funkcji aktywacji świst, mianowicie x * sigmoid(x) .

  Źródło: (. Ramachandran i wsp 2017) „W poszukiwaniu funkcja aktywacji” https://arxiv.org/abs/1710.05941

  Deklaracja

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

• twardySigmoid(_:)

  Zwraca tensora stosując ciężką funkcji aktywacji esicy, mianowicie Relu6(x+3)/6 .

  Źródło: „Wyszukiwanie” (MobileNetV3. Howard i wsp 2019) https://arxiv.org/abs/1905.02244

  Deklaracja

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

• hardSwish(_:)

  Zwraca tensora stosując ciężką funkcji aktywacji świst, mianowicie x * Relu6(x+3)/6 .

  Źródło: „Wyszukiwanie” (MobileNetV3. Howard i wsp 2019) https://arxiv.org/abs/1905.02244

  Deklaracja

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

• misz(_:)

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

  Źródło: „Mish: Funkcja Self uregulowana niemonotoniczny Neural Aktywacja” 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, rozgłaszają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, rozgłaszają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, rozgłaszając skalar.

  Deklaracja

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

• źródło(_:_:)

  Zwraca element mądry n th korzeń tensora.

  Deklaracja

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

• kwadrat różnicy(_:_:)

  Zwraca kwadrat różnicy 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ść zwrotu

  (x - y) ^ 2 .

• maks(_:_:)

  Zwraca elementowe maksimum dwóch tensorów.

  Notatka

  max podpory nadawania.

  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, rozgłaszają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, rozgłaszają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 elementowe minimum dwóch tensorów.

  Notatka

  min obsługuje transmisji.

  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, rozgłaszają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, rozgłaszają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>

• cosindystans(_:_:)

  Zwraca cosinus odległość między x i y . Odległość cosinus jest zdefiniowana 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 z innym tensorem 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(_:filtr:krok:dopełnienie:dylatacja:)

  Zwraca splot jednowymiarowy z określonymi danymi wejściowymi, 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 konwolucji.
  stride	Krok filtra przesuwnego.
  padding	Wypełnienie dla operacji.
  dilation	Czynnik dylatacyjny.

• conv2D(_:filtr:kroki:wypełnienie:dylatacje:)

  Zwraca splot 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ę 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 konwolucji.
  strides	Kroki filtru przesuwnego dla każdego wymiaru danych wejściowych.
  padding	Wyściółka do operacji
  dilations	Współczynnik dylatacji dla każdego wymiaru wejścia.

• transposedConv2D(_:kształt:filtr:kroki:wypełnienie:dylatacje:)

  Zwraca splot transponowany 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ę 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 konwolucji.
  strides	Kroki filtru przesuwnego dla każdego wymiaru danych wejściowych.
  padding	Wyściółka do operacji
  dilations	Współczynnik dylatacji dla każdego wymiaru wejścia.

• conv3D(_:filtr:kroki:wypełnienie:dylatacje:)

  Zwraca splot 3-W z określonymi danymi wejściowymi, 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 konwolucji.
  strides	Kroki filtru przesuwnego dla każdego wymiaru danych wejściowych.
  padding	Wypełnienie dla operacji.
  dilations	Współczynnik dylatacji dla każdego wymiaru wejścia.

• depthwiseConv2D(_:filtr:kroki:dopełnienie:)

  Zwraca splot wgłębny 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ę 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 splatania wgłębnego.
  strides	Kroki filtru przesuwnego dla każdego wymiaru danych wejściowych.
  padding	Wypełnienie dla operacji.

• maxPool2D(_:rozmiar filtra:kroki:dopełnienie:)

  Zwraca pulę 2-D max 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 puli.
  strides	Kroki filtru przesuwnego dla każdego wymiaru danych wejściowych.
  padding	Wypełnienie dla operacji.

• maxPool3D(_:rozmiar filtra:kroki:dopełnienie:)

  Zwraca pulę 3-W max 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 puli.
  strides	Kroki filtru przesuwnego dla każdego wymiaru danych wejściowych.
  padding	Wypełnienie dla operacji.

• avgPool2D(_:rozmiar filtra:kroki:wypełnienie:)

  Zwraca średnią pulę 2-W 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 puli.
  strides	Kroki filtru przesuwnego dla każdego wymiaru danych wejściowych.
  padding	Wypełnienie dla operacji.

• avgPool3D(_:rozmiar filtra: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 puli.
  strides	Kroki filtru przesuwnego dla każdego wymiaru danych wejściowych.
  padding	Wypełnienie dla operacji.

• fractionalMaxPool2D(_:poolingRatio:pseudoLosowo:nakładające się:deterministyczne:ziarno:ziarno2:)

  Zwraca ułamkową maksymalną pulę 2-D z określonymi współczynnikami pulowania.

  Uwaga: fractionalMaxPool nie posiada implementację XLA, a tym samym 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 w kształcie [batch, height, width, channels] .
  poolingRatio	Lista Doubles . Stosunek pulę dla każdego wymiaru input aktualnie obsługuje tylko rzędu Col wymiary i powinna być> = 1,0.
  pseudoRandom	Opcjonalny Bool . Domyślnie false . Po ustawieniu na true , generuje sekwencję poolingu w sposób pseudolosowy, inaczej, w sposób losowy.
  overlapping	Opcjonalny Bool . Domyślnie false . Po ustawieniu na true , to znaczy, gdy łączenie wartości na granicy sąsiednich komórek łączenia używane są zarówno przez komórki.
  deterministic	Opcjonalnego Bool . Po ustawieniu na true , stałe regionu łączenie zostaną wykorzystane podczas iteracji nad węzłem fractionalMaxPool2D na wykresie obliczeń.
  seed	Opcjonalny Int64 . Domyślnie 0 . Jeśli jest ustawiony na wartość niezerową, generator liczb losowych jest inicjowany przez podane ziarno.
  seed2	Opcjonalny Int64 . Domyślnie 0 . Drugie nasiono, aby uniknąć kolizji nasion.

• depthToSpace(_:rozmiar bloku:)

  Zwraca kopii input , gdzie wartości od wymiaru głębokości są przemieszczane w blokach przestrzennych wymiarów wysokości i szerokoś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]]]]
  

  Wyjście to operacja będzie tensora kształtu [1, 1, 1, 4] :

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

  Tutaj wkład ma partię 1, a każdy element partię kształtu [2, 2, 1] , odpowiedni wyjściowy będzie miał jeden element (czyli szerokość i wysokość o 1) i mają głębokość 4 kanałów (1 * rozmiar_bloku * rozmiar_bloku). Kształt elementu wyjściowy [1, 1, 4] .

  Dla tensora wejściowego większej głębokości, tutaj w kształcie [1, 2, 2, 3] , na przykład

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

  Operacja ta, na block_size 2 powróci następujące tensor kształtu [1, 1, 1, 12]

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

  Podobnie, dla następnego wejścia kształtu [1 4 4 1] i rozmiaru bloku 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(_:rozmiar bloku:)

  Zwraca kopię input gdzie wartości od wysokości i szerokości wymiary 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]]]]
  

  Wyjście to operacja będzie tensora kształtu [1, 1, 1, 4] :

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

  Tutaj wkład ma partię 1, a każdy element partię kształtu [2, 2, 1] , odpowiedni wyjściowy będzie miał jeden element (czyli szerokość i wysokość o 1) i mają głębokość 4 kanałów (1 * rozmiar_bloku * rozmiar_bloku). Kształt elementu wyjściowy [1, 1, 4] .

  Dla tensora wejściowego większej głębokości, tutaj w kształcie [1, 2, 2, 3] , na przykład

  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 .

  Deklaracja

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

  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:momentum:weightDecay:nesterov:)

  Builds a SGD based per-weight optimizer.

  Deklaracja

  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”

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

  Generates a new random seed for TensorFlow.

  Deklaracja

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

• concatenate(_:_:)

  Concatenates two values.

  Deklaracja

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

• sum(_:_:)

  Adds two values and produces their sum.

  Deklaracja

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

• average(_:_:)

  Averages two values.

  Deklaracja

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

• multiply(_:_:)

  Multiplies two values.

  Deklaracja

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

• stack(_:_:)

  Stack two values.

  Deklaracja

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

• PrintX10Metrics()

  Deklaracja

  public func PrintX10Metrics()

• formatStatistics(_:)

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

  Deklaracja

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

• formatStatistics(train:test:)

  Deklaracja

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

• runOnNThreads(_:_:)

  Maps a function over n threads.

  Deklaracja

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