Fonksiyonlar

Aşağıdaki işlevler küresel olarak kullanılabilir.

  • Tahminler ve beklentiler arasındaki L1 kaybını döndürür.

    beyanname

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

    parametreler

    predicted

    Bir sinir ağından tahmin edilen çıktılar.

    expected

    Beklenen değerler, yani doğru çıktıya karşılık gelen hedefler.

  • Tahminler ve beklentiler arasındaki L2 kaybını döndürür.

    beyanname

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

    parametreler

    predicted

    Bir sinir ağından tahmin edilen çıktılar.

    expected

    Beklenen değerler, yani doğru çıktıya karşılık gelen hedefler.

  • Tahminler ve beklentiler arasındaki menteşe kaybını döndürür.

    beyanname

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

    parametreler

    predicted

    Bir sinir ağından tahmin edilen çıktılar.

    expected

    Beklenen değerler, yani doğru çıktıya karşılık gelen hedefler.

  • Tahminler ve beklentiler arasındaki menteşe kaybının karesini döndürür.

    beyanname

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

    parametreler

    predicted

    Bir sinir ağından tahmin edilen çıktılar.

    expected

    Beklenen değerler, yani doğru çıktıya karşılık gelen hedefler.

  • Tahminler ve beklentiler arasındaki kategorik menteşe kaybını döndürür.

    beyanname

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

    parametreler

    predicted

    Bir sinir ağından tahmin edilen çıktılar.

    expected

    Beklenen değerler, yani doğru çıktıya karşılık gelen hedefler.

  • Tahminler ve beklentiler arasındaki hatanın hiperbolik kosinüsünün logaritmasını döndürür.

    beyanname

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

    parametreler

    predicted

    Bir sinir ağından tahmin edilen çıktılar.

    expected

    Beklenen değerler, yani doğru çıktıya karşılık gelen hedefler.

  • Tahminler ve beklentiler arasındaki Poisson kaybını döndürür.

    beyanname

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

    parametreler

    predicted

    Bir sinir ağından tahmin edilen çıktılar.

    expected

    Beklenen değerler, yani doğru çıktıya karşılık gelen hedefler.

  • Beklentiler ve tahminler arasındaki Kullback-Leibler sapmasını (KL sapmasını) döndürür. İki dağılımları dikkate alındığında p ve q , KL sapma hesaplar p * log(p / q) .

    beyanname

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

    parametreler

    predicted

    Bir sinir ağından tahmin edilen çıktılar.

    expected

    Beklenen değerler, yani doğru çıktıya karşılık gelen hedefler.

  • Logitler ve etiketler arasındaki softmax çapraz entropiyi (kategorik çapraz entropi) döndürür.

    beyanname

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

    parametreler

    logits

    Bir sinir ağından tek sıcak kodlanmış çıktılar.

    labels

    Doğru çıktıların endeksleri (sıfır endeksli).

  • Logitler ve etiketler arasındaki sigmoid çapraz entropiyi (ikili çapraz entropi) döndürür.

    beyanname

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

    parametreler

    logits

    Bir sinir ağının ölçeklenmemiş çıktısı.

    labels

    Doğru çıktıya karşılık gelen tamsayı değerleri.

  • Belirtilen tensörle aynı şekle ve skalere sahip bir tensör döndürür.

    beyanname

    @differentiable
public func identity<Scalar>(_ x: Tensor<Scalar>) -> Tensor<Scalar> where Scalar : TensorFlowScalar

  • Verilen öğrenme aşaması dışında geçerli bağlamla aynı olan her şeye sahip bir bağlam içinde verilen kapanışı çağırır.

    beyanname

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

    parametreler

    context

    Kapatmadan önce ayarlanacak bir bağlam çağrılır ve kapatma geri döndükten sonra geri yüklenir.

    body

    Sıfır kapatma. Kapak, bir geri dönüş değeri vardır, bu değer aynı zamanda dönüş değeri olarak kullanılır withContext(_:_:) fonksiyonu.

    Geri dönüş değeri

    Dönüş değeri, eğer varsa body kapatılması.

  • Verilen öğrenme aşaması dışında geçerli bağlamla aynı olan her şeye sahip bir bağlam içinde verilen kapanışı çağırır.

    beyanname

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

    parametreler

    learningPhase

    Kapatmadan önce ayarlanacak bir öğrenme aşaması çağrılır ve kapanış geri döndükten sonra geri yüklenir.

    body

    Sıfır kapatma. Kapak, bir geri dönüş değeri vardır, bu değer aynı zamanda dönüş değeri olarak kullanılır withLearningPhase(_:_:) fonksiyonu.

    Geri dönüş değeri

    Dönüş değeri, eğer varsa body kapatılması.

  • Verilen rasgele tohum dışında geçerli bağlamla aynı olan her şeye sahip bir bağlam içinde verilen kapanışı çağırır.

    beyanname

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

    parametreler

    randomSeed

    Kapatmadan önce ayarlanacak rastgele bir tohum çağrılır ve kapatma geri döndükten sonra geri yüklenir.

    body

    Sıfır kapatma. Kapak, bir geri dönüş değeri vardır, bu değer aynı zamanda dönüş değeri olarak kullanılır withRandomSeedForTensorFlow(_:_:) fonksiyonu.

    Geri dönüş değeri

    Dönüş değeri, eğer varsa body kapatılması.

  • Verilen rasgele sayı üreteci dışında geçerli bağlamla aynı olan her şeye sahip bir bağlam içinde verilen kapatmayı çağırır.

    beyanname

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

    parametreler

    randomNumberGenerator

    Kapatmadan önce ayarlanacak bir rasgele sayı üreteci, kapatma geri döndükten sonra çağrılır ve geri yüklenir.

    body

    Sıfır kapatma. Kapak, bir geri dönüş değeri vardır, bu değer aynı zamanda dönüş değeri olarak kullanılır withRandomNumberGeneratorForTensorFlow(_:_:) fonksiyonu.

    Geri dönüş değeri

    Dönüş değeri, eğer varsa body kapatılması.

  • beyanname

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

  • LazyTensorBarrier, tüm canlı tensörlerin (sağlanmışsa cihazda) planlanmasını ve çalışmasını sağlar. wait true olarak ayarlanırsa, bu çağrı hesaplama tamamlanana kadar engeller.

    beyanname

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

  • beyanname

    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

  • beyanname

    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

  • beyanname

    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

  • beyanname

    public func valueWithGradient<T, R>(
  of f: @escaping @differentiable (T) -> Tensor<R>
) -> (T) -> (value: Tensor<R>, gradient: T.TangentVector)
where T: Differentiable, R: TensorFlowFloatingPoint

  • beyanname

    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

  • beyanname

    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

  • beyanname

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

  • beyanname

    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

  • beyanname

    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

  • beyanname

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

  • beyanname

    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

  • beyanname

    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

  • Geleneksel otomatik farklılaşmada "kontrol noktası" olarak bilinen bir fonksiyonun geri çekilmesinde yeniden hesaplanmasını sağlayın.

    beyanname

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

  • Bir vektör-Jacobian ürünleri işlevinden türevlenebilir bir işlev oluşturun.

    beyanname

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

  • Bir vektör-Jacobian ürünleri işlevinden türevlenebilir bir işlev oluşturun.

    beyanname

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

  • İade x kimlik fonksiyonu gibi. Bir bağlamda kullanıldığında x göre farklılaştırılmış olan bu işlev de, türev üretmeyecektir x .

    beyanname

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

  • Verilen kapatma uygular body için x . Bir bağlamda kullanıldığında x göre farklılaştırılmış olan bu işlev de, türev üretmeyecektir x .

    beyanname

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

  • Bir kapatma yürütür ve TensorFlow işlemlerinin belirli bir cihaz türünde çalışmasını sağlar.

    beyanname

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

    parametreler

    kind

    TensorFlow işlemlerini çalıştırmak için bir tür cihaz.

    index

    İşlemleri çalıştıracak cihaz.

    body

    Belirtilen cihaz türünde TensorFlow işlemleri yürütülecek bir kapatma.

  • Bir kapatma yürütür ve TensorFlow işlemlerinin belirli bir ada sahip bir cihazda çalışmasını sağlar.

    Cihaz adlarına bazı örnekler:

    • “/device:CPU:0”: Makinenizin CPU'su.
    • “/GPU:0”: Makinenizin TensorFlow tarafından görülebilen ilk GPU'su için kısa el gösterimi
    • “/job:localhost/replica:0/task:0/device:GPU:1”: Makinenizin TensorFlow tarafından görülebilen ikinci GPU'sunun tam nitelikli adı.

    beyanname

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

    parametreler

    name

    Cihaz adı.

    body

    Belirtilen cihaz türünde TensorFlow işlemleri yürütülecek bir kapatma.

  • TensorFlow'un TensorFlow işlemlerini herhangi bir cihaza yerleştirmesine izin veren bir kapatma yürütür. Bu, varsayılan yerleştirme davranışını geri yüklemelidir.

    beyanname

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

    parametreler

    body

    Belirtilen cihaz türünde TensorFlow işlemleri yürütülecek bir kapatma.

  • Belirtilen yöntemi kullanarak görüntüleri yeniden boyutlandırın.

    ön koşul

    Görüntüler dereceye sahip olmalıdır 3 veya 4 .

    ön koşul

    Boyut pozitif olmalıdır.

    beyanname

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

    parametreler

    images

    4-d Tensor şeklinin [batch, height, width, channels] ya da 3-D Tensor şeklin [height, width, channels] .

    size

    Görüntülerin yeni boyutu.

    method

    Yeniden boyutlandırma yöntemi. Varsayılan değerdir .bilinear .

    antialias

    İff true bir görüntü altörnekleme zaman bir anti-aliasing filtre kullanın.

  • Alan enterpolasyonu kullanarak görüntüleri yeniden boyutlandırın.

    ön koşul

    Görüntüler dereceye sahip olmalıdır 3 veya 4 .

    ön koşul

    Boyut pozitif olmalıdır.

    beyanname

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

    parametreler

    images

    4-d Tensor şeklinin [batch, height, width, channels] ya da 3-D Tensor şeklin [height, width, channels] .

    size

    Görüntülerin yeni boyutu.

  • Belirtilen giriş, filtre, adımlar ve dolgu ile 2 boyutlu bir genişletme döndürür.

    ön koşul

    input dereceye sahip olmalıdır 4 .

    ön koşul

    filter dereceye sahip olmalıdır 3 .

    beyanname

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

    parametreler

    input

    Girdi.

    filter

    Genişletme filtresi.

    strides

    Girişin her boyutu için kayan filtrenin adımları.

    padding

    Operasyon için dolgu

    rates

    Girişin her boyutu için genişleme oranları.

  • Belirtilen giriş, filtre, adımlar ve dolgu ile 2B aşındırma döndürür.

    ön koşul

    input dereceye sahip olmalıdır 4 .

    ön koşul

    filter sıralaması 3 olması gerekir.

    beyanname

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

    parametreler

    input

    Girdi.

    filter

    Erozyon filtresi.

    strides

    Girişin her boyutu için kayan filtrenin adımları.

    padding

    Operasyon için dolgu

    rates

    Girişin her boyutu için genişleme oranları.

  • Tüm değerlerini sıfır olarak başlatarak bir tensör oluşturan bir işlev döndürür.

    beyanname

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

  • Tüm değerlerini sağlanan değere başlatarak bir tensör oluşturan bir işlev döndürür.

    beyanname

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

  • Sağlanan değere başlatarak bir tensör oluşturan bir işlev döndürür. Sağlanan değerin yayın desteklenmediğini unutmayın.

    beyanname

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

  • İade rasgele arasında tek bir şekilde dağılımı ile ilgili sayısal değerler, örnekleme belirtilen şekil için tek tip başlatma Glorot (Xavier'i) gerçekleştirerek bir tensörünün oluşturan bir fonksiyonu -limit ve limit sınırı varsayılan rasgele sayı üreteci tarafından üretilen, sqrt(6 / (fanIn + fanOut)) ve fanIn / fanOut giriş sayısını temsil eder ve mevcut olduğu takdirde çıkışı, açık alan ile çarpılır özellikleri.

    beyanname

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

  • İade rastgele kesilmiş normal dağılımdan skaler değerleri numune, özel bir şekle normal başlatma Glorot (Xavier'i) gerçekleştirerek bir tensörünün yaratan bir fonksiyonu merkezli 0 standart sapma ile sqrt(2 / (fanIn + fanOut)) , fanIn / fanOut varsa, alıcı alan boyutuyla çarpılan giriş ve çıkış özelliklerinin sayısını temsil eder.

    beyanname

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

  • İade rasgele arasında tek bir şekilde dağılımı ile ilgili sayısal değerler, örnekleme O (Kaiming) belirli bir şekil için tek tip başlatma işlemi ile tensörünün oluşturan bir fonksiyonu -limit ve limit sınırı varsayılan rasgele sayı üreteci tarafından üretilen, sqrt(6 / fanIn) ve fanIn mevcut olduğu takdirde, açık alan ile çarpılan giriş özellikleri sayısını temsil eder.

    beyanname

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

  • İade rastgele kesilmiş normal dağılımdan skaler değerleri numune, belirtilen şekil için He (Kaiming), normal başlatma işlemi ile tensörünün yaratan bir fonksiyonu merkezli 0 standart sapma ile sqrt(2 / fanIn) , fanIn giriş özellikleri sayısını temsil eder varsa, alıcı alan boyutuyla çarpılır.

    beyanname

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

  • İade rasgele arasında tek bir şekilde dağılımı ile ilgili sayısal değerler, örnekleme belirtilen şekil için LeCun üniform başlatma işlemi ile tensörünün oluşturan bir fonksiyonu -limit ve limit sınırı varsayılan rasgele sayı üreteci tarafından üretilen, sqrt(3 / fanIn) ve fanIn mevcut olduğu takdirde, açık alan ile çarpılan giriş özellikleri sayısını temsil eder.

    beyanname

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

  • İade rastgele kesilmiş normal dağılımdan skaler değerleri numune, özel bir şekle yönelik LeCun, normal başlatma işlemi ile tensörünün yaratan bir fonksiyonu merkezli 0 standart sapma ile sqrt(1 / fanIn) , fanIn ile çarpılır özellikleri giriş sayısını temsil eder varsa, alıcı alan boyutu.

    beyanname

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

  • Tüm değerlerini kesilmiş bir Normal dağılımdan rasgele başlatarak bir tensör oluşturan bir işlev döndürür. Oluşturulan değerler ortalama ile normal bir dağılım izleyin mean ve standart sapma standardDeviation büyüklüğü ortalama iki standart sapma düştü ve resampled vardır fazla olduğunu değerlere hariç.

    beyanname

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

    parametreler

    mean

    Normal dağılımın ortalaması.

    standardDeviation

    Normal dağılımın standart sapması.

    Geri dönüş değeri

    Kesik bir normal parametre başlatıcı işlevi.

  • beyanname

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

  • Bir kimlik matrisi veya bir toplu matris döndürür.

    beyanname

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

    parametreler

    rowCount

    Her parti matrisindeki satır sayısı.

    columnCount

    Her parti matrisindeki sütun sayısı.

    batchShape

    Döndürülen tensörün önde gelen parti boyutları.

  • İsteğe bağlı olarak toplu bir matrisin izini hesaplar. İz, her en içteki matrisin ana köşegeni boyunca toplamıdır.

    Girdi şekli ile bir tensör olan [..., M, N] . Çıkış şeklinde bir tensör olan [...] .

    ön koşul

    matrix şeklinde bir tensör olmalıdır [..., M, N] .

    beyanname

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

    parametreler

    matrix

    Şeklinin bir tensör [..., M, N] .

  • Bir veya daha fazla kare matrisin Cholesky ayrıştırmasını döndürür.

    Girdi şekli bir tensör olan [..., M, M] olan en iç 2 boyutları kare matris oluşturur.

    Girdi simetrik ve pozitif tanımlı olmalıdır. Bu işlem için girişin yalnızca alt üçgen kısmı kullanılacaktır. Üst üçgen kısım okunmayacaktır.

    Çıkış tüm giriş submatrices için Cholesky ayrışmaları içeren girdi olarak aynı şekilde bir tensör olan [..., :, :] .

    beyanname

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

    parametreler

    input

    Şeklinin bir tensör [..., M, M] .

  • İade çözelti x lineer denklem sistemine ile temsil edilen Ax = b .

    ön koşul

    matrix şeklinde bir tensör olmalıdır [..., M, M] .

    ön koşul

    rhs şekli olan bir tensör olmalıdır [..., M, K] .

    beyanname

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

    parametreler

    matrix

    Temsil eden giriş üçgen katsayısı matrisi, A bölgesindeki Ax = b .

    rhs

    Sağ taraftaki değerleri temsil b içinde Ax = b .

    lower

    İster matrix daha düşük bir üçgen (olduğunu true ) veya üst üçgen ( false ). Varsayılan değer true .

    adjoint

    Eğer true , bir eşlenik ile çözmek matrix yerine matrix . Varsayılan değer false .

    Geri dönüş değeri

    Çözelti x lineer denklem sistemine ile temsil edilen Ax = b . x aynı şekle sahiptir b .

  • Arasındaki L1 kaybı hesaplar expected ve predicted . loss = reduction(abs(expected - predicted))

    beyanname

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

    parametreler

    predicted

    Bir sinir ağından tahmin edilen çıktılar.

    expected

    Beklenen değerler, yani doğru çıktıya karşılık gelen hedefler.

    reduction

    Hesaplanan eleman bazında kayıp değerlerine uygulanacak azaltma.

  • Arasındaki L2 kaybı hesaplar expected ve predicted . loss = reduction(square(expected - predicted))

    beyanname

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

    parametreler

    predicted

    Bir sinir ağından tahmin edilen çıktılar.

    expected

    Beklenen değerler, yani doğru çıktıya karşılık gelen hedefler.

    reduction

    Hesaplanan eleman bazında kayıp değerlerine uygulanacak azaltma.

  • Etiketler ve tahminler arasındaki mutlak farkın ortalamasını hesaplar. loss = mean(abs(expected - predicted))

    beyanname

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

    parametreler

    predicted

    Bir sinir ağından tahmin edilen çıktılar.

    expected

    Beklenen değerler, yani doğru çıktıya karşılık gelen hedefler.

  • Etiketler ve tahminler arasındaki hataların karelerinin ortalamasını hesaplar. loss = mean(square(expected - predicted))

    beyanname

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

    parametreler

    predicted

    Bir sinir ağından tahmin edilen çıktılar.

    expected

    Beklenen değerler, yani doğru çıktıya karşılık gelen hedefler.

  • Arasındaki ortalama kare logaritmik hatayı hesaplar predicted ve expected loss = square(log(expected) - log(predicted))

    Not

    Negatif tensör girişleri kelepçelenmiş edilecektir 0 olarak tanımlanmamış logaritmik davranıştan kaçınmak için log(_:) negatif reals tanımlanmamış.

    beyanname

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

    parametreler

    predicted

    Bir sinir ağından tahmin edilen çıktılar.

    expected

    Beklenen değerler, yani doğru çıktıya karşılık gelen hedefler.

  • Arasındaki ortalama mutlak yüzde hata hesaplar predicted ve expected . loss = 100 * mean(abs((expected - predicted) / abs(expected)))

    beyanname

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

    parametreler

    predicted

    Bir sinir ağından tahmin edilen çıktılar.

    expected

    Beklenen değerler, yani doğru çıktıya karşılık gelen hedefler.

  • Arasındaki menteşe kaybını hesaplar predicted ve expected . loss = reduction(max(0, 1 - predicted * expected)) expected değerler olması beklenmektedir 1 veya 1 edilmektedir.

    beyanname

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

    parametreler

    predicted

    Bir sinir ağından tahmin edilen çıktılar.

    expected

    Beklenen değerler, yani doğru çıktıya karşılık gelen hedefler.

    reduction

    Hesaplanan eleman bazında kayıp değerlerine uygulanacak azaltma.

  • Arasındaki karesi menteşe kaybını hesaplar predicted ve expected . loss = reduction(square(max(0, 1 - predicted * expected))) expected değerler olması beklenmektedir 1 veya 1 edilmektedir.

    beyanname

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

    parametreler

    predicted

    Bir sinir ağından tahmin edilen çıktılar.

    expected

    Beklenen değerler, yani doğru çıktıya karşılık gelen hedefler.

    reduction

    Hesaplanan eleman bazında kayıp değerlerine uygulanacak azaltma.

  • Arasında kategorik menteşe kaybı hesaplar predicted ve expected . loss = maximum(negative - positive + 1, 0) negative = max((1 - expected) * predicted) ve positive = sum(predicted * expected)

    beyanname

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

    parametreler

    predicted

    Bir sinir ağından tahmin edilen çıktılar.

    expected

    Beklenen değerler, yani doğru çıktıya karşılık gelen hedefler.

    reduction

    Hesaplanan eleman bazında kayıp değerlerine uygulanacak azaltma.

  • Tahmin hatasının hiperbolik kosinüsünün logaritmasını hesaplar. logcosh = log((exp(x) + exp(-x))/2) x hata olan, predicted - expected

    beyanname

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

    parametreler

    predicted

    Bir sinir ağından tahmin edilen çıktılar.

    expected

    Beklenen değerler, yani doğru çıktıya karşılık gelen hedefler.

    reduction

    Hesaplanan eleman bazında kayıp değerlerine uygulanacak azaltma.

  • Tahmin ve Poisson kaybı beklenen arasındaki Poisson kaybı hesaplar unsurları ortalamasıdır Tensor predicted - expected * log(predicted) .

    beyanname

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

    parametreler

    predicted

    Bir sinir ağından tahmin edilen çıktılar.

    expected

    Beklenen değerler, yani doğru çıktıya karşılık gelen hedefler.

    reduction

    Hesaplanan eleman bazında kayıp değerlerine uygulanacak azaltma.

  • Arasındaki hesaplar Kullback-Leibler sapma kaybı expected ve predicted . loss = reduction(expected * log(expected / predicted))

    beyanname

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

    parametreler

    predicted

    Bir sinir ağından tahmin edilen çıktılar.

    expected

    Beklenen değerler, yani doğru çıktıya karşılık gelen hedefler.

    reduction

    Hesaplanan eleman bazında kayıp değerlerine uygulanacak azaltma.

  • Logitler ve etiketler arasındaki seyrek softmax çapraz entropiyi (kategorik çapraz entropi) hesaplar. İki veya daha fazla etiket sınıfı olduğunda bu çapraz entropi kaybı işlevini kullanın. Etiketlerin tamsayı olarak sağlanmasını bekliyoruz. Olmalıdır # classes için özellik başına kayan nokta değeri logits için ve özellik başına tek kayan nokta değeri expected .

    beyanname

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

    parametreler

    logits

    Bir sinir ağından tek sıcak kodlanmış çıktılar.

    labels

    Doğru çıktıların endeksleri (sıfır endeksli).

    reduction

    Hesaplanan eleman bazında kayıp değerlerine uygulanacak azaltma.

  • Logitler ve etiketler arasındaki seyrek softmax çapraz entropiyi (kategorik çapraz entropi) hesaplar. İki veya daha fazla etiket sınıfı olduğunda bu çapraz entropi kaybı işlevini kullanın. Biz etiketler temin sağlanacak beklemek one_hot temsil. Olmalıdır # classes özellik başına kayan nokta değeri.

    beyanname

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

    parametreler

    logits

    Bir sinir ağından ölçeklenmemiş günlük olasılıkları.

    probabilities

    Doğru çıktıya karşılık gelen olasılık değerleri. Her satır geçerli bir olasılık dağılımı olmalıdır.

    reduction

    Hesaplanan eleman bazında kayıp değerlerine uygulanacak azaltma.

  • Logitler ve etiketler arasındaki sigmoid çapraz entropiyi (ikili çapraz entropi) hesaplar. Yalnızca iki etiket sınıfı (0 ve 1 olduğu varsayılır) olduğunda bu çapraz entropi kaybını kullanın. Her örnek için, tahmin başına tek bir kayan nokta değeri olmalıdır.

    beyanname

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

    parametreler

    logits

    Bir sinir ağının ölçeklenmemiş çıktısı.

    labels

    Doğru çıktıya karşılık gelen tamsayı değerleri.

    reduction

    Hesaplanan eleman bazında kayıp değerlerine uygulanacak azaltma.

  • Arasında Huber kaybını hesaplar predicted ve expected .

    Her değer için x de error = expected - predicted :

    • 0.5 * x^2 eğer |x| <= δ .

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

    • Kaynak: Wikipedia makalesi .

    beyanname

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

    parametreler

    predicted

    Bir sinir ağından tahmin edilen çıktılar.

    expected

    Beklenen değerler, yani doğru çıktıya karşılık gelen hedefler.

    delta

    Huber kayıp fonksiyonunun ikinci dereceden doğrusala değiştiği noktayı temsil eden bir kayan noktalı skaler.

    reduction

    Hesaplanan eleman bazında kayıp değerlerine uygulanacak azaltma.

  • Belirtilen tensörün mutlak değerini eleman bazında döndürür.

    beyanname

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

  • Belirtilen tensör öğesi açısından doğal logaritmasını döndürür.

    beyanname

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

  • Belirtilen tensör öğesi açısından iki taban logaritmasını döndürür.

    beyanname

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

  • Belirtilen tensör öğesi açısından on tabanlı logaritmasını döndürür.

    beyanname

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

  • İade logaritması 1 + x öğeye göre.

    beyanname

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

  • İade log(1 - exp(x)) sayısal olarak sabit bir yaklaşım kullanılmıştır.

    Not

    : Yaklaşım Denklem 7'de gösterilmektedir https://cran.r-project.org/web/packages/Rmpfr/vignettes/log1mexp-note.pdf .

    beyanname

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

  • Belirtilen tensörün sinüsünü eleman bazında döndürür.

    beyanname

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

  • Belirtilen tensörün kosinüsünü eleman bazında döndürür.

    beyanname

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

  • Belirtilen tensörün tanjantını öğe bazında döndürür.

    beyanname

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

  • Belirtilen tensör elemanının hiperbolik sinüsünü döndürür.

    beyanname

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

  • Belirtilen tensör elemanının hiperbolik kosinüsünü döndürür.

    beyanname

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

  • Belirtilen tensörün hiperbolik tanjantını öğe bazında döndürür.

    beyanname

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

  • Belirtilen tensör elemanının ters kosinüsünü döndürür.

    beyanname

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

  • Belirtilen tensör elemanının ters sinüsünü döndürür.

    beyanname

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

  • Belirtilen tensör elemanının ters tanjantını döndürür.

    beyanname

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

  • Belirtilen tensör elemanının ters hiperbolik kosinüsünü döndürür.

    beyanname

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

  • Belirtilen tensör öğesi açısından ters hiperbolik sinüsü döndürür.

    beyanname

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

  • Belirtilen tensör elemanının ters hiperbolik tanjantını döndürür.

    beyanname

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

  • Belirtilen tensörün karekökünü eleman bazında döndürür.

    beyanname

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

  • Belirtilen tensör elemanının ters karekökünü döndürür.

    beyanname

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

  • Belirtilen tensör öğesinin üstel değerini döndürür.

    beyanname

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

  • Belirtilen tensörün gücüne yükseltilmiş iki öğeyi döndürür.

    beyanname

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

  • Belirtilen tensör öğesinin gücüne yükseltilmiş on değerini döndürür.

    beyanname

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

  • İade üstel x - 1 elemanı-bilge.

    beyanname

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

  • Öğe bazında en yakın tamsayıya yuvarlanmış belirtilen tensörün değerlerini döndürür.

    beyanname

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

  • Belirtilen tensörün tavanını eleman bazında döndürür.

    beyanname

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

  • Belirtilen tensörün tabanını eleman bazında döndürür.

    beyanname

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

  • Belirtilen tensör elemanının işaretinin bir göstergesini döndürür. Spesifik olarak, hesaplar y = sign(x) = -1 ise x < 0 ; 0 ise x == 0 ; 1, eğer x > 0 .

    beyanname

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

  • Belirtilen tensör elemanının sigmoidini döndürür. Spesifik olarak, hesaplar 1 / (1 + exp(-x)) .

    beyanname

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

  • Belirtilen tensör öğesi açısından log-sigmoid değerini döndürür. Spesifik olarak, log(1 / (1 + exp(-x))) . Sayısal stabilite için, kullanımı -softplus(-x) .

    beyanname

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

  • Belirtilen tensör öğesinin softplus değerini döndürür. Özellikle, değerlerini hesaplar log(exp(features) + 1) .

    beyanname

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

  • Belirtilen tensörün yumuşak işaretini öğe bazında döndürür. Özellikle, hesaplar features/ (abs(features) + 1) .

    beyanname

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

  • Son eksen boyunca belirtilen tensörün softmax değerini döndürür. Spesifik olarak, değerlerini hesaplar exp(x) / exp(x).sum(alongAxes: -1) .

    beyanname

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

  • Belirtilen eksen boyunca belirtilen tensörün softmax değerini döndürür. Spesifik olarak, değerlerini hesaplar exp(x) / exp(x).sum(alongAxes: axis) .

    beyanname

    @differentiable
public func softmax<T>(_ x: Tensor<T>, alongAxis axis: Int) -> Tensor<T> where T : TensorFlowFloatingPoint

  • Belirtilen tensör öğesi açısından log-softmax değerini döndürür.

    beyanname

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

  • Üstel bir doğrusal birim uygulayarak bir tensör döndürür. Spesifik olarak, değerlerini hesaplar exp(x) - 1 <0, eğer x , aksi. Bkz Üstel Lineer Birimleri tarafından Hızlı ve Doğru Derin Ağ Öğrenme (Elus)

    beyanname

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

  • Belirtilen tensör öğesi açısından Gauss Hatası Doğrusal Birimi (GELU) etkinleştirmelerini döndürür.

    Spesifik olarak, gelu yaklaşır xP(X <= x) , burada P(X <= x) standart Gauss kümülatif dağılım hesaplayarak gibidir: X * [0.5 * (1 + tanh [√ (2 / π) * (x + 0.044715 * x^3)])].

    Bkz Gauss Hata Lineer Birimleri .

    beyanname

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

  • ReLU etkinleştirme işlevini belirtilen tensör öğesi açısından uygulayarak bir tensör döndürür. Spesifik olarak, hesaplar max(0, x) .

    beyanname

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

  • İade yani ReLU6 aktivasyon fonksiyonunu uygulanarak bir tensör min(max(0, x), 6) .

    beyanname

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

  • Sızdıran ReLU etkinleştirme işlevini belirtilen tensör öğesi açısından uygulayarak bir tensör döndürür. Spesifik olarak, hesaplar max(x, x * alpha) .

    beyanname

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

  • İade Selu aktivasyon fonksiyonu uygulayarak bir tensör, yani scale * alpha * (exp(x) - 1) eğer x < 0 ve scale * x aksi.

    Not

    Bu, varyans ölçekleme katmanı başlatıcılarıyla birlikte kullanılmak üzere tasarlanmıştır. Bakınız Kendinden Normalizing Sinir Ağları daha fazla bilgi için.

    beyanname

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

  • İade homoseksüel aktivasyon fonksiyonu, yani uygulayarak bir tensör x * sigmoid(x) .

    Kaynak: (. Ramachandran vd 2017) “Aktivasyon Fonksiyonlar aranıyor” https://arxiv.org/abs/1710.05941

    beyanname

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

  • İade sabit sigmoid aktivasyon fonksiyonu, yani uygulayarak bir tensör Relu6(x+3)/6 .

    Kaynak: “MobileNetV3 aranıyor” (. Howard ve arkadaşları 2019) https://arxiv.org/abs/1905.02244

    beyanname

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

  • İade, yani sert homoseksüel aktivasyon fonksiyonu uygulayarak bir tensör x * Relu6(x+3)/6 .

    Kaynak: “MobileNetV3 aranıyor” (. Howard ve arkadaşları 2019) https://arxiv.org/abs/1905.02244

    beyanname

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

  • İade miş aktivasyon fonksiyonu, yani uygulayarak bir tensör x * tanh(softplus(x)) .

    Kaynak: “Mish: A Self Regülarize- Olmayan Monotonik Sinir Aktivasyon Fonksiyonu” https://arxiv.org/abs/1908.08681

    beyanname

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

  • Birinci tensörün gücünü ikinci tensöre döndürür.

    beyanname

    @differentiable
public func pow<T>(_ lhs: Tensor<T>, _ rhs: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • Skaleri yayınlayarak skalerin gücünü tensöre döndürür.

    beyanname

    @differentiable(wrt: rhs)
public func pow<T>(_ lhs: T, _ rhs: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint

  • Skaleri yayınlayarak tensörün gücünü skalere döndürür.

    beyanname

    @differentiable(wrt: lhs)
public func pow<T>(_ lhs: Tensor<T>, _ rhs: T) -> Tensor<T> where T : TensorFlowFloatingPoint

  • Skaleri yayınlayarak tensörün gücünü skalere döndürür.

    beyanname

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

  • Öğeye göre döndürür n tensörün inci kökü.

    beyanname

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

  • İade arasındaki karesi alınmış farkı x ve y .

    beyanname

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

    Geri dönüş değeri

    (x - y) ^ 2 .

  • Öğe bazında maksimum iki tensörü döndürür.

    Not

    max destekler yayın.

    beyanname

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

  • Skaleri yayınlayarak skaler ve tensörün eleman bazında maksimumunu döndürür.

    beyanname

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

  • Skaleri yayınlayarak skaler ve tensörün eleman bazında maksimumunu döndürür.

    beyanname

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

  • İki tensörün öğe bazında minimumunu döndürür.

    Not

    min yayın destekler.

    beyanname

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

  • Skaleri yayınlayarak skaler ve tensörün eleman bazında minimumunu döndürür.

    beyanname

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

  • Skaleri yayınlayarak skaler ve tensörün eleman bazında minimumunu döndürür.

    beyanname

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

  • İade arasında kosinüs benzerliği x ve y .

    beyanname

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

  • İade arasındaki kosinüs mesafe x ve y . Kosinüs mesafesi olarak tanımlanır 1 - cosineSimilarity(x, y) .

    beyanname

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

  • Başka bir tensör ile matris çarpımı gerçekleştirir ve sonucu üretir.

    beyanname

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

  • Belirtilen giriş, filtre, adım ve dolgu ile 1 boyutlu bir evrişim döndürür.

    ön koşul

    input dereceye sahip olmalıdır 3 .

    ön koşul

    filter sıralaması 3 olması gerekir.

    beyanname

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

    parametreler

    input

    Girdi.

    filter

    Evrişim filtresi.

    stride

    Kayar filtrenin adımı.

    padding

    Operasyon için dolgu.

    dilation

    Genişletme faktörü.

  • Belirtilen giriş, filtre, adımlar ve dolgu ile 2 boyutlu bir evrişim döndürür.

    ön koşul

    input dereceye sahip olmalıdır 4 .

    ön koşul

    filter sıralaması 4 olması gerekir.

    beyanname

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

    parametreler

    input

    Girdi.

    filter

    Evrişim filtresi.

    strides

    Girişin her boyutu için kayan filtrenin adımları.

    padding

    Operasyon için dolgu

    dilations

    Girişin her boyutu için genişleme faktörü.

  • Belirtilen giriş, filtre, adımlar ve dolgu ile 2B transpoze edilmiş bir evrişim döndürür.

    ön koşul

    input dereceye sahip olmalıdır 4 .

    ön koşul

    filter sıralaması 4 olması gerekir.

    beyanname

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

    parametreler

    input

    Girdi.

    shape

    Geri evrişim işleminin çıkış şekli.

    filter

    Evrişim filtresi.

    strides

    Girişin her boyutu için kayan filtrenin adımları.

    padding

    Operasyon için dolgu

    dilations

    Girişin her boyutu için genişleme faktörü.

  • Belirtilen giriş, filtre, adımlar, dolgu ve genişlemelerle 3 boyutlu bir evrişim döndürür.

    ön koşul

    input dereceye sahip olmalıdır 5 .

    ön koşul

    filter sıralaması 5 olması gerekir.

    beyanname

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

    parametreler

    input

    Girdi.

    filter

    Evrişim filtresi.

    strides

    Girişin her boyutu için kayan filtrenin adımları.

    padding

    Operasyon için dolgu.

    dilations

    Girişin her boyutu için genişleme faktörü.

  • Belirtilen giriş, filtre, adımlar ve dolgu ile 2B derinlikte evrişim döndürür.

    ön koşul

    input sıralaması 4 olması gerekir.

    ön koşul

    filter sıralaması 4 olması gerekir.

    beyanname

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

    parametreler

    input

    Girdi.

    filter

    Derinlemesine evrişim filtresi.

    strides

    Girişin her boyutu için kayan filtrenin adımları.

    padding

    Operasyon için dolgu.

  • Belirtilen filtre boyutları, adımları ve dolgusu ile 2 boyutlu bir maksimum havuzlama döndürür.

    beyanname

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

    parametreler

    input

    Girdi.

    filterSize

    Havuzlama çekirdeğinin boyutları.

    strides

    Girişin her boyutu için kayan filtrenin adımları.

    padding

    Operasyon için dolgu.

  • Belirtilen filtre boyutları, adımları ve dolgusu ile 3 boyutlu bir maksimum havuzlama döndürür.

    beyanname

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

    parametreler

    input

    Girdi.

    filterSize

    Havuzlama çekirdeğinin boyutları.

    strides

    Girişin her boyutu için kayan filtrenin adımları.

    padding

    Operasyon için dolgu.

  • Belirtilen filtre boyutları, adımlar ve dolgu ile 2 boyutlu bir ortalama havuzlama döndürür.

    beyanname

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

    parametreler

    input

    Girdi.

    filterSize

    Havuzlama çekirdeğinin boyutları.

    strides

    Girişin her boyutu için kayan filtrenin adımları.

    padding

    Operasyon için dolgu.

  • Belirtilen filtre boyutları, adımlar ve dolgu ile 3 boyutlu bir ortalama havuzlama döndürür.

    beyanname

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

    parametreler

    input

    Girdi.

    filterSize

    Havuzlama çekirdeğinin boyutları.

    strides

    Girişin her boyutu için kayan filtrenin adımları.

    padding

    Operasyon için dolgu.

  • Belirtilen havuzlama oranlarıyla 2 boyutlu kesirli bir maksimum havuzlama döndürür.

    Not: fractionalMaxPool bir XLA uygulaması olmaması ve dolayısıyla performans etkileri olabilir.

    beyanname

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

    parametreler

    input

    Bir Tensör. Şekil 4-D [batch, height, width, channels] .

    poolingRatio

    Bir listesi Doubles . Her boyut için oranı havuzu oluşturma input , şu anda sadece satır ve sütun boyutu destekler ve> = 1.0 olması gerekir.

    pseudoRandom

    İsteğe bağlı Bool . Varsayılan false . Ayarlandığında true , rasgele bir şekilde, aksi takdirde, bir yalancı rasgele bir şekilde havuzu dizisini oluşturur.

    overlapping

    İsteğe bağlı Bool . Varsayılan false . Ayarlandığında true havuzu, bunun anlamı, bitişik havuzu hücrelerinin sınır değerler her iki hücre tarafından kullanılır.

    deterministic

    İsteğe Bağlı Bool . Grubu için zaman true sabit bir havuzlama bölgesi hesaplama grafikte bir fractionalMaxPool2D düğümü ilerlerken kullanılacaktır.

    seed

    İsteğe bağlı Int64 . Varsayılan 0 . Sıfırdan farklı olarak ayarlanırsa, rasgele sayı üreteci verilen tohum tarafından tohumlanır.

    seed2

    İsteğe bağlı Int64 . Varsayılan 0 . Tohum çarpışmasını önlemek için ikinci bir tohum.

  • Bir kopyasını verir input derinliği boyuttan değerleri yükseklik ve genişlik boyutlarına uzamsal bloklarda taşınır.

    Örneğin, bir şeklin girdi verildi [1, 2, 2, 1] , data_format = “NHWC” ve block_size = 2:

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

    Bu işlem çıktısı şeklinde bir tensör [1, 1, 1, 4] :

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

    Burada, giriş 1 bir dizi var ve her parti elemanı şekle sahiptir [2, 2, 1] , ilgili çıkış tek bir elemana sahip olacak (yani genişlik ve yükseklik hem 1) ve 4 kanallı bir derinliğe sahip olacak (1 * blok_boyutu * blok_boyutu). Çıkış elemanı şekil [1, 1, 4] .

    Burada şekil daha büyük derinliğe sahip olan bir giriş tensörü için [1, 2, 2, 3] , örneğin,

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

    Bu işlem, 2 block_size için, şekil aşağıdaki tensörünün döndürür [1, 1, 1, 12]

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

    Benzer şekilde, şekil aşağıdaki girişi için [1 4 4 1] ve 2 bir blok boyutu:

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

    Operatör şeklinin aşağıdaki tensörünün döndürür [1 2 2 4] :

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

    ön koşul

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

    ön koşul

    Özelliklerin sayısı karesi bölünebilir olmalıdır b .

    beyanname

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

  • Bir kopyasını verir input yükseklik ve genişlik boyutlarında gelen değerler derinlik boyutu taşınır.

    Örneğin, bir şeklin girdi verildi [1, 2, 2, 1] , data_format = “NHWC” ve block_size = 2:

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

    Bu işlem çıktısı şeklinde bir tensör [1, 1, 1, 4] :

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

    Burada, giriş 1 bir dizi var ve her parti elemanı şekle sahiptir [2, 2, 1] , ilgili çıkış tek bir elemana sahip olacak (yani genişlik ve yükseklik hem 1) ve 4 kanallı bir derinliğe sahip olacak (1 * blok_boyutu * blok_boyutu). Çıkış elemanı şekil [1, 1, 4] .

    Burada şekil daha büyük derinliğe sahip olan bir giriş tensörü için [1, 2, 2, 3] , örneğin,

    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 .

    beyanname

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

    beyanname

    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.

    beyanname

    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”

    beyanname

    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.

    beyanname

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

  • Concatenates two values.

    beyanname

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

  • Adds two values and produces their sum.

    beyanname

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

  • Averages two values.

    beyanname

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

  • Multiplies two values.

    beyanname

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

  • Stack two values.

    beyanname

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

  • beyanname

    public func PrintX10Metrics()

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

    beyanname

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

  • beyanname

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

  • Maps a function over n threads.

    beyanname

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