Funkcje

Poniższe funkcje są dostępne globalnie.

  • Zwraca stratę L1 pomiędzy przewidywaniami i oczekiwaniami.

    Deklaracja

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

    Parametry

    predicted

    Przewidywane wyjścia z sieci neuronowej.

    expected

    Oczekiwane wartości, tj. cele, które odpowiadają prawidłowemu wynikowi.

  • Zwraca stratę L2 pomiędzy przewidywaniami i oczekiwaniami.

    Deklaracja

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

    Parametry

    predicted

    Przewidywane wyjścia z sieci neuronowej.

    expected

    Oczekiwane wartości, tj. cele, które odpowiadają prawidłowemu wynikowi.

  • Zwraca utratę zawiasów między przewidywaniami i oczekiwaniami.

    Deklaracja

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

    Parametry

    predicted

    Przewidywane wyjścia z sieci neuronowej.

    expected

    Oczekiwane wartości, tj. cele, które odpowiadają prawidłowemu wynikowi.

  • Zwraca kwadratową utratę zawiasów między przewidywaniami i oczekiwaniami.

    Deklaracja

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

    Parametry

    predicted

    Przewidywane wyjścia z sieci neuronowej.

    expected

    Oczekiwane wartości, tj. cele, które odpowiadają prawidłowemu wynikowi.

  • Zwraca kategoryczną utratę zawiasów między przewidywaniami i oczekiwaniami.

    Deklaracja

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

    Parametry

    predicted

    Przewidywane wyjścia z sieci neuronowej.

    expected

    Oczekiwane wartości, tj. cele, które odpowiadają prawidłowemu wynikowi.

  • Zwraca logarytm cosinusa hiperbolicznego błędu między przewidywaniami i oczekiwaniami.

    Deklaracja

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

    Parametry

    predicted

    Przewidywane wyjścia z sieci neuronowej.

    expected

    Oczekiwane wartości, tj. cele, które odpowiadają prawidłowemu wynikowi.

  • Zwraca stratę Poissona pomiędzy przewidywaniami i oczekiwaniami.

    Deklaracja

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

    Parametry

    predicted

    Przewidywane wyjścia z sieci neuronowej.

    expected

    Oczekiwane wartości, tj. cele, które odpowiadają prawidłowemu wynikowi.

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

    Deklaracja

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

    Parametry

    predicted

    Przewidywane wyjścia z sieci neuronowej.

    expected

    Oczekiwane wartości, tj. cele, które odpowiadają prawidłowemu wynikowi.

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

    Deklaracja

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

    Parametry

    logits

    Zakodowane w trybie one-hot wyjścia z sieci neuronowej.

    labels

    Indeksy (indeksowane od zera) prawidłowych wyjść.

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

    Deklaracja

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

    Parametry

    logits

    Nieskalowane wyjście sieci neuronowej.

    labels

    Wartości całkowite odpowiadające poprawnym wynikom.

  • 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ócony po powrocie zamknięcia.

    body

    Zamknięcie nullowe. Jeśli zamknięcie ma wartość zwracaną, wartość ta jest również używana jako wartość zwracana przez funkcję withContext(_:_:) .

    Wartość zwracana

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

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

    Deklaracja

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

    Parametry

    learningPhase

    Faza uczenia się, która zostanie ustawiona przed wywołaniem zamknięcia i przywrócona po powrocie zamknięcia.

    body

    Zamknięcie nullowe. Jeśli zamknięcie ma wartość zwracaną, wartość ta jest również używana jako wartość zwracana przez funkcję withLearningPhase(_:_:) .

    Wartość zwracana

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

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

    Deklaracja

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

    Parametry

    randomSeed

    Losowe ziarno, które zostanie ustawione przed wywołaniem zamknięcia i przywrócone po powrocie zamknięcia.

    body

    Zamknięcie nullowe. Jeśli zamknięcie ma wartość zwracaną, wartość ta jest również używana jako wartość zwracana przez funkcję withRandomSeedForTensorFlow(_:_:) .

    Wartość zwracana

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

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

    Deklaracja

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

    Parametry

    randomNumberGenerator

    Generator liczb losowych, który zostanie ustawiony przed wywołaniem zamknięcia i przywrócony po powrocie zamknięcia.

    body

    Zamknięcie nullowe. Jeśli zamknięcie ma wartość zwracaną, wartość ta jest również używana jako wartość zwracana przez funkcję withRandomNumberGeneratorForTensorFlow(_:_:) .

    Wartość zwracana

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

  • Deklaracja

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

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

    Deklaracja

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

  • 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 podczas jej wycofania, co w tradycyjnym automatycznym różnicowaniu nazywa się „punktem kontrolnym”.

    Deklaracja

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

  • Utwórz funkcję różniczkowalną na podstawie funkcji iloczynu wektorowo-jakobiańskiego.

    Deklaracja

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

  • Utwórz funkcję różniczkowalną na podstawie funkcji iloczynu wektorowo-jakobiańskiego.

    Deklaracja

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

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

    Deklaracja

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

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

    Deklaracja

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

  • Wykonuje zamknięcie, dzięki czemu operacje TensorFlow działają na określonym rodzaju urządzenia.

    Deklaracja

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

    Parametry

    kind

    Rodzaj urządzenia, na którym można uruchamiać operacje TensorFlow.

    index

    Urządzenie, na którym można uruchamiać operacje.

    body

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

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

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

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

    Deklaracja

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

    Parametry

    name

    Nazwa urządzenia.

    body

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

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

    Deklaracja

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

    Parametry

    body

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

  • Zmień rozmiar obrazów do odpowiedniego rozmiaru, korzystając z określonej metody.

    Warunek wstępny

    Obrazy muszą mieć rangę 3 lub 4 .

    Warunek wstępny

    Rozmiar musi być dodatni.

    Deklaracja

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

    Parametry

    images

    4-D Tensor kształtu [batch, height, width, channels] lub 3-D Tensor kształtu [height, width, channels] .

    size

    Nowy rozmiar obrazów.

    method

    Metoda zmiany rozmiaru. Wartość domyślna to .bilinear .

    antialias

    Jeśli true , użyj filtra antyaliasingowego podczas próbkowania obrazu w dół.

  • Zmień rozmiar obrazów do rozmiaru za pomocą interpolacji obszaru.

    Warunek wstępny

    Obrazy muszą mieć rangę 3 lub 4 .

    Warunek wstępny

    Rozmiar musi być dodatni.

    Deklaracja

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

    Parametry

    images

    4-D Tensor kształtu [batch, height, width, channels] lub 3-D Tensor kształtu [height, width, channels] .

    size

    Nowy rozmiar obrazów.

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

    Warunek wstępny

    input muszą mieć rangę 4 .

    Warunek wstępny

    filter musi mieć rangę 3 .

    Deklaracja

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

    Parametry

    input

    Wejście.

    filter

    Filtr dylatacyjny.

    strides

    Kroki filtra przesuwnego dla każdego wymiaru sygnału wejściowego.

    padding

    Wyściółka do operacji

    rates

    Szybkości dylatacji dla każdego wymiaru wejścia.

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

    Warunek wstępny

    input muszą mieć rangę 4 .

    Warunek wstępny

    filter musi mieć rangę 3.

    Deklaracja

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

    Parametry

    input

    Wejście.

    filter

    Filtr erozyjny.

    strides

    Kroki filtra przesuwnego dla każdego wymiaru sygnału wejściowego.

    padding

    Wyściółka do operacji

    rates

    Szybkości dylatacji dla każdego wymiaru wejścia.

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

    Deklaracja

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

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

    Deklaracja

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

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

    Deklaracja

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

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

    Deklaracja

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

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

    Deklaracja

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

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

    Deklaracja

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

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

    Deklaracja

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

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

    Deklaracja

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

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

    Deklaracja

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

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

    Deklaracja

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

    Parametry

    mean

    Średnia rozkładu normalnego.

    standardDeviation

    Odchylenie standardowe rozkładu normalnego.

    Wartość zwracana

    Obcięta funkcja inicjatora parametrów normalnych.

  • Deklaracja

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

  • Zwraca macierz tożsamości lub grupę macierzy.

    Deklaracja

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

    Parametry

    rowCount

    Liczba wierszy w każdej macierzy wsadowej.

    columnCount

    Liczba kolumn w każdej macierzy wsadowej.

    batchShape

    Wiodące wymiary partii zwróconego tensora.

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

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

    Warunek wstępny

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

    Deklaracja

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

    Parametry

    matrix

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

  • Zwraca rozkład Cholesky'ego jednej lub większej liczby macierzy kwadratowych.

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

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

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

    Deklaracja

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

    Parametry

    input

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

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

    Warunek wstępny

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

    Warunek wstępny

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

    Deklaracja

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

    Parametry

    matrix

    Wejściowa macierz współczynników trójkątnych reprezentująca A w Ax = b .

    rhs

    Wartości po prawej stronie, reprezentujące b w Ax = b .

    lower

    Określa, czy matrix jest dolna trójkątna ( true ), czy górna ( false ). Wartość domyślna to true .

    adjoint

    Jeśli true , rozwiąż za pomocą sprzężenia matrix zamiast matrix . Wartość domyślna to false .

    Wartość zwracana

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

  • Oblicza stratę L1 pomiędzy expected i predicted . loss = reduction(abs(expected - predicted))

    Deklaracja

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

    Parametry

    predicted

    Przewidywane wyjścia z sieci neuronowej.

    expected

    Oczekiwane wartości, tj. cele, które odpowiadają prawidłowemu wynikowi.

    reduction

    Redukcja stosowana do obliczonych wartości strat elementarnych.

  • Oblicza stratę L2 pomiędzy expected i predicted . loss = reduction(square(expected - predicted))

    Deklaracja

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

    Parametry

    predicted

    Przewidywane wyjścia z sieci neuronowej.

    expected

    Oczekiwane wartości, tj. cele, które odpowiadają prawidłowemu wynikowi.

    reduction

    Redukcja stosowana do obliczonych wartości strat elementarnych.

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

    Deklaracja

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

    Parametry

    predicted

    Przewidywane wyjścia z sieci neuronowej.

    expected

    Oczekiwane wartości, tj. cele, które odpowiadają prawidłowemu wynikowi.

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

    Deklaracja

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

    Parametry

    predicted

    Przewidywane wyjścia z sieci neuronowej.

    expected

    Oczekiwane wartości, tj. cele, które odpowiadają prawidłowemu wynikowi.

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

    Notatka

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

    Deklaracja

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

    Parametry

    predicted

    Przewidywane wyjścia z sieci neuronowej.

    expected

    Oczekiwane wartości, tj. cele, które odpowiadają prawidłowemu wynikowi.

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

    Deklaracja

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

    Parametry

    predicted

    Przewidywane wyjścia z sieci neuronowej.

    expected

    Oczekiwane wartości, tj. cele, które odpowiadają prawidłowemu wynikowi.

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

    Deklaracja

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

    Parametry

    predicted

    Przewidywane wyjścia z sieci neuronowej.

    expected

    Oczekiwane wartości, tj. cele, które odpowiadają prawidłowemu wynikowi.

    reduction

    Redukcja stosowana do obliczonych wartości strat elementarnych.

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

    Deklaracja

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

    Parametry

    predicted

    Przewidywane wyjścia z sieci neuronowej.

    expected

    Oczekiwane wartości, tj. cele, które odpowiadają prawidłowemu wynikowi.

    reduction

    Redukcja stosowana do obliczonych wartości strat elementarnych.

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

    Deklaracja

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

    Parametry

    predicted

    Przewidywane wyjścia z sieci neuronowej.

    expected

    Oczekiwane wartości, tj. cele, które odpowiadają prawidłowemu wynikowi.

    reduction

    Redukcja stosowana do obliczonych wartości strat elementarnych.

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

    Deklaracja

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

    Parametry

    predicted

    Przewidywane wyjścia z sieci neuronowej.

    expected

    Oczekiwane wartości, tj. cele, które odpowiadają prawidłowemu wynikowi.

    reduction

    Redukcja stosowana do obliczonych wartości strat elementarnych.

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

    Deklaracja

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

    Parametry

    predicted

    Przewidywane wyjścia z sieci neuronowej.

    expected

    Oczekiwane wartości, tj. cele, które odpowiadają prawidłowemu wynikowi.

    reduction

    Redukcja stosowana do obliczonych wartości strat elementarnych.

  • Oblicza stratę dywergencji Kullbacka-Leiblera pomiędzy expected i predicted . loss = reduction(expected * log(expected / predicted))

    Deklaracja

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

    Parametry

    predicted

    Przewidywane wyjścia z sieci neuronowej.

    expected

    Oczekiwane wartości, tj. cele, które odpowiadają prawidłowemu wynikowi.

    reduction

    Redukcja stosowana do obliczonych wartości strat elementarnych.

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

    Deklaracja

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

    Parametry

    logits

    Zakodowane w trybie one-hot wyjścia z sieci neuronowej.

    labels

    Indeksy (indeksowane od zera) prawidłowych wyjść.

    reduction

    Redukcja stosowana do obliczonych wartości strat elementarnych.

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

    Deklaracja

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

    Parametry

    logits

    Nieskalowane prawdopodobieństwa dziennika z sieci neuronowej.

    probabilities

    Wartości prawdopodobieństwa odpowiadające prawidłowemu wynikowi. Każdy wiersz musi być prawidłowym rozkładem prawdopodobieństwa.

    reduction

    Redukcja stosowana do obliczonych wartości strat elementarnych.

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

    Deklaracja

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

    Parametry

    logits

    Nieskalowane wyjście sieci neuronowej.

    labels

    Wartości całkowite odpowiadające poprawnym wynikom.

    reduction

    Redukcja stosowana do obliczonych wartości strat elementarnych.

  • Oblicza stratę Hubera pomiędzy predicted i expected .

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

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

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

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

    Deklaracja

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

    Parametry

    predicted

    Przewidywane wyjścia z sieci neuronowej.

    expected

    Oczekiwane wartości, tj. cele, które odpowiadają prawidłowemu wynikowi.

    delta

    Skalar zmiennoprzecinkowy reprezentujący punkt, w którym funkcja straty Hubera zmienia się z kwadratowej na liniową.

    reduction

    Redukcja stosowana do obliczonych wartości strat elementarnych.

  • 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 tensora według elementu.

    Deklaracja

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

  • Zwraca logarytm o podstawie dwóch określonego elementu tensora.

    Deklaracja

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

  • Zwraca logarytm dziesiętny określonego tensora w ujęciu elementowym.

    Deklaracja

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

  • Zwraca logarytm 1 + x w ujęciu elementowym.

    Deklaracja

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

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

    Notatka

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

    Deklaracja

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

  • Zwraca sinus określonego tensora według elementu.

    Deklaracja

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

  • Zwraca cosinus określonego tensora według elementu.

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

    Deklaracja

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

  • Zwraca odwrotną tangens 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ładniczy 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 tensora według elementu.

    Deklaracja

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

  • Zwraca dziesięć podniesionych do potęgi określonego tensora według elementu.

    Deklaracja

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

  • Zwraca wykładniczą x - 1 elementowo.

    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, według elementów.

    Deklaracja

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

  • Zwraca pułap określonego tensora według elementu.

    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 tensora według elementu. W szczególności oblicza y = sign(x) = -1 jeśli x < 0 ; 0 jeśli x == 0 ; 1 jeśli x > 0 .

    Deklaracja

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

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

    Deklaracja

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

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

    Deklaracja

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

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

    Deklaracja

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

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

    Deklaracja

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

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

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

    Zobacz Jednostki liniowe błędu Gaussa .

    Deklaracja

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

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

    Deklaracja

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

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

    Deklaracja

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

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

    Deklaracja

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

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

    Notatka

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

    Deklaracja

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

  • Zwraca tensor poprzez zastosowanie funkcji aktywacji Swish, a mianowicie x * sigmoid(x) .

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

    Deklaracja

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

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

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

    Deklaracja

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

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

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

    Deklaracja

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

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

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

    Deklaracja

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

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

    Deklaracja

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

  • Zwraca elementarny n ty pierwiastek tensora.

    Deklaracja

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

  • Zwraca kwadratową różnicę między x i y .

    Deklaracja

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

    Wartość zwracana

    (x - y) ^ 2 .

  • Zwraca elementowe maksimum dwóch tensorów.

    Notatka

    max obsługuje nadawanie.

    Deklaracja

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

  • Zwraca elementowe maksimum skalara i tensora, emitując skalar.

    Deklaracja

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

  • Zwraca elementowe maksimum skalara i tensora, emitując skalar.

    Deklaracja

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

  • Zwraca elementarne minimum dwóch tensorów.

    Notatka

    min obsługuje nadawanie.

    Deklaracja

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

  • Zwraca elementarne minimum skalara i tensora, emitując skalar.

    Deklaracja

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

  • Zwraca elementarne minimum skalara i tensora, emitując skalar.

    Deklaracja

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

  • 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 odległość cosinus między x i y . Odległość cosinus definiuje się jako 1 - cosineSimilarity(x, y) .

    Deklaracja

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

  • Wykonuje mnożenie macierzy przez inny tensor i daje wynik.

    Deklaracja

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

  • Zwraca splot 1-D z określonymi danymi wejściowymi, filtrem, krokiem i dopełnieniem.

    Warunek wstępny

    input muszą mieć rangę 3 .

    Warunek wstępny

    filter musi mieć rangę 3.

    Deklaracja

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

    Parametry

    input

    Wejście.

    filter

    Filtr splotowy.

    stride

    Krok przesuwanego filtra.

    padding

    Wyściółka do operacji.

    dilation

    Współczynnik dylatacji.

  • Zwraca splot 2-D z określonymi danymi wejściowymi, filtrem, krokami i dopełnieniem.

    Warunek wstępny

    input muszą mieć rangę 4 .

    Warunek wstępny

    filter musi mieć rangę 4.

    Deklaracja

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

    Parametry

    input

    Wejście.

    filter

    Filtr splotowy.

    strides

    Kroki filtra przesuwnego dla każdego wymiaru sygnału wejściowego.

    padding

    Wyściółka do operacji

    dilations

    Współczynnik dylatacji dla każdego wymiaru wejściowego.

  • Zwraca transponowany splot 2-D z określonymi danymi wejściowymi, filtrem, krokami i dopełnieniem.

    Warunek wstępny

    input muszą mieć rangę 4 .

    Warunek wstępny

    filter musi mieć rangę 4.

    Deklaracja

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

    Parametry

    input

    Wejście.

    shape

    Kształt wyjściowy operacji dekonwolucji.

    filter

    Filtr splotowy.

    strides

    Kroki filtra przesuwnego dla każdego wymiaru sygnału wejściowego.

    padding

    Wyściółka do operacji

    dilations

    Współczynnik dylatacji dla każdego wymiaru wejściowego.

  • Zwraca splot 3-W z określonymi danymi wejściowymi, filtrem, krokami, dopełnieniem i rozszerzeniami.

    Warunek wstępny

    input muszą mieć rangę 5 .

    Warunek wstępny

    filter musi mieć rangę 5.

    Deklaracja

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

    Parametry

    input

    Wejście.

    filter

    Filtr splotowy.

    strides

    Kroki filtra przesuwnego dla każdego wymiaru sygnału wejściowego.

    padding

    Wyściółka do operacji.

    dilations

    Współczynnik dylatacji dla każdego wymiaru wejściowego.

  • Zwraca splot wgłębny 2-D z określonymi danymi wejściowymi, filtrem, krokami i dopełnieniem.

    Warunek wstępny

    input muszą mieć rangę 4.

    Warunek wstępny

    filter musi mieć rangę 4.

    Deklaracja

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

    Parametry

    input

    Wejście.

    filter

    Głęboko filtr splotowy.

    strides

    Kroki filtra przesuwnego dla każdego wymiaru sygnału wejściowego.

    padding

    Wyściółka do operacji.

  • Zwraca maksymalną pulę 2-D z określonymi rozmiarami filtrów, krokami i dopełnieniem.

    Deklaracja

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

    Parametry

    input

    Wejście.

    filterSize

    Wymiary jądra łączenia.

    strides

    Kroki filtra przesuwnego dla każdego wymiaru sygnału wejściowego.

    padding

    Wyściółka do operacji.

  • Zwraca maksymalną pulę 3-D z określonymi rozmiarami filtrów, krokami i dopełnieniem.

    Deklaracja

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

    Parametry

    input

    Wejście.

    filterSize

    Wymiary jądra łączenia.

    strides

    Kroki filtra przesuwnego dla każdego wymiaru sygnału wejściowego.

    padding

    Wyściółka do operacji.

  • Zwraca średnią pulę 2-D z określonymi rozmiarami filtrów, krokami i dopełnieniem.

    Deklaracja

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

    Parametry

    input

    Wejście.

    filterSize

    Wymiary jądra łączenia.

    strides

    Kroki filtra przesuwnego dla każdego wymiaru sygnału wejściowego.

    padding

    Wyściółka do operacji.

  • Zwraca średnią pulę 3-W z określonymi rozmiarami filtrów, krokami i dopełnieniem.

    Deklaracja

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

    Parametry

    input

    Wejście.

    filterSize

    Wymiary jądra łączenia.

    strides

    Kroki filtra przesuwnego dla każdego wymiaru sygnału wejściowego.

    padding

    Wyściółka do operacji.

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

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

    Deklaracja

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

    Parametry

    input

    Tensor. 4-D z kształtem [batch, height, width, channels] .

    poolingRatio

    Lista Doubles . Współczynnik łączenia dla każdego wymiaru input , obecnie obsługuje tylko wymiar wierszy i kolumn i powinien wynosić >= 1,0.

    pseudoRandom

    Opcjonalny Bool . Domyślnie jest to false . Po ustawieniu na true generuje sekwencję łączenia w sposób pseudolosowy, w przeciwnym razie w sposób losowy.

    overlapping

    Opcjonalny Bool . Domyślnie jest to false . Ustawienie na true oznacza, że ​​podczas łączenia wartości na granicy sąsiednich komórek łączenia są używane przez obie komórki.

    deterministic

    Opcjonalny Bool . Po ustawieniu na true podczas iteracji po węźle FractionalMaxPool2D na wykresie obliczeniowym używany będzie stały region puli.

    seed

    Opcjonalny Int64 . Domyślnie 0 . Jeśli ustawiona jest na wartość różną od zera, generator liczb losowych jest zaszczepiany danym ziarnem.

    seed2

    Opcjonalny Int64 . Domyślnie 0 . Drugie ziarno, aby uniknąć kolizji nasion.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    Warunek wstępny

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

    Warunek wstępny

    Liczba cech musi być podzielna przez kwadrat b .

    Deklaracja

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    Warunek wstępny

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

    Warunek wstępny

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

    Warunek wstępny

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

    Deklaracja

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

  • Tworzy optymalizator wagowy dla LARS ( https://arxiv.org/pdf/1708.03888.pdf ).

    Deklaracja

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

  • Tworzy optymalizator wagowy oparty na SGD.

    Deklaracja

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

  • Tworzy optymalizator wagowy dla Adama ze spadkiem masy ciała.

    Odniesienie: „Adam – metoda optymalizacji stochastycznej”

    Deklaracja

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

  • Generuje nowe losowe ziarno dla TensorFlow.

    Deklaracja

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

  • Łączy dwie wartości.

    Deklaracja

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

  • Dodaje dwie wartości i generuje ich sumę.

    Deklaracja

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

  • Średnia dwie wartości.

    Deklaracja

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

  • Mnoży dwie wartości.

    Deklaracja

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

  • Ułóż dwie wartości.

    Deklaracja

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

  • Deklaracja

    public func PrintX10Metrics()

  • Tworzy podsumowanie ciągów listy statystyk szkoleniowych i testowych.

    Deklaracja

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

  • Deklaracja

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

  • Mapuje funkcję nad n wątkami.

    Deklaracja

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