Google I/O to frajda! Nadrobić zaległości w sesjach TensorFlow Zobacz sesje

Funkcje

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

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

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

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

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

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

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

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

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

  • 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ść.

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

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

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

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

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

  • Deklaracja

    public func zip<T: TensorGroup, U: TensorGroup>(
      _ dataset1: Dataset<T>, _ dataset2: Dataset<U>
    ) -> Dataset<Zip2TensorGroup<T, U>>
  • 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)
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • Deklaracja

    public func gradient<T, R>(
      at x: T,
      in f: @differentiable (T) -> Tensor<R>
    ) -> T.TangentVector where T: Differentiable, R: TensorFlowFloatingPoint
  • 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
  • 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
  • Deklaracja

    public func gradient<T, R>(
      of f: @escaping @differentiable (T) -> Tensor<R>
    ) -> (T) -> T.TangentVector where T: Differentiable, R: TensorFlowFloatingPoint
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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.

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

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

  • 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ęć.

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

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

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

    Deklaracja

    public func zeros<Scalar>() -> ParameterInitializer<Scalar> where Scalar : TensorFlowFloatingPoint
  • 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>
  • 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>
  • 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>
  • 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>
  • 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>
  • 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>
  • 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>
  • 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>
  • 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
  • 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.

  • 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] .

  • 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] .

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    Deklaracja

    @differentiable
    public func abs<T>(_ x: Tensor<T>) -> Tensor<T> where T : SignedNumeric, T : TensorFlowScalar
  • Zwraca logarytm naturalny określonego elementu tensora.

    Deklaracja

    @differentiable
    public func log<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Zwraca logarytm o podstawie dwa określonego elementu tensora.

    Deklaracja

    @differentiable
    public func log2<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Zwraca logarytm dziesiętny określonego elementu tensora.

    Deklaracja

    @differentiable
    public func log10<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Zwraca logarytm 1 + x elementem mądry.

    Deklaracja

    @differentiable
    public func log1p<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 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
  • Zwraca sinus określonego elementu tensora.

    Deklaracja

    @differentiable
    public func sin<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Zwraca cosinus określonego elementu tensora.

    Deklaracja

    @differentiable
    public func cos<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Zwraca tangens określonego elementu tensora.

    Deklaracja

    @differentiable
    public func tan<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Zwraca sinus hiperboliczny określonego elementu tensora.

    Deklaracja

    @differentiable
    public func sinh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Zwraca cosinus hiperboliczny określonego elementu tensora.

    Deklaracja

    @differentiable
    public func cosh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Zwraca tangens hiperboliczny określonego elementu tensora.

    Deklaracja

    @differentiable
    public func tanh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Zwraca odwrotny cosinus określonego elementu tensora.

    Deklaracja

    @differentiable
    public func acos<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Zwraca sinus odwrotny określonego elementu tensora.

    Deklaracja

    @differentiable
    public func asin<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Zwraca tangens odwrotny określonego elementu tensora.

    Deklaracja

    @differentiable
    public func atan<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Zwraca odwrotny cosinus hiperboliczny określonego elementu tensora.

    Deklaracja

    @differentiable
    public func acosh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Zwraca odwrotny sinus hiperboliczny określonego elementu tensora.

    Deklaracja

    @differentiable
    public func asinh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Zwraca odwrotny tangens hiperboliczny określonego elementu tensora.

    Deklaracja

    @differentiable
    public func atanh<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Zwraca pierwiastek kwadratowy z określonego elementu tensora.

    Deklaracja

    @differentiable
    public func sqrt<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Zwraca odwrotny pierwiastek kwadratowy określonego elementu tensora.

    Deklaracja

    @differentiable
    public func rsqrt<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Zwraca wykładnik określonego elementu tensora.

    Deklaracja

    @differentiable
    public func exp<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Zwraca dwa podniesione do potęgi określonego elementu tensora.

    Deklaracja

    @differentiable
    public func exp2<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Zwraca dziesięć podniesionych do potęgi określonego elementu tensora.

    Deklaracja

    @differentiable
    public func exp10<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Zwraca wykładniczy z x - 1 element mądry.

    Deklaracja

    @differentiable
    public func expm1<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 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
  • Zwraca pułap określonego elementu tensora.

    Deklaracja

    @differentiable
    public func ceil<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Zwraca podłogę określonego elementu tensora.

    Deklaracja

    @differentiable
    public func floor<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • Zwraca log-softmax określonego elementu tensora.

    Deklaracja

    @differentiable
    public func logSoftmax<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 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
  • 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
  • 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
  • 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
  • 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>
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • Zwraca element mądry n th korzeń tensora.

    Deklaracja

    @differentiable
    public func root<T>(_ x: Tensor<T>, _ n: Int) -> Tensor<T> where T : TensorFlowFloatingPoint
  • 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 .

  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
  • Zwraca cosinus podobieństwa między x i y .

    Deklaracja

    @differentiable
    public func cosineSimilarity<Scalar: TensorFlowFloatingPoint>(
      _ x: Tensor<Scalar>,
      _ y: Tensor<Scalar>
    ) -> Tensor<Scalar>
  • 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>
  • 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>
  • 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.

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

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

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

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

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

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

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

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

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

  • 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
  • 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
  • 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
  • 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
  • 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
  • Generates a new random seed for TensorFlow.

    Deklaracja

    public func randomSeedForTensorFlow(using seed: TensorFlowSeed? = nil) -> TensorFlowSeed
  • Concatenates two values.

    Deklaracja

    @differentiable
    public func concatenate<T: Mergeable>(
      _ first: T,
      _ second: T
    ) -> T
  • Adds two values and produces their sum.

    Deklaracja

    @differentiable
    public func sum<T: Mergeable>(
      _ first: T,
      _ second: T
    ) -> T
  • Averages two values.

    Deklaracja

    @differentiable
    public func average<T: Mergeable>(
      _ first: T,
      _ second: T
    ) -> T
  • Multiplies two values.

    Deklaracja

    @differentiable
    public func multiply<T: Mergeable>(
      _ first: T,
      _ second: T
    ) -> T
  • Stack two values.

    Deklaracja

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

    public func PrintX10Metrics()
  • Creates a string summary of a list of training and testing stats.

    Deklaracja

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

    public func formatStatistics(train trainStats: HostStatistics, test testStats: HostStatistics)
      -> String
  • Maps a function over n threads.

    Deklaracja

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