Odpowiedz już dziś na lokalne wydarzenie TensorFlow Everywhere!
Ta strona została przetłumaczona przez Cloud Translation API.
Switch to English

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 dane wyjściowe z sieci neuronowej.

    expected

    Oczekiwane wartości, tj. Cele, które odpowiadają poprawnemu wynikowi.

  • Zwraca stratę L2 między przewidywaniami a oczekiwaniami.

    Deklaracja

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

    Parametry

    predicted

    Przewidywane dane wyjściowe z sieci neuronowej.

    expected

    Oczekiwane wartości, tj. Cele, które odpowiadają poprawnemu wynikowi.

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

    Deklaracja

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

    Parametry

    predicted

    Przewidywane dane wyjściowe z sieci neuronowej.

    expected

    Oczekiwane wartości, tj. Cele, które odpowiadają poprawnemu wynikowi.

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

    Deklaracja

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

    Parametry

    predicted

    Przewidywane dane wyjściowe z sieci neuronowej.

    expected

    Oczekiwane wartości, tj. Cele, które odpowiadają poprawnemu wynikowi.

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

    Deklaracja

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

    Parametry

    predicted

    Przewidywane dane wyjściowe z sieci neuronowej.

    expected

    Oczekiwane wartości, tj. Cele, które odpowiadają poprawnemu wynikowi.

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

    Deklaracja

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

    Parametry

    predicted

    Przewidywane dane wyjściowe z sieci neuronowej.

    expected

    Oczekiwane wartości, czyli cele, które odpowiadają poprawnemu wynikowi.

  • Zwraca stratę Poissona między przewidywaniami a oczekiwaniami.

    Deklaracja

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

    Parametry

    predicted

    Przewidywane dane wyjściowe z sieci neuronowej.

    expected

    Oczekiwane wartości, tj. Cele, które odpowiadają poprawnemu wynikowi.

  • Zwraca dywergencję Kullbacka-Leiblera (dywergencję KL) między oczekiwaniami a przewidywaniami. Mając dwa rozkłady p i q , dywergencja KL oblicza p * log(p / q) .

    Deklaracja

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

    Parametry

    predicted

    Przewidywane dane wyjściowe z sieci neuronowej.

    expected

    Oczekiwane wartości, tj. Cele, które odpowiadają poprawnemu wynikowi.

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

    Deklaracja

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

    Parametry

    logits

    Zakodowane na gorąco wyjścia z sieci neuronowej.

    labels

    Indeksy (indeksowane zerami) prawidłowych wyników.

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

    Deklaracja

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

    Parametry

    logits

    Nieskalowany wynik sieci neuronowej.

    labels

    Wartości całkowite, które odpowiadają poprawnemu wyjściu.

  • 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 obecnym kontekstem, z wyjątkiem danej fazy uczenia się.

    Deklaracja

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

    Parametry

    context

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

    body

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

    Wartość zwracana

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

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

    Deklaracja

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

    Parametry

    learningPhase

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

    body

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

    Wartość zwracana

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

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

    Deklaracja

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

    Parametry

    randomSeed

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

    body

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

    Wartość zwracana

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

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

    Deklaracja

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

    Parametry

    randomNumberGenerator

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

    body

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

    Wartość zwracana

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

  • 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 działają. Jeśli parametr wait jest ustawiony na true, to wywołanie blokuje się do zakończenia obliczeń.

    Deklaracja

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

  • 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 różniczkowalną funkcję z wektorowo-jakobianowej funkcji iloczynu.

    Deklaracja

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

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

    Deklaracja

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

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

    Deklaracja

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

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

    Deklaracja

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

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

    Deklaracja

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

    Parametry

    kind

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

    index

    Urządzenie do uruchamiania operacji.

    body

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

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

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

    • „/ Device: CPU: 0”: Procesor twojego komputera.
    • „/ GPU: 0”: notacja krótka wskazująca na pierwszy GPU w komputerze, który jest widoczny dla TensorFlow
    • „/ Job: localhost / replica: 0 / task: 0 / device: GPU: 1”: w pełni kwalifikowana nazwa drugiego procesora graficznego w komputerze, która jest widoczna dla TensorFlow.

    Deklaracja

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

    Parametry

    name

    Nazwa urządzenia.

    body

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

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

    Deklaracja

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

    Parametry

    body

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

  • Zmień rozmiar obrazów do rozmiaru przy użyciu określonej metody.

    Warunek wstępny

    Obrazy muszą mieć rangę 3 lub 4 .

    Warunek wstępny

    Rozmiar musi być dodatni.

    Deklaracja

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

    Parametry

    images

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

    size

    Nowy rozmiar obrazów.

    method

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

    antialias

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

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

    Warunek wstępny

    Obrazy muszą mieć rangę 3 lub 4 .

    Warunek wstępny

    Rozmiar musi być dodatni.

    Deklaracja

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

    Parametry

    images

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

    size

    Nowy rozmiar obrazów.

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

    Warunek wstępny

    input musi mieć rangę 4 .

    Warunek wstępny

    filter musi mieć rangę 3 .

    Deklaracja

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

    Parametry

    input

    Wejście.

    filter

    Filtr rozszerzający.

    strides

    Kroki filtra ślizgowego dla każdego wymiaru wejścia.

    padding

    Wypełnienie dla operacji

    rates

    Współczynniki dylatacji dla każdego wymiaru wkładu.

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

    Warunek wstępny

    input musi mieć rangę 4 .

    Warunek wstępny

    filter musi mieć rangę 3.

    Deklaracja

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

    Parametry

    input

    Wejście.

    filter

    Filtr erozji.

    strides

    Kroki filtra ślizgowego dla każdego wymiaru wejścia.

    padding

    Wypełnienie dla operacji

    rates

    Współczynniki dylatacji dla każdego wymiaru wkładu.

  • 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 pamiętać, że nadawanie 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 jednorodną inicjalizację Glorota (Xavier) dla określonego kształtu, losowo próbkując wartości skalarne z jednolitego rozkładu między -limit i limit , generowane przez domyślny generator liczb losowych, gdzie limit to sqrt(6 / (fanIn + fanOut)) i fanIn / fanOut reprezentują liczbę funkcji wejściowych i wyjściowych pomnożoną przez pole odbiorcze, jeśli występuje.

    Deklaracja

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

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

    Deklaracja

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

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

    Deklaracja

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

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

    Deklaracja

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

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

    Deklaracja

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

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

    Deklaracja

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

  • Zwraca funkcję, która tworzy tensor, inicjując losowo wszystkie jego wartości z obciętego rozkładu normalnego. Wygenerowane wartości są zgodne z rozkładem normalnym ze średnią mean i odchyleniem standardowym odchylenia standardDeviation , z tym wyjątkiem, że wartości, których wielkość jest większa niż dwa odchylenia standardowe od średniej, są pomijane i ponownie próbkowane.

    Deklaracja

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

    Parametry

    mean

    Średnia rozkładu normalnego.

    standardDeviation

    Odchylenie standardowe rozkładu normalnego.

    Wartość zwracana

    Obcięta normalna funkcja inicjatora parametrów.

  • Deklaracja

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

  • Zwraca macierz tożsamości lub zestaw macierzy.

    Deklaracja

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

    Parametry

    rowCount

    Liczba wierszy w każdej macierzy partii.

    columnCount

    Liczba kolumn w każdej macierzy partii.

    batchShape

    Wiodące wymiary partii zwracanego tensora.

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

    Wejście to tensor o kształcie [..., M, N] . Wyjście to tensor o kształcie [...] .

    Warunek wstępny

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

    Deklaracja

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

    Parametry

    matrix

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

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

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

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

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

    Deklaracja

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

    Parametry

    input

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

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

    Warunek wstępny

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

    Warunek wstępny

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

    Deklaracja

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

    Parametry

    matrix

    Trójkątna macierz współczynników wejściowych, reprezentująca A w Ax = b .

    rhs

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

    lower

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

    adjoint

    Jeśli true , rozwiąż z łącznikiem matrix zamiast matrix . Wartość domyślna to false .

    Wartość zwracana

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

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

    Deklaracja

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

    Parametry

    predicted

    Przewidywane dane wyjściowe z sieci neuronowej.

    expected

    Oczekiwane wartości, tj. Cele, które odpowiadają poprawnemu wynikowi.

    reduction

    Redukcja do zastosowania na obliczonych wartościach strat elementarnych.

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

    Deklaracja

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

    Parametry

    predicted

    Przewidywane dane wyjściowe z sieci neuronowej.

    expected

    Oczekiwane wartości, czyli cele, które odpowiadają poprawnemu wynikowi.

    reduction

    Redukcja do zastosowania na obliczonych wartościach strat elementarnych.

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

    Deklaracja

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

    Parametry

    predicted

    Przewidywane dane wyjściowe z sieci neuronowej.

    expected

    Oczekiwane wartości, tj. Cele, które odpowiadają poprawnemu wynikowi.

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

    Deklaracja

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

    Parametry

    predicted

    Przewidywane dane wyjściowe z sieci neuronowej.

    expected

    Oczekiwane wartości, tj. Cele, które odpowiadają poprawnemu wynikowi.

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

    Uwaga

    Ujemne wpisy tensorów zostaną obcięte na 0 aby uniknąć niezdefiniowanego zachowania logarytmicznego, ponieważ log(_:) jest niezdefiniowany dla ujemnych liczb rzeczywistych.

    Deklaracja

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

    Parametry

    predicted

    Przewidywane dane wyjściowe z sieci neuronowej.

    expected

    Oczekiwane wartości, tj. Cele, które odpowiadają poprawnemu wynikowi.

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

    Deklaracja

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

    Parametry

    predicted

    Przewidywane dane wyjściowe z sieci neuronowej.

    expected

    Oczekiwane wartości, tj. Cele, które odpowiadają poprawnemu wynikowi.

  • Oblicza utratę zawiasów między predicted a expected . loss = reduction(max(0, 1 - predicted * expected)) expected wartości to -1 lub 1.

    Deklaracja

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

    Parametry

    predicted

    Przewidywane dane wyjściowe z sieci neuronowej.

    expected

    Oczekiwane wartości, tj. Cele, które odpowiadają poprawnemu wynikowi.

    reduction

    Redukcja, która ma zastosowanie do obliczonych wartości strat elementarnych.

  • Oblicza kwadratową utratę zawiasów między predicted a expected . loss = reduction(square(max(0, 1 - predicted * expected))) expected wartości to -1 lub 1.

    Deklaracja

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

    Parametry

    predicted

    Przewidywane dane wyjściowe z sieci neuronowej.

    expected

    Oczekiwane wartości, tj. Cele, które odpowiadają poprawnemu wynikowi.

    reduction

    Redukcja, która ma zastosowanie do obliczonych wartości strat elementarnych.

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

    Deklaracja

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

    Parametry

    predicted

    Przewidywane dane wyjściowe z sieci neuronowej.

    expected

    Oczekiwane wartości, tj. Cele, które odpowiadają poprawnemu wynikowi.

    reduction

    Redukcja, która ma zastosowanie do obliczonych wartości strat elementarnych.

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

    Deklaracja

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

    Parametry

    predicted

    Przewidywane dane wyjściowe z sieci neuronowej.

    expected

    Oczekiwane wartości, tj. Cele, które odpowiadają poprawnemu wynikowi.

    reduction

    Redukcja, która ma zastosowanie do obliczonych wartości strat elementarnych.

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

    Deklaracja

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

    Parametry

    predicted

    Przewidywane dane wyjściowe z sieci neuronowej.

    expected

    Oczekiwane wartości, tj. Cele, które odpowiadają poprawnemu wynikowi.

    reduction

    Redukcja, która ma zastosowanie do obliczonych wartości strat elementarnych.

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

    Deklaracja

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

    Parametry

    predicted

    Przewidywane dane wyjściowe z sieci neuronowej.

    expected

    Oczekiwane wartości, tj. Cele, które odpowiadają poprawnemu wynikowi.

    reduction

    Redukcja do zastosowania na obliczonych wartościach strat elementarnych.

  • Oblicza rzadką entropię krzyżową softmax (kategoryczną entropię krzyżową) między logitami i etykietami. Użyj tej funkcji utraty crossentropy, gdy istnieją co najmniej dwie klasy etykiet. Oczekujemy, że etykiety będą dostarczane jako liczby całkowite. Powinno istnieć # classes wartości zmiennoprzecinkowych na funkcję dla logits i jedna wartość zmiennoprzecinkowa na cechę dla expected .

    Deklaracja

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

    Parametry

    logits

    Zakodowane na gorąco wyjścia z sieci neuronowej.

    labels

    Indeksy (indeksowane zerami) prawidłowych wyników.

    reduction

    Redukcja do zastosowania na obliczonych wartościach strat elementarnych.

  • Oblicza rzadką entropię krzyżową softmax (kategoryczną entropię krzyżową) między logitami i etykietami. Użyj tej funkcji utraty krzyżowej, gdy istnieją co najmniej dwie klasy etykiet. Oczekujemy, że etykiety będą dostarczane w postaci reprezentacji one_hot . Dla każdego elementu powinno być # classes wartości zmiennoprzecinkowych.

    Deklaracja

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

    Parametry

    logits

    Nieskalowane prawdopodobieństwa w dzienniku z sieci neuronowej.

    probabilities

    Wartości prawdopodobieństwa, które odpowiadają poprawnemu wynikowi. Każdy wiersz musi być prawidłowym rozkładem prawdopodobieństwa.

    reduction

    Redukcja, która ma zastosowanie do obliczonych wartości strat elementarnych.

  • Oblicza sigmoidalną entropię krzyża (binarną entropię krzyżową) między logitami i etykietami. Użyj tej utraty entropii krzyżowej, gdy istnieją tylko dwie klasy etykiet (zakładane jako 0 i 1). W każdym przykładzie powinna istnieć jedna wartość zmiennoprzecinkowa na prognozę.

    Deklaracja

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

    Parametry

    logits

    Nieskalowany wynik sieci neuronowej.

    labels

    Wartości całkowite, które odpowiadają poprawnemu wyjściu.

    reduction

    Redukcja do zastosowania na obliczonych wartościach strat elementarnych.

  • Oblicza stratę Hubera między predicted a expected .

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

    Deklaracja

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

    Parametry

    predicted

    Przewidywane dane wyjściowe z sieci neuronowej.

    expected

    Oczekiwane wartości, tj. Cele, które odpowiadają poprawnemu wynikowi.

    delta

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

    reduction

    Redukcja, która ma zastosowanie do obliczonych wartości strat elementarnych.

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

    Deklaracja

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

  • Zwraca logarytm 1 + x elementarny.

    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.

    Uwaga

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

    Deklaracja

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

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

    Deklaracja

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

  • Zwraca wykładniczą wartość 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ładniczą wartość x - 1 elementarnie.

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

    Deklaracja

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

  • 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 miękki znak określonego elementu tensora. W szczególności oblicza features/ (abs(features) + 1) .

    Deklaracja

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

  • 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śli <0, w przeciwnym razie x . Zobacz szybkie i dokładne głębokie uczenie sieciowe według wykładniczych jednostek liniowych (ELU)

    Deklaracja

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

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

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

    Zobacz błąd Gaussian Error Linear Units .

    Deklaracja

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

  • Zwraca tensor, stosując funkcję aktywacji ReLU do określonego elementu tensora. W szczególności oblicza max(0, x) .

    Deklaracja

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

  • 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, stosując nieszczelną funkcję aktywacji ReLU do określonego elementu tensora. W szczególności oblicza max(x, x * alpha) .

    Deklaracja

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

  • Zwraca tensor przez zastosowanie funkcji aktywacji SeLU, a mianowicie scale * alpha * (exp(x) - 1) if x < 0 , oraz scale * x inaczej.

    Uwaga

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

    Deklaracja

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

  • Zwraca tensor przez zastosowanie funkcji aktywacji swish, a mianowicie x * sigmoid(x) .

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

    Deklaracja

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

  • Zwraca tensor przez zastosowanie funkcji aktywacji twardej esicy, mianowicie Relu6(x+3)/6 .

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

    Deklaracja

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

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

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

    Deklaracja

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

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

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

    Deklaracja

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

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

    Deklaracja

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

  • Zwraca n ty pierwiastek tensora pod względem elementu.

    Deklaracja

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

  • 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 maksymalnie dwa tensory w odniesieniu do elementów.

    Uwaga

    max obsługuje nadawanie.

    Deklaracja

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

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

    Deklaracja

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

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

    Deklaracja

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

  • Zwraca minimum dwóch tensorów pod względem elementu.

    Uwaga

    min obsługuje nadawanie.

    Deklaracja

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

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

    Deklaracja

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

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

    Deklaracja

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

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

    Deklaracja

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

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

    Deklaracja

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

  • Wykonuje mnożenie macierzy z innym tensorem i zwraca wynik.

    Deklaracja

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

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

    Warunek wstępny

    input musi mieć rangę 3 .

    Warunek wstępny

    filter musi mieć rangę 3.

    Deklaracja

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

    Parametry

    input

    Wejście.

    filter

    Filtr splotu.

    stride

    Krok przesuwanego filtra.

    padding

    Wypełnienie dla operacji.

    dilation

    Współczynnik dylatacji.

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

    Warunek wstępny

    input musi mieć rangę 4 .

    Warunek wstępny

    filter musi mieć rangę 4.

    Deklaracja

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

    Parametry

    input

    Wejście.

    filter

    Filtr splotu.

    strides

    Kroki filtra ślizgowego dla każdego wymiaru wejścia.

    padding

    Wypełnienie dla operacji

    dilations

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

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

    Warunek wstępny

    input musi mieć rangę 4 .

    Warunek wstępny

    filter musi mieć rangę 4.

    Deklaracja

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

    Parametry

    input

    Wejście.

    shape

    Wyjściowy kształt operacji dekonwolucji.

    filter

    Filtr splotu.

    strides

    Kroki filtra ślizgowego dla każdego wymiaru wejścia.

    padding

    Wypełnienie dla operacji

    dilations

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

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

    Warunek wstępny

    input musi mieć rangę 5 .

    Warunek wstępny

    filter musi mieć rangę 5.

    Deklaracja

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

    Parametry

    input

    Wejście.

    filter

    Filtr splotu.

    strides

    Kroki filtra ślizgowego dla każdego wymiaru wejścia.

    padding

    Wypełnienie dla operacji.

    dilations

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

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

    Warunek wstępny

    input musi mieć rangę 4.

    Warunek wstępny

    filter musi mieć rangę 4.

    Deklaracja

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

    Parametry

    input

    Wejście.

    filter

    Filtr splotu wgłębnego.

    strides

    Kroki filtra ślizgowego dla każdego wymiaru wejścia.

    padding

    Wypełnienie dla operacji.

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

    Declaration

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

    Parameters

    input

    The input.

    filterSize

    The dimensions of the pooling kernel.

    strides

    The strides of the sliding filter for each dimension of the input.

    padding

    The padding for the operation.

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

    Declaration

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

    Parameters

    input

    The input.

    filterSize

    The dimensions of the pooling kernel.

    strides

    The strides of the sliding filter for each dimension of the input.

    padding

    The padding for the operation.

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

    Declaration

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

    Parameters

    input

    The input.

    filterSize

    The dimensions of the pooling kernel.

    strides

    The strides of the sliding filter for each dimension of the input.

    padding

    The padding for the operation.

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

    Declaration

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

    Parameters

    input

    The input.

    filterSize

    The dimensions of the pooling kernel.

    strides

    The strides of the sliding filter for each dimension of the input.

    padding

    The padding for the operation.

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

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

    Declaration

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

    Parameters

    input

    A Tensor. 4-D with shape [batch, height, width, channels] .

    poolingRatio

    A list of Doubles . Pooling ratio for each dimension of input , currently only supports row and col dimension and should be >= 1.0.

    pseudoRandom

    An optional Bool . Defaults to false . When set to true , generates the pooling sequence in a pseudorandom fashion, otherwise, in a random fashion.

    overlapping

    An optional Bool . Defaults to false . When set to true , it means when pooling, the values at the boundary of adjacent pooling cells are used by both cells.

    deterministic

    An Optional Bool . When set to true , a fixed pooling region will be used when iterating over a fractionalMaxPool2D node in the computation graph.

    seed

    An optional Int64 . Defaults to 0 . If set to be non-zero, the random number generator is seeded by the given seed.

    seed2

    An optional Int64 . Defaults to 0 . A second seed to avoid seed collision.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    Precondition

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

    Precondition

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

    Declaration

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    Precondition

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

    Precondition

    The height of the input must be divisible by b .

    Precondition

    The width of the input must be divisible by b .

    Declaration

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

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

    Declaration

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

  • Builds a SGD based per-weight optimizer.

    Declaration

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

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

    Reference: “Adam - A Method for Stochastic Optimization”

    Declaration

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

  • Generates a new random seed for TensorFlow.

    Declaration

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

  • Concatenates two values.

    Declaration

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

  • Adds two values and produces their sum.

    Declaration

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

  • Averages two values.

    Declaration

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

  • Multiplies two values.

    Declaration

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

  • Stack two values.

    Declaration

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

  • Declaration

    public func PrintX10Metrics()

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

    Declaration

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

  • Declaration

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

  • Maps a function over n threads.

    Declaration

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