İşlevler

Aşağıdaki işlevler genel olarak mevcuttur.

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

    beyan

    @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 beklenen çıktılar.

    expected

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

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

    beyan

    @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 beklenen çıktılar.

    expected

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

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

    beyan

    @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 beklenen çıktılar.

    expected

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

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

    beyan

    @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 beklenen çıktılar.

    expected

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

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

    beyan

    @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 beklenen çıktılar.

    expected

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

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

    beyan

    @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 beklenen çıktılar.

    expected

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

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

    beyan

    @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 beklenen çıktılar.

    expected

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

  • Beklentiler ve tahminler arasındaki Kullback-Leibler farklılığını (KL farklılığını) döndürür. p ve q olmak üzere iki dağılım göz önüne alındığında, KL diverjansı p * log(p / q) hesaplar.

    beyan

    @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 beklenen çıktılar.

    expected

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

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

    beyan

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

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

    beyan

    @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 tam sayı değerleri.

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

    beyan

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

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

    beyan

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

    Parametreler

    context

    Kapanış çağrılmadan önce ayarlanacak ve kapanış geri döndükten sonra geri yüklenecek bir bağlam.

    body

    Sıfır kapanış. Kapatmanın bir dönüş değeri varsa, bu değer aynı zamanda withContext(_:_:) işlevinin dönüş değeri olarak da kullanılır.

    Geri dönüş değeri

    Varsa body kapanışının dönüş değeri.

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

    beyan

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

    Parametreler

    learningPhase

    Kapanış çağrılmadan önce ayarlanacak ve kapanış geri döndükten sonra geri yüklenecek bir öğrenme aşaması.

    body

    Sıfır kapanış. Kapatmanın bir dönüş değeri varsa, bu değer aynı zamanda withLearningPhase(_:_:) işlevinin dönüş değeri olarak da kullanılır.

    Geri dönüş değeri

    Varsa body kapanışının dönüş değeri.

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

    beyan

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

    Parametreler

    randomSeed

    Kapanıştan önce ayarlanacak rastgele bir tohum çağrılır ve kapanış geri döndükten sonra geri yüklenir.

    body

    Sıfır kapanış. Kapatmanın bir dönüş değeri varsa, bu değer aynı zamanda withRandomSeedForTensorFlow(_:_:) işlevinin dönüş değeri olarak da kullanılır.

    Geri dönüş değeri

    Varsa body kapanışının dönüş değeri.

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

    beyan

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

    Parametreler

    randomNumberGenerator

    Kapanış çağrılmadan önce ayarlanacak ve kapanış geri geldikten sonra geri yüklenecek bir rastgele sayı üreteci.

    body

    Sıfır kapanış. Kapatmanın bir dönüş değeri varsa, bu değer aynı zamanda withRandomNumberGeneratorForTensorFlow(_:_:) işlevinin dönüş değeri olarak da kullanılır.

    Geri dönüş değeri

    Varsa body kapanışının dönüş değeri.

  • beyan

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

  • LazyTensorBarrier, tüm canlı tensörlerin (varsa cihazda) planlanmasını ve çalışmasını sağlar. Bekleme doğru olarak ayarlanırsa bu çağrı, hesaplama tamamlanana kadar engellenir.

    beyan

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

  • beyan

    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

  • beyan

    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

  • beyan

    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

  • beyan

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

  • beyan

    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

  • beyan

    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

  • beyan

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

  • beyan

    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

  • beyan

    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

  • beyan

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

  • beyan

    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

  • beyan

    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ştırmada "kontrol noktası oluşturma" olarak bilinen, bir işlevin geri çekilmesinde yeniden hesaplanmasını sağlayın.

    beyan

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

  • Vektör-Jacobian çarpım fonksiyonundan türevlenebilir bir fonksiyon oluşturun.

    beyan

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

  • Vektör-Jacobian çarpım fonksiyonundan türevlenebilir bir fonksiyon oluşturun.

    beyan

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

  • Bir kimlik işlevi gibi x döndürür. x türevinin alındığı bir bağlamda kullanıldığında bu fonksiyon x herhangi bir türev üretmez.

    beyan

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

  • Verilen kapatma body x öğesine uygular. x türevinin alındığı bir bağlamda kullanıldığında bu fonksiyon x herhangi bir türev üretmez.

    beyan

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

  • TensorFlow işlemlerinin belirli bir cihaz türünde çalışmasını sağlayan bir kapatma gerçekleştirir.

    beyan

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

    Parametreler

    kind

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

    index

    İşlemlerin yürütüleceği cihaz.

    body

    TensorFlow işlemlerinin belirtilen türde bir cihaz üzerinde yürütüleceği bir kapatma.

  • TensorFlow işlemlerinin belirli bir ada sahip bir cihazda çalışmasını sağlayarak bir kapatma gerçekleştirir.

    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 gösterim
    • “/job:localhost/replica:0/task:0/device:GPU:1”: Makinenizin TensorFlow tarafından görülebilen ikinci GPU'sunun tam adı.

    beyan

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

    Parametreler

    name

    Cihaz adı.

    body

    TensorFlow işlemlerinin belirtilen türde bir cihaz üzerinde yürütüleceği bir kapatma.

  • TensorFlow'un TensorFlow işlemlerini herhangi bir cihaza yerleştirmesine olanak tanıyan bir kapatma gerçekleştirir. Bu, varsayılan yerleştirme davranışını geri yüklemelidir.

    beyan

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

    Parametreler

    body

    TensorFlow işlemlerinin belirtilen türde bir cihaz üzerinde yürütüleceği bir kapatma.

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

    Önkoşul

    Görsellerin sıralaması 3 veya 4 olmalıdır.

    Önkoşul

    Boyut pozitif olmalıdır.

    beyan

    @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-B Şekil Tensor [batch, height, width, channels] veya 3-B şekil Tensor [height, width, channels] .

    size

    Resimlerin yeni boyutu.

    method

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

    antialias

    true , bir görüntüyü altörneklerken kenar yumuşatma filtresi kullanın.

  • Alan enterpolasyonunu kullanarak görüntüleri boyuta göre yeniden boyutlandırın.

    Önkoşul

    Görsellerin sıralaması 3 veya 4 olmalıdır.

    Önkoşul

    Boyut pozitif olmalıdır.

    beyan

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

    Parametreler

    images

    4-B Şekil Tensor [batch, height, width, channels] veya 3-B şekil Tensor [height, width, channels] .

    size

    Resimlerin yeni boyutu.

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

    Önkoşul

    input 4 sıraya sahip olması gerekir.

    Önkoşul

    filter sıralaması 3 olmalıdır.

    beyan

    @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şleme 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 2 boyutlu bir erozyon döndürür.

    Önkoşul

    input 4 sıraya sahip olması gerekir.

    Önkoşul

    filter sıralaması 3 olmalıdır.

    beyan

    @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ırlarla başlatarak tensör oluşturan bir işlev döndürür.

    beyan

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

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

    beyan

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

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

    beyan

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

  • Belirtilen şekil için Glorot (Xavier) tekdüze başlatma gerçekleştirerek tensör oluşturan bir işlev döndürür; varsayılan rastgele sayı üreteci tarafından oluşturulan -limit ve limit arasındaki tekdüze bir dağılımdan skaler değerleri rastgele örneklendirir; burada limit sqrt(6 / (fanIn + fanOut)) ve fanIn / fanOut , varsa alıcı alanla çarpılan giriş ve çıkış özelliklerinin sayısını temsil eder.

    beyan

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

  • Belirtilen şekil için Glorot (Xavier) normal başlatma işlemini gerçekleştirerek, standart sapma sqrt(2 / (fanIn + fanOut)) ile 0 merkezli kesik normal dağılımdan skaler değerleri rastgele örnekleyerek bir tensör oluşturan bir işlev döndürür; burada fanIn / fanOut varsa, alıcı alan boyutuyla çarpılan giriş ve çıkış özelliklerinin sayısını temsil eder.

    beyan

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

  • Belirtilen şekil için He (Kaiming) tekdüze başlatma işlemini gerçekleştirerek tensör oluşturan bir işlev döndürür; varsayılan rastgele sayı üreteci tarafından oluşturulan -limit ve limit arasındaki tekdüze dağılımdan skaler değerleri rastgele örneklendirir; limit sqrt(6 / fanIn) ve fanIn , varsa alıcı alanla çarpılan giriş özelliklerinin sayısını temsil eder.

    beyan

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

  • Belirtilen şekil için He (Kaiming) normal başlatma gerçekleştirerek bir tensör oluşturan, standart sapma sqrt(2 / fanIn) ile 0 merkezli kesik normal dağılımdan skaler değerleri rastgele örnekleyen, burada fanIn giriş özelliklerinin sayısını temsil eden bir fonksiyon döndürür varsa alıcı alan boyutuyla çarpılır.

    beyan

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

  • Belirtilen şekil için LeCun tekdüze başlatma işlemini gerçekleştirerek bir tensör oluşturan, varsayılan rastgele sayı üreteci tarafından oluşturulan -limit ve limit arasındaki tekdüze bir dağılımdan skaler değerleri rastgele örnekleyen (limit sqrt(3 / fanIn) olan) bir işlev döndürür ve fanIn varsa alıcı alanla çarpılan giriş özelliklerinin sayısını temsil eder.

    beyan

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

  • Belirtilen şekil için LeCun normal başlatma işlemini gerçekleştirerek bir tensör oluşturan, standart sapma sqrt(1 / fanIn) ile 0 merkezli kesik normal dağılımdan skaler değerleri rastgele örnekleyen bir işlev döndürür; burada fanIn , giriş özelliklerinin sayısı ile çarpılır. varsa alıcı alan boyutu.

    beyan

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

  • Tüm değerlerini kesik bir Normal dağılımdan rastgele başlatarak bir tensör oluşturan bir işlev döndürür. Oluşturulan değerler, ortalama mean ve standart sapma standardDeviation ile bir Normal dağılım izler; ancak büyüklüğü ortalamadan iki standart sapmadan fazla olan değerler düşürülür ve yeniden örneklenir.

    beyan

    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

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

  • beyan

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

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

    beyan

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

    Parametreler

    rowCount

    Her toplu iş matrisindeki satır sayısı.

    columnCount

    Her toplu iş 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 bir en içteki matrisin ana köşegeni boyunca toplamıdır.

    Giriş [..., M, N] şeklinde bir tensördür. Çıktı [...] şeklinde bir tensördür.

    Önkoşul

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

    beyan

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

    Parametreler

    matrix

    [..., M, N] şeklinde bir tensör.

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

    Giriş, en içteki 2 boyutu kare matrisler oluşturan [..., M, M] şeklinde bir tensördür.

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

    Çıkış, tüm giriş alt matrisleri [..., :, :] için Cholesky ayrıştırmalarını içeren girişle aynı şekle sahip bir tensördür.

    beyan

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

    Parametreler

    input

    [..., M, M] şeklinde bir tensör.

  • Ax = b ile temsil edilen doğrusal denklemler sisteminin x çözümünü döndürür.

    Önkoşul

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

    Önkoşul

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

    beyan

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

    Parametreler

    matrix

    Ax = b A temsil eden giriş üçgen katsayı matrisi.

    rhs

    Ax = b b temsil eden sağ taraftaki değerler.

    lower

    matrix alt üçgen ( true ) veya üst üçgen ( false ) olup olmadığı. Varsayılan değer true .

    adjoint

    true , matrix yerine matrix ekiyle çözün. Varsayılan değer false .

    Geri dönüş değeri

    Ax = b ile temsil edilen doğrusal denklem sisteminin çözümü x . x b ile aynı şekle sahiptir.

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

    beyan

    @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 beklenen çıktılar.

    expected

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

    reduction

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

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

    beyan

    @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 beklenen çıktılar.

    expected

    Doğru çıktıya karşılık gelen beklenen değerler, yani 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))

    beyan

    @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 beklenen çıktılar.

    expected

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

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

    beyan

    @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 beklenen çıktılar.

    expected

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

  • predicted ve expected loss = square(log(expected) - log(predicted))

    Not

    Negatif gerçekler için log(_:) tanımsız olduğundan, tanımsız logaritmik davranışı önlemek için negatif tensör girişleri 0 sabitlenecektir.

    beyan

    @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 beklenen çıktılar.

    expected

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

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

    beyan

    @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 beklenen çıktılar.

    expected

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

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

    beyan

    @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 beklenen çıktılar.

    expected

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

    reduction

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

  • predicted ve expected arasındaki kare menteşe kaybını hesaplar. loss = reduction(square(max(0, 1 - predicted * expected))) expected değerlerin -1 veya 1 olması bekleniyor.

    beyan

    @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 beklenen çıktılar.

    expected

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

    reduction

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

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

    beyan

    @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 beklenen çıktılar.

    expected

    Doğru çıktıya karşılık gelen beklenen değerler, yani 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) , burada x predicted - expected hatadır

    beyan

    @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 beklenen çıktılar.

    expected

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

    reduction

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

  • Tahmin edilen ve beklenen arasındaki Poisson kaybını hesaplar. Poisson kaybı predicted - expected * log(predicted) Tensor öğelerinin ortalamasıdır.

    beyan

    @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 beklenen çıktılar.

    expected

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

    reduction

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

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

    beyan

    @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 beklenen çıktılar.

    expected

    Doğru çıktıya karşılık gelen beklenen değerler, yani 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ı fonksiyonunu kullanın. Etiketlerin tam sayı olarak sağlanmasını bekliyoruz. logits için özellik başına # classes kayan nokta değeri ve expected için özellik başına tek bir kayan nokta değeri olmalıdır.

    beyan

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

    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ı fonksiyonunu kullanın. Etiketlerin one_hot temsilinde sağlanmasını bekliyoruz. Özellik başına # classes kayan nokta değeri olmalıdır.

    beyan

    @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 örnekte tahmin başına tek bir kayan nokta değeri olmalıdır.

    beyan

    @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 tam sayı değerleri.

    reduction

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

  • predicted ve expected arasındaki Huber kaybını hesaplar.

    Hatadaki her x değeri için error = expected - predicted :

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

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

    • Kaynak: Vikipedi makalesi .

    beyan

    @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 beklenen çıktılar.

    expected

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

    delta

    Huber kayıp fonksiyonunun ikinci dereceden doğrusala değiştiği noktayı temsil eden kayan nokta skaleri.

    reduction

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

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

    beyan

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

  • Belirtilen tensör öğesi bazında doğal logaritmasını döndürür.

    beyan

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

  • Belirtilen tensör öğesi bazında iki tabanlı logaritmayı döndürür.

    beyan

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

  • Belirtilen tensör öğesi bazında on tabanlı logaritmayı döndürür.

    beyan

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

  • 1 + x öğe bazında logaritmasını döndürür.

    beyan

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

  • Sayısal olarak kararlı bir yaklaşım kullanarak log(1 - exp(x)) değerini döndürür.

    Not

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

    beyan

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

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

    beyan

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

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

    beyan

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

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

    beyan

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

  • Belirtilen tensör öğesi bazında hiperbolik sinüsü döndürür.

    beyan

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

  • Belirtilen tensör öğesi bazında hiperbolik kosinüsünü döndürür.

    beyan

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

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

    beyan

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

  • Belirtilen tensör öğesi bazında ters kosinüsünü döndürür.

    beyan

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

  • Belirtilen tensör öğesi bazında ters sinüsünü döndürür.

    beyan

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

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

    beyan

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

  • Belirtilen tensör öğesi bazında ters hiperbolik kosinüsünü döndürür.

    beyan

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

  • Belirtilen tensör öğesi bazında ters hiperbolik sinüsü döndürür.

    beyan

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

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

    beyan

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

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

    beyan

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

  • Belirtilen tensör öğesi bazında ters karekökünü döndürür.

    beyan

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

  • Belirtilen tensör öğesi bazında üstel değerini döndürür.

    beyan

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

  • Belirtilen tensör öğesi bazında ikinin kuvvetine yükseltilmiş değeri döndürür.

    beyan

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

  • Belirtilen tensör öğesi bazında on kuvvetine yükseltilmiş on değeri döndürür.

    beyan

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

  • Öğe bazında x - 1 üstel değerini döndürür.

    beyan

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

  • Belirtilen tensörün değerlerini öğe bazında en yakın tam sayıya yuvarlanmış olarak döndürür.

    beyan

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

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

    beyan

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

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

    beyan

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

  • Belirtilen tensör öğesi bazında işaretin göstergesini döndürür. Özellikle x < 0 ise y = sign(x) = -1 hesaplar; 0 eğer x == 0 ise; 1 eğer x > 0 ise.

    beyan

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

  • Belirtilen tensör öğesi bazında sigmoid'i döndürür. Özellikle, 1 / (1 + exp(-x)) değerini hesaplar.

    beyan

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

  • Belirtilen tensör öğesi bazında log-sigmoid'i döndürür. Özellikle, log(1 / (1 + exp(-x))) . Sayısal kararlılık için -softplus(-x) kullanıyoruz.

    beyan

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

  • Belirtilen tensör öğesi bazında softplus'ı döndürür. Özellikle log(exp(features) + 1) değerini hesaplar.

    beyan

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

  • Belirtilen tensör öğesi bazında yazılım işaretini döndürür. Özellikle, features/ (abs(features) + 1) hesaplar.

    beyan

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

  • Son eksen boyunca belirtilen tensörün softmax'ını döndürür. Özellikle, exp(x) / exp(x).sum(alongAxes: -1) hesaplar.

    beyan

    @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. Özellikle, exp(x) / exp(x).sum(alongAxes: axis) hesaplar.

    beyan

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

  • Belirtilen tensör elemanının log-softmax değerini döndürür.

    beyan

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

  • Üstel doğrusal birim uygulayarak bir tensör döndürür. Spesifik olarak, < 0 ise exp(x) - 1 , aksi halde x hesaplar. Üstel Doğrusal Birimler (ELU'lar) ile Hızlı ve Doğru Derin Ağ Öğrenmeyi Görün

    beyan

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

  • Belirtilen tensör öğesi bazında Gauss Hatası Doğrusal Birimi (GELU) etkinleştirmelerini döndürür.

    Spesifik olarak gelu , xP(X <= x) e yaklaşır; burada P(X <= x) , Standart Gauss kümülatif dağılımıdır: x * [0,5 * (1 + tanh[√(2/π) * (x + 0,044715 * x^3)])].

    Bkz. Gauss Hatası Doğrusal Birimleri .

    beyan

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

  • ReLU etkinleştirme işlevini belirtilen tensör öğesi bazında uygulayarak bir tensör döndürür. Özellikle max(0, x) hesaplar.

    beyan

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

  • ReLU6 etkinleştirme fonksiyonunu uygulayarak bir tensör döndürür, yani min(max(0, x), 6) .

    beyan

    @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 bazında uygulayarak bir tensör döndürür. Özellikle max(x, x * alpha) hesaplar.

    beyan

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

  • SeLU aktivasyon fonksiyonunu uygulayarak bir tensör döndürür; yani x < 0 ise scale * alpha * (exp(x) - 1) ve aksi halde scale * x .

    Not

    Bu, varyans ölçeklendirme katmanı başlatıcılarıyla birlikte kullanılmak üzere tasarlanmıştır. Daha fazla bilgi için lütfen Kendi Kendini Normalleştiren Sinir Ağlarına bakın.

    beyan

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

  • Swish etkinleştirme fonksiyonunu x * sigmoid(x) uygulayarak bir tensör döndürür.

    Kaynak: “Etkinleştirme İşlevlerini Arama” (Ramachandran ve diğerleri 2017) https://arxiv.org/abs/1710.05941

    beyan

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

  • Relu6(x+3)/6 gibi sert sigmoid etkinleştirme işlevini uygulayarak bir tensör döndürür.

    Kaynak: “MobileNetV3 Aranıyor” (Howard ve diğerleri 2019) https://arxiv.org/abs/1905.02244

    beyan

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

  • Sert swish aktivasyon fonksiyonunu uygulayarak bir tensör döndürür, yani x * Relu6(x+3)/6 .

    Kaynak: “MobileNetV3 Aranıyor” (Howard ve diğerleri 2019) https://arxiv.org/abs/1905.02244

    beyan

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

  • Mish etkinleştirme fonksiyonunu uygulayarak bir tensör döndürür, yani x * tanh(softplus(x)) .

    Kaynak: “Mish: Kendi Kendini Düzenleyen Monotonik Olmayan Nöral Aktivasyon Fonksiyonu” https://arxiv.org/abs/1908.08681

    beyan

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

    beyan

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

    beyan

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

    beyan

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

    beyan

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

  • Tensörün öğe bazında n kökünü döndürür.

    beyan

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

  • x ve y arasındaki kare farkını döndürür.

    beyan

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

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

    Not

    max yayını destekler.

    beyan

    @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 öğe bazında maksimumunu döndürür.

    beyan

    @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 öğe bazında maksimumunu döndürür.

    beyan

    @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 minimum değerini döndürür.

    Not

    min yayını destekler.

    beyan

    @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 öğe bazında minimumunu döndürür.

    beyan

    @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 öğe bazında minimumunu döndürür.

    beyan

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

  • x ve y arasındaki kosinüs benzerliğini döndürür.

    beyan

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

  • x ile y arasındaki kosinüs mesafesini döndürür. Kosinüs mesafesi 1 - cosineSimilarity(x, y) olarak tanımlanır.

    beyan

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

  • Başka bir tensörle matris çarpımını yapar ve sonucu üretir.

    beyan

    @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şimi döndürür.

    Önkoşul

    input rütbe 3 olması gerekir.

    Önkoşul

    filter sıralaması 3 olmalıdır.

    beyan

    @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şleme faktörü.

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

    Önkoşul

    input 4 sıraya sahip olması gerekir.

    Önkoşul

    filter sıralaması 4 olmalıdır.

    beyan

    @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 2 boyutlu transpoze edilmiş bir evrişimi döndürür.

    Önkoşul

    input 4 sıraya sahip olması gerekir.

    Önkoşul

    filter sıralaması 4 olmalıdır.

    beyan

    @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

    Dekonvolüsyon işleminin çıktı ş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şletmelerle 3 boyutlu bir evrişimi döndürür.

    Önkoşul

    input 5 sıraya sahip olması gerekir.

    Önkoşul

    filter sıralaması 5 olmalıdır.

    beyan

    @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 2 boyutlu derinlemesine evrişimi döndürür.

    Önkoşul

    input 4. sıraya sahip olması gerekir.

    Önkoşul

    filter sıralaması 4 olmalıdır.

    beyan

    @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 dolguyla birlikte 2 boyutlu maksimum havuzlamayı döndürür.

    beyan

    @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 dolguyla birlikte 3 boyutlu maksimum havuzlamayı döndürür.

    beyan

    @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 dolguyla birlikte 2 boyutlu ortalama havuzlamayı döndürür.

    beyan

    @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 dolgularla birlikte 3 boyutlu ortalama havuzlamayı döndürür.

    beyan

    @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 maksimum havuzlamayı döndürür.

    Not: fractionalMaxPool bir XLA uygulaması yoktur ve dolayısıyla performansla ilgili etkileri olabilir.

    beyan

    @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. Şekilli 4-D [batch, height, width, channels] .

    poolingRatio

    Doubles listesi. input her boyutu için havuzlama oranı, şu anda yalnızca satır ve sütun boyutunu desteklemektedir ve >= 1,0 olmalıdır.

    pseudoRandom

    İsteğe bağlı bir Bool . Varsayılan olarak false . true olarak ayarlandığında, havuzlama sırasını sözde rastgele bir biçimde, aksi takdirde rastgele bir biçimde oluşturur.

    overlapping

    İsteğe bağlı bir Bool . Varsayılan olarak false . true olarak ayarlandığında, havuzlama sırasında bitişik havuzlama hücrelerinin sınırındaki değerlerin her iki hücre tarafından da kullanıldığı anlamına gelir.

    deterministic

    İsteğe Bağlı Bir Bool . true olarak ayarlandığında, hesaplama grafiğinde kesirliMaxPool2D düğümü üzerinde yineleme yapılırken sabit bir havuzlama bölgesi kullanılacaktır.

    seed

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

    seed2

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

  • Derinlik boyutundan gelen değerlerin uzamsal bloklar halinde yükseklik ve genişlik boyutlarına taşındığı input bir kopyasını döndürür.

    Örneğin, [1, 2, 2, 1] şeklinde bir giriş verildiğinde, data_format = “NHWC” ve blok_size = 2:

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

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

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

    Burada, giriş 1'lik bir partiye sahiptir ve her parti elemanı [2, 2, 1] şeklindedir, karşılık gelen çıktı tek bir elemana sahip olacaktır (yani genişlik ve yüksekliğin her ikisi de 1'dir) ve 4 kanal derinliğine sahip olacaktır (1) * blok_boyutu * blok_boyutu). Çıkış elemanı şekli [1, 1, 4] şeklindedir.

    Daha büyük derinliğe sahip bir giriş tensörü için, burada [1, 2, 2, 3] şeklindedir, örneğin

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

    Bu işlem, blok_boyutu 2 için, aşağıdaki [1, 1, 1, 12] şeklindeki tensörü döndürecektir.

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

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

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

    operatör aşağıdaki şekil tensörünü döndürecektir [1 2 2 4] :

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

    Önkoşul

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

    Önkoşul

    Özellik sayısı b karesine bölünebilir olmalıdır.

    beyan

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

  • Yükseklik ve genişlik boyutlarından değerlerin derinlik boyutuna taşındığı input bir kopyasını döndürür.

    Örneğin, [1, 2, 2, 1] şeklinde bir giriş verildiğinde, data_format = “NHWC” ve blok_size = 2:

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

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

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

    Burada, giriş 1'lik bir partiye sahiptir ve her parti elemanı [2, 2, 1] şeklindedir, karşılık gelen çıktı tek bir elemana sahip olacaktır (yani genişlik ve yüksekliğin her ikisi de 1'dir) ve 4 kanal derinliğine sahip olacaktır (1) * blok_boyutu * blok_boyutu). Çıkış elemanı şekli [1, 1, 4] şeklindedir.

    Daha büyük derinliğe sahip bir giriş tensörü için, burada [1, 2, 2, 3] şeklindedir, örneğin

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

    Bu işlem, blok_boyutu 2 için, aşağıdaki [1, 1, 1, 12] şeklindeki tensörü döndürecektir.

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

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

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

    operatör aşağıdaki şekil tensörünü döndürecektir [1 2 2 4] :

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

    Önkoşul

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

    Önkoşul

    Girişin yüksekliği b bölünebilir olmalıdır.

    Önkoşul

    Girişin genişliği b bölünebilir olmalıdır.

    beyan

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

  • Lars için bir ağırlık başına optimizer oluşturur ( 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

  • SGD tabanlı bir ağırlık başına optimizer oluşturur.

    Beyanname

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

  • Ağırlık çürümesi ile Adam için ağırlık başına bir optimizer oluşturur.

    Referans: "Adam - Stokastik Optimizasyon İçin Bir Yöntem"

    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

  • Tensorflow için yeni bir rastgele tohum üretir.

    Beyanname

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

  • İki değeri birleştirir.

    Beyanname

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

  • İki değer ekler ve toplamlarını üretir.

    Beyanname

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

  • Ortalama iki değer.

    Beyanname

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

  • İki değeri çoğaltır.

    Beyanname

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

  • İki değeri istifleyin.

    Beyanname

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

  • Beyanname

    public func PrintX10Metrics()

  • Eğitim ve test istatistikleri listesinin bir dize özetini oluşturur.

    Beyanname

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

  • Beyanname

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

  • Bir işlevi n iş parçacıkları üzerinden haritalar.

    Beyanname

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