Fungsi

Fungsi-fungsi berikut tersedia secara global.

  • Mengembalikan kerugian L1 antara prediksi dan ekspektasi.

    Pernyataan

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

    Parameter

    predicted

    Output yang diprediksi dari jaringan saraf.

    expected

    Nilai yang diharapkan, yaitu target, yang sesuai dengan keluaran yang benar.

  • Mengembalikan kerugian L2 antara prediksi dan ekspektasi.

    Pernyataan

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

    Parameter

    predicted

    Output yang diprediksi dari jaringan saraf.

    expected

    Nilai yang diharapkan, yaitu target, yang sesuai dengan keluaran yang benar.

  • Mengembalikan kerugian engsel antara prediksi dan ekspektasi.

    Pernyataan

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

    Parameter

    predicted

    Output yang diprediksi dari jaringan saraf.

    expected

    Nilai yang diharapkan, yaitu target, yang sesuai dengan keluaran yang benar.

  • Mengembalikan kerugian engsel kuadrat antara prediksi dan ekspektasi.

    Pernyataan

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

    Parameter

    predicted

    Output yang diprediksi dari jaringan saraf.

    expected

    Nilai yang diharapkan, yaitu target, yang sesuai dengan keluaran yang benar.

  • Mengembalikan kerugian engsel kategoris antara prediksi dan ekspektasi.

    Pernyataan

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

    Parameter

    predicted

    Output yang diprediksi dari jaringan saraf.

    expected

    Nilai yang diharapkan, yaitu target, yang sesuai dengan keluaran yang benar.

  • Mengembalikan logaritma kosinus hiperbolik kesalahan antara prediksi dan ekspektasi.

    Pernyataan

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

    Parameter

    predicted

    Output yang diprediksi dari jaringan saraf.

    expected

    Nilai yang diharapkan, yaitu target, yang sesuai dengan keluaran yang benar.

  • Mengembalikan kerugian Poisson antara prediksi dan ekspektasi.

    Pernyataan

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

    Parameter

    predicted

    Output yang diprediksi dari jaringan saraf.

    expected

    Nilai yang diharapkan, yaitu target, yang sesuai dengan keluaran yang benar.

  • Mengembalikan divergensi Kullback-Leibler (divergensi KL) antara ekspektasi dan prediksi. Diberikan dua distribusi p dan q , divergensi KL menghitung p * log(p / q) .

    Pernyataan

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

    Parameter

    predicted

    Output yang diprediksi dari jaringan saraf.

    expected

    Nilai yang diharapkan, yaitu target, yang sesuai dengan keluaran yang benar.

  • Mengembalikan entropi silang softmax (entropi silang kategoris) antara logit dan label.

    Pernyataan

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

    Parameter

    logits

    Output yang dikodekan one-hot dari jaringan saraf.

    labels

    Indeks (diindeks nol) dari keluaran yang benar.

  • Mengembalikan entropi silang sigmoid (entropi silang biner) antara logit dan label.

    Pernyataan

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

    Parameter

    logits

    Output jaringan saraf yang tidak berskala.

    labels

    Nilai integer yang sesuai dengan output yang benar.

  • Mengembalikan tensor dengan bentuk dan skalar yang sama dengan tensor yang ditentukan.

    Pernyataan

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

  • Memanggil penutupan yang diberikan dalam konteks yang semuanya identik dengan konteks saat ini kecuali untuk fase pembelajaran tertentu.

    Pernyataan

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

    Parameter

    context

    Konteks yang akan ditetapkan sebelum penutupan dipanggil dan dipulihkan setelah penutupan kembali.

    body

    Penutupan nullary. Jika penutupan memiliki nilai kembalian, nilai tersebut juga digunakan sebagai nilai kembalian fungsi withContext(_:_:) .

    Nilai Pengembalian

    Nilai yang dikembalikan, jika ada, dari penutupan body .

  • Memanggil penutupan yang diberikan dalam konteks yang semuanya identik dengan konteks saat ini kecuali untuk fase pembelajaran tertentu.

    Pernyataan

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

    Parameter

    learningPhase

    Fase pembelajaran yang akan ditetapkan sebelum penutupan dipanggil dan dipulihkan setelah penutupan kembali.

    body

    Penutupan nullary. Jika penutupan memiliki nilai kembalian, nilai tersebut juga digunakan sebagai nilai kembalian fungsi withLearningPhase(_:_:) .

    Nilai Pengembalian

    Nilai yang dikembalikan, jika ada, dari penutupan body .

  • Memanggil penutupan yang diberikan dalam konteks yang memiliki segala sesuatu yang identik dengan konteks saat ini kecuali benih acak yang diberikan.

    Pernyataan

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

    Parameter

    randomSeed

    Benih acak yang akan disetel sebelum penutupan dipanggil dan dipulihkan setelah penutupan kembali.

    body

    Penutupan nullary. Jika penutupan memiliki nilai kembalian, nilai tersebut juga digunakan sebagai nilai kembalian fungsi withRandomSeedForTensorFlow(_:_:) .

    Nilai Pengembalian

    Nilai yang dikembalikan, jika ada, dari penutupan body .

  • Memanggil penutupan yang diberikan dalam konteks yang memiliki segala sesuatu yang identik dengan konteks saat ini kecuali untuk generator nomor acak yang diberikan.

    Pernyataan

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

    Parameter

    randomNumberGenerator

    Generator nomor acak yang akan disetel sebelum penutupan dipanggil dan dipulihkan setelah penutupan kembali.

    body

    Penutupan nullary. Jika penutupan memiliki nilai kembalian, nilai tersebut juga digunakan sebagai nilai kembalian fungsi withRandomNumberGeneratorForTensorFlow(_:_:) .

    Nilai Pengembalian

    Nilai yang dikembalikan, jika ada, dari penutupan body .

  • Pernyataan

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

  • LazyTensorBarrier memastikan semua tensor aktif (di perangkat jika disediakan) dijadwalkan dan berjalan. Jika wait disetel ke true, panggilan ini akan diblokir hingga komputasi selesai.

    Pernyataan

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

  • Pernyataan

    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

  • Pernyataan

    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

  • Pernyataan

    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

  • Pernyataan

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

  • Pernyataan

    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

  • Pernyataan

    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

  • Pernyataan

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

  • Pernyataan

    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

  • Pernyataan

    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

  • Pernyataan

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

  • Pernyataan

    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

  • Pernyataan

    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

  • Membuat suatu fungsi dihitung ulang kemundurannya, yang dikenal sebagai “pos pemeriksaan” dalam diferensiasi otomatis tradisional.

    Pernyataan

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

  • Buat fungsi terdiferensiasi dari fungsi produk vektor-Jacobian.

    Pernyataan

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

  • Buat fungsi terdiferensiasi dari fungsi produk vektor-Jacobian.

    Pernyataan

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

  • Mengembalikan x seperti fungsi identitas. Jika digunakan dalam konteks di mana x terdiferensiasi terhadap, fungsi ini tidak akan menghasilkan turunan apa pun di x .

    Pernyataan

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

  • Menerapkan body penutupan yang diberikan ke x . Jika digunakan dalam konteks di mana x terdiferensiasi terhadap, fungsi ini tidak akan menghasilkan turunan apa pun di x .

    Pernyataan

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

  • Menjalankan penutupan, membuat operasi TensorFlow berjalan pada jenis perangkat tertentu.

    Pernyataan

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

    Parameter

    kind

    Semacam perangkat untuk menjalankan operasi TensorFlow.

    index

    Perangkat untuk menjalankan operasi.

    body

    Penutupan yang operasi TensorFlownya akan dijalankan pada jenis perangkat tertentu.

  • Menjalankan penutupan, membuat operasi TensorFlow berjalan pada perangkat dengan nama tertentu.

    Beberapa contoh nama perangkat:

    • “/device:CPU:0”: CPU mesin Anda.
    • “/GPU:0”: Notasi singkat untuk GPU pertama mesin Anda yang terlihat oleh TensorFlow
    • “/job:localhost/replica:0/task:0/device:GPU:1”: Nama GPU kedua mesin Anda yang sepenuhnya memenuhi syarat dan dapat dilihat oleh TensorFlow.

    Pernyataan

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

    Parameter

    name

    Nama perangkat.

    body

    Penutupan yang operasi TensorFlownya akan dijalankan pada jenis perangkat tertentu.

  • Menjalankan penutupan, memungkinkan TensorFlow menempatkan operasi TensorFlow di perangkat apa pun. Ini akan mengembalikan perilaku penempatan default.

    Pernyataan

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

    Parameter

    body

    Penutupan yang operasi TensorFlownya akan dijalankan pada jenis perangkat tertentu.

  • Ubah ukuran gambar ke ukuran menggunakan metode yang ditentukan.

    Prasyarat

    Gambar harus memiliki peringkat 3 atau 4 .

    Prasyarat

    Ukurannya harus positif.

    Pernyataan

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

    Parameter

    images

    Tensor bentuk 4-D [batch, height, width, channels] atau Tensor bentuk 3-D [height, width, channels] .

    size

    Ukuran gambar yang baru.

    method

    Metode pengubahan ukuran. Nilai defaultnya adalah .bilinear .

    antialias

    Jika true , gunakan filter anti-aliasing saat melakukan downsampling gambar.

  • Ubah ukuran gambar ke ukuran menggunakan interpolasi area.

    Prasyarat

    Gambar harus memiliki peringkat 3 atau 4 .

    Prasyarat

    Ukurannya harus positif.

    Pernyataan

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

    Parameter

    images

    Tensor bentuk 4-D [batch, height, width, channels] atau Tensor bentuk 3-D [height, width, channels] .

    size

    Ukuran gambar yang baru.

  • Mengembalikan dilatasi 2D dengan input, filter, langkah, dan padding yang ditentukan.

    Prasyarat

    input harus memiliki peringkat 4 .

    Prasyarat

    filter harus memiliki peringkat 3 .

    Pernyataan

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

    Parameter

    input

    Masukan.

    filter

    Filter pelebaran.

    strides

    Langkah filter geser untuk setiap dimensi masukan.

    padding

    Bantalan untuk operasi

    rates

    Tingkat pelebaran untuk setiap dimensi masukan.

  • Mengembalikan erosi 2D dengan input, filter, langkah, dan padding yang ditentukan.

    Prasyarat

    input harus memiliki peringkat 4 .

    Prasyarat

    filter harus memiliki peringkat 3.

    Pernyataan

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

    Parameter

    input

    Masukan.

    filter

    Filter erosi.

    strides

    Langkah filter geser untuk setiap dimensi masukan.

    padding

    Bantalan untuk operasi

    rates

    Tingkat pelebaran untuk setiap dimensi masukan.

  • Mengembalikan fungsi yang membuat tensor dengan menginisialisasi semua nilainya ke nol.

    Pernyataan

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

  • Mengembalikan fungsi yang membuat tensor dengan menginisialisasi semua nilainya ke nilai yang disediakan.

    Pernyataan

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

  • Mengembalikan fungsi yang membuat tensor dengan menginisialisasinya ke nilai yang diberikan. Perhatikan bahwa penyiaran dengan nilai yang diberikan tidak didukung.

    Pernyataan

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

  • Mengembalikan fungsi yang membuat tensor dengan melakukan inisialisasi seragam Glorot (Xavier) untuk bentuk yang ditentukan, mengambil sampel nilai skalar secara acak dari distribusi seragam antara -limit dan limit , dihasilkan oleh generator bilangan acak default, dengan limit adalah sqrt(6 / (fanIn + fanOut)) , dan fanIn / fanOut mewakili jumlah fitur input dan output dikalikan dengan bidang reseptif, jika ada.

    Pernyataan

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

  • Mengembalikan fungsi yang membuat tensor dengan melakukan inisialisasi normal Glorot (Xavier) untuk bentuk yang ditentukan, mengambil sampel nilai skalar secara acak dari distribusi normal terpotong yang berpusat pada 0 dengan deviasi standar sqrt(2 / (fanIn + fanOut)) , di mana fanIn / fanOut mewakili jumlah fitur masukan dan keluaran dikalikan dengan ukuran bidang reseptif, jika ada.

    Pernyataan

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

  • Mengembalikan fungsi yang membuat tensor dengan melakukan inisialisasi seragam He (Kaiming) untuk bentuk yang ditentukan, mengambil sampel nilai skalar secara acak dari distribusi seragam antara -limit dan limit , dihasilkan oleh generator bilangan acak default, dengan limit adalah sqrt(6 / fanIn) , dan fanIn mewakili jumlah fitur masukan dikalikan dengan bidang reseptif, jika ada.

    Pernyataan

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

  • Mengembalikan fungsi yang membuat tensor dengan melakukan inisialisasi normal He (Kaiming) untuk bentuk yang ditentukan, mengambil sampel nilai skalar secara acak dari distribusi normal terpotong yang berpusat pada 0 dengan deviasi standar sqrt(2 / fanIn) , dengan fanIn mewakili jumlah fitur masukan dikalikan dengan ukuran bidang reseptif, jika ada.

    Pernyataan

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

  • Mengembalikan fungsi yang membuat tensor dengan melakukan inisialisasi seragam LeCun untuk bentuk yang ditentukan, mengambil sampel nilai skalar secara acak dari distribusi seragam antara -limit dan limit , dihasilkan oleh generator bilangan acak default, dengan limit adalah sqrt(3 / fanIn) , dan fanIn mewakili jumlah fitur masukan dikalikan dengan bidang reseptif, jika ada.

    Pernyataan

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

  • Mengembalikan fungsi yang membuat tensor dengan melakukan inisialisasi normal LeCun untuk bentuk yang ditentukan, mengambil sampel nilai skalar secara acak dari distribusi normal terpotong yang berpusat pada 0 dengan deviasi standar sqrt(1 / fanIn) , dengan fanIn mewakili jumlah fitur masukan dikalikan dengan ukuran bidang reseptif, jika ada.

    Pernyataan

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

  • Mengembalikan fungsi yang membuat tensor dengan menginisialisasi semua nilainya secara acak dari distribusi Normal yang terpotong. Nilai yang dihasilkan mengikuti distribusi Normal dengan mean mean dan standar deviasi standardDeviation , kecuali nilai yang besarnya lebih dari dua standar deviasi dari mean dihilangkan dan diambil sampelnya kembali.

    Pernyataan

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

    Parameter

    mean

    Rata-rata distribusi Normal.

    standardDeviation

    Simpangan baku dari distribusi Normal.

    Nilai Pengembalian

    Fungsi penginisialisasi parameter normal terpotong.

  • Pernyataan

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

  • Mengembalikan matriks identitas atau kumpulan matriks.

    Pernyataan

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

    Parameter

    rowCount

    Jumlah baris dalam setiap matriks batch.

    columnCount

    Jumlah kolom di setiap matriks batch.

    batchShape

    Dimensi batch terdepan dari tensor yang dikembalikan.

  • Menghitung jejak matriks yang dikelompokkan secara opsional. Jejak adalah jumlah sepanjang diagonal utama setiap matriks terdalam.

    Inputnya berupa tensor dengan bentuk [..., M, N] . Outputnya adalah tensor dengan bentuk [...] .

    Prasyarat

    matrix harus berupa tensor dengan bentuk [..., M, N] .

    Pernyataan

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

    Parameter

    matrix

    Tensor berbentuk [..., M, N] .

  • Mengembalikan dekomposisi Cholesky dari satu atau lebih matriks persegi.

    Inputnya berupa tensor berbentuk [..., M, M] yang 2 dimensi terdalamnya berbentuk matriks persegi.

    Masukannya harus simetris dan pasti positif. Hanya bagian masukan segitiga bawah yang akan digunakan untuk operasi ini. Bagian segitiga atas tidak akan terbaca.

    Outputnya adalah tensor dengan bentuk yang sama dengan input yang berisi dekomposisi Cholesky untuk semua submatriks input [..., :, :] .

    Pernyataan

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

    Parameter

    input

    Tensor berbentuk [..., M, M] .

  • Mengembalikan solusi x ke sistem persamaan linear yang diwakili oleh Ax = b .

    Prasyarat

    matrix harus berupa tensor dengan bentuk [..., M, M] .

    Prasyarat

    rhs harus berupa tensor dengan bentuk [..., M, K] .

    Pernyataan

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

    Parameter

    matrix

    Matriks koefisien segitiga masukan, mewakili A dalam Ax = b .

    rhs

    Nilai sisi kanan, mewakili b dalam Ax = b .

    lower

    Apakah matrix segitiga bawah ( true ) atau segitiga atas ( false ). Nilai defaultnya adalah true .

    adjoint

    Jika true , selesaikan dengan adjoint matrix , bukan matrix . Nilai defaultnya adalah false .

    Nilai Pengembalian

    Solusi x sistem persamaan linear diwakili oleh Ax = b . x memiliki bentuk yang sama dengan b .

  • Menghitung kerugian L1 antara expected dan predicted . loss = reduction(abs(expected - predicted))

    Pernyataan

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

    Parameter

    predicted

    Output yang diprediksi dari jaringan saraf.

    expected

    Nilai yang diharapkan, yaitu target, yang sesuai dengan keluaran yang benar.

    reduction

    Pengurangan untuk diterapkan pada nilai kerugian berdasarkan elemen yang dihitung.

  • Menghitung kerugian L2 antara expected dan predicted . loss = reduction(square(expected - predicted))

    Pernyataan

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

    Parameter

    predicted

    Output yang diprediksi dari jaringan saraf.

    expected

    Nilai yang diharapkan, yaitu target, yang sesuai dengan keluaran yang benar.

    reduction

    Pengurangan untuk diterapkan pada nilai kerugian berdasarkan elemen yang dihitung.

  • Menghitung rata-rata perbedaan absolut antara label dan prediksi. loss = mean(abs(expected - predicted))

    Pernyataan

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

    Parameter

    predicted

    Output yang diprediksi dari jaringan saraf.

    expected

    Nilai yang diharapkan, yaitu target, yang sesuai dengan keluaran yang benar.

  • Menghitung rata-rata kuadrat kesalahan antara label dan prediksi. loss = mean(square(expected - predicted))

    Pernyataan

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

    Parameter

    predicted

    Output yang diprediksi dari jaringan saraf.

    expected

    Nilai yang diharapkan, yaitu target, yang sesuai dengan keluaran yang benar.

  • Menghitung rata-rata kesalahan logaritmik kuadrat antara kerugian predicted dan expected loss = square(log(expected) - log(predicted))

    Catatan

    Entri tensor negatif akan dijepit pada 0 untuk menghindari perilaku logaritmik yang tidak terdefinisi, karena log(_:) tidak terdefinisi untuk real negatif.

    Pernyataan

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

    Parameter

    predicted

    Output yang diprediksi dari jaringan saraf.

    expected

    Nilai yang diharapkan, yaitu target, yang sesuai dengan keluaran yang benar.

  • Menghitung rata-rata persentase kesalahan absolut antara predicted dan expected . loss = 100 * mean(abs((expected - predicted) / abs(expected)))

    Pernyataan

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

    Parameter

    predicted

    Output yang diprediksi dari jaringan saraf.

    expected

    Nilai yang diharapkan, yaitu target, yang sesuai dengan keluaran yang benar.

  • Menghitung kerugian engsel antara predicted dan expected . loss = reduction(max(0, 1 - predicted * expected)) nilai yang expected diharapkan -1 atau 1.

    Pernyataan

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

    Parameter

    predicted

    Output yang diprediksi dari jaringan saraf.

    expected

    Nilai yang diharapkan, yaitu target, yang sesuai dengan keluaran yang benar.

    reduction

    Pengurangan untuk diterapkan pada nilai kerugian berdasarkan elemen yang dihitung.

  • Menghitung kerugian engsel kuadrat antara predicted dan expected . loss = reduction(square(max(0, 1 - predicted * expected))) nilai yang expected diharapkan -1 atau 1.

    Pernyataan

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

    Parameter

    predicted

    Output yang diprediksi dari jaringan saraf.

    expected

    Nilai yang diharapkan, yaitu target, yang sesuai dengan keluaran yang benar.

    reduction

    Pengurangan untuk diterapkan pada nilai kerugian berdasarkan elemen yang dihitung.

  • Menghitung kerugian engsel kategorikal antara predicted dan expected . loss = maximum(negative - positive + 1, 0) dengan negative = max((1 - expected) * predicted) dan positive = sum(predicted * expected)

    Pernyataan

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

    Parameter

    predicted

    Output yang diprediksi dari jaringan saraf.

    expected

    Nilai yang diharapkan, yaitu target, yang sesuai dengan keluaran yang benar.

    reduction

    Pengurangan untuk diterapkan pada nilai kerugian berdasarkan elemen yang dihitung.

  • Menghitung logaritma kosinus hiperbolik dari kesalahan prediksi. logcosh = log((exp(x) + exp(-x))/2) , di mana x adalah kesalahan predicted - expected

    Pernyataan

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

    Parameter

    predicted

    Output yang diprediksi dari jaringan saraf.

    expected

    Nilai yang diharapkan, yaitu target, yang sesuai dengan keluaran yang benar.

    reduction

    Pengurangan untuk diterapkan pada nilai kerugian berdasarkan elemen yang dihitung.

  • Menghitung kerugian Poisson antara prediksi dan ekspektasi Kerugian Poisson adalah rata-rata elemen Tensor predicted - expected * log(predicted) .

    Pernyataan

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

    Parameter

    predicted

    Output yang diprediksi dari jaringan saraf.

    expected

    Nilai yang diharapkan, yaitu target, yang sesuai dengan keluaran yang benar.

    reduction

    Pengurangan untuk diterapkan pada nilai kerugian berdasarkan elemen yang dihitung.

  • Menghitung kerugian divergensi Kullback-Leibler antara expected dan predicted . loss = reduction(expected * log(expected / predicted))

    Pernyataan

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

    Parameter

    predicted

    Output yang diprediksi dari jaringan saraf.

    expected

    Nilai yang diharapkan, yaitu target, yang sesuai dengan keluaran yang benar.

    reduction

    Pengurangan untuk diterapkan pada nilai kerugian berdasarkan elemen yang dihitung.

  • Menghitung entropi silang softmax yang jarang (entropi silang kategoris) antara logit dan label. Gunakan fungsi kerugian crossentropy ini ketika ada dua atau lebih kelas label. Kami mengharapkan label diberikan sebagai bilangan bulat. Harus ada # classes per fitur untuk logits dan satu nilai floating point per fitur untuk expected .

    Pernyataan

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

    Parameter

    logits

    Output yang dikodekan one-hot dari jaringan saraf.

    labels

    Indeks (diindeks nol) dari keluaran yang benar.

    reduction

    Pengurangan untuk diterapkan pada nilai kerugian berdasarkan elemen yang dihitung.

  • Menghitung entropi silang softmax yang jarang (entropi silang kategoris) antara logit dan label. Gunakan fungsi kerugian crossentropy ini ketika ada dua atau lebih kelas label. Kami mengharapkan label diberikan dalam representasi one_hot . Harus ada # classes per fitur.

    Pernyataan

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

    Parameter

    logits

    Probabilitas log yang tidak berskala dari jaringan neural.

    probabilities

    Nilai probabilitas yang sesuai dengan keluaran yang benar. Setiap baris harus merupakan distribusi probabilitas yang valid.

    reduction

    Pengurangan untuk diterapkan pada nilai kerugian berdasarkan elemen yang dihitung.

  • Menghitung entropi silang sigmoid (entropi silang biner) antara logit dan label. Gunakan kerugian entropi silang ini ketika hanya ada dua kelas label (diasumsikan 0 dan 1). Untuk setiap contoh, harus ada satu nilai floating-point per prediksi.

    Pernyataan

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

    Parameter

    logits

    Output jaringan saraf yang tidak berskala.

    labels

    Nilai integer yang sesuai dengan output yang benar.

    reduction

    Pengurangan untuk diterapkan pada nilai kerugian berdasarkan elemen yang dihitung.

  • Menghitung kerugian Huber antara predicted dan expected .

    Untuk setiap nilai x dalam error = expected - predicted :

    • 0.5 * x^2 jika |x| <= δ .

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

    • Sumber: artikel Wikipedia .

    Pernyataan

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

    Parameter

    predicted

    Output yang diprediksi dari jaringan saraf.

    expected

    Nilai yang diharapkan, yaitu target, yang sesuai dengan keluaran yang benar.

    delta

    Skalar titik mengambang yang mewakili titik di mana fungsi kerugian Huber berubah dari kuadrat menjadi linier.

    reduction

    Pengurangan untuk diterapkan pada nilai kerugian berdasarkan elemen yang dihitung.

  • Mengembalikan nilai absolut dari elemen tensor yang ditentukan.

    Pernyataan

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

  • Mengembalikan logaritma natural dari elemen tensor yang ditentukan.

    Pernyataan

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

  • Mengembalikan logaritma basis dua dari elemen tensor yang ditentukan.

    Pernyataan

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

  • Mengembalikan logaritma basis sepuluh dari elemen tensor yang ditentukan.

    Pernyataan

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

  • Mengembalikan logaritma 1 + x berdasarkan elemen.

    Pernyataan

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

  • Mengembalikan log(1 - exp(x)) menggunakan pendekatan yang stabil secara numerik.

    Catatan

    Pendekatannya ditunjukkan pada Persamaan 7 dari: https://cran.r-project.org/web/packages/Rmpfr/vignettes/log1mexp-note.pdf .

    Pernyataan

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

  • Mengembalikan sinus dari elemen tensor yang ditentukan.

    Pernyataan

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

  • Mengembalikan kosinus dari elemen tensor yang ditentukan.

    Pernyataan

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

  • Mengembalikan tangen dari elemen tensor yang ditentukan.

    Pernyataan

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

  • Mengembalikan sinus hiperbolik dari elemen tensor yang ditentukan.

    Pernyataan

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

  • Mengembalikan kosinus hiperbolik dari elemen tensor yang ditentukan.

    Pernyataan

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

  • Mengembalikan tangen hiperbolik dari elemen tensor yang ditentukan.

    Pernyataan

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

  • Mengembalikan kosinus terbalik dari elemen tensor yang ditentukan.

    Pernyataan

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

  • Mengembalikan sinus invers dari elemen tensor yang ditentukan.

    Pernyataan

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

  • Mengembalikan kebalikan tangen dari elemen tensor yang ditentukan.

    Pernyataan

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

  • Mengembalikan kosinus hiperbolik terbalik dari elemen tensor yang ditentukan.

    Pernyataan

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

  • Mengembalikan sinus hiperbolik terbalik dari elemen tensor yang ditentukan.

    Pernyataan

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

  • Mengembalikan tangen hiperbolik terbalik dari elemen tensor yang ditentukan.

    Pernyataan

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

  • Mengembalikan akar kuadrat dari elemen tensor yang ditentukan.

    Pernyataan

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

  • Mengembalikan akar kuadrat terbalik dari elemen tensor yang ditentukan.

    Pernyataan

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

  • Mengembalikan eksponensial dari elemen tensor yang ditentukan.

    Pernyataan

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

  • Mengembalikan dua pangkat elemen tensor yang ditentukan.

    Pernyataan

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

  • Mengembalikan sepuluh pangkat elemen tensor yang ditentukan.

    Pernyataan

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

  • Mengembalikan eksponensial x - 1 berdasarkan elemen.

    Pernyataan

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

  • Mengembalikan nilai tensor tertentu yang dibulatkan ke bilangan bulat terdekat, berdasarkan elemen.

    Pernyataan

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

  • Mengembalikan batas atas elemen tensor yang ditentukan.

    Pernyataan

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

  • Mengembalikan nilai dasar elemen tensor yang ditentukan.

    Pernyataan

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

  • Mengembalikan indikasi tanda elemen tensor yang ditentukan. Secara khusus, menghitung y = sign(x) = -1 jika x < 0 ; 0 jika x == 0 ; 1 jika x > 0 .

    Pernyataan

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

  • Mengembalikan sigmoid dari elemen tensor yang ditentukan. Secara khusus, menghitung 1 / (1 + exp(-x)) .

    Pernyataan

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

  • Mengembalikan log-sigmoid dari elemen tensor yang ditentukan. Secara khusus, log(1 / (1 + exp(-x))) . Untuk stabilitas numerik, kami menggunakan -softplus(-x) .

    Pernyataan

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

  • Mengembalikan softplus dari elemen tensor yang ditentukan. Secara khusus, menghitung log(exp(features) + 1) .

    Pernyataan

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

  • Mengembalikan tanda lunak dari elemen tensor yang ditentukan. Secara khusus, menghitung features/ (abs(features) + 1) .

    Pernyataan

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

  • Mengembalikan softmax dari tensor yang ditentukan sepanjang sumbu terakhir. Secara khusus, menghitung exp(x) / exp(x).sum(alongAxes: -1) .

    Pernyataan

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

  • Mengembalikan softmax dari tensor yang ditentukan sepanjang sumbu yang ditentukan. Secara khusus, menghitung exp(x) / exp(x).sum(alongAxes: axis) .

    Pernyataan

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

  • Mengembalikan log-softmax dari elemen tensor yang ditentukan.

    Pernyataan

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

  • Mengembalikan tensor dengan menerapkan unit linier eksponensial. Secara khusus, hitung exp(x) - 1 jika < 0, x sebaliknya. Lihat Pembelajaran Jaringan Dalam yang Cepat dan Akurat dengan Unit Linier Eksponensial (ELU)

    Pernyataan

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

  • Mengembalikan aktivasi Gaussian Error Linear Unit (GELU) dari elemen tensor yang ditentukan.

    Secara khusus, gelu mendekati xP(X <= x) , dengan P(X <= x) adalah distribusi kumulatif Gaussian Standar, dengan menghitung: x * [0.5 * (1 + tanh[√(2/π) * (x + 0,044715*x^3)])].

    Lihat Satuan Linier Kesalahan Gaussian .

    Pernyataan

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

  • Mengembalikan tensor dengan menerapkan fungsi aktivasi ReLU ke elemen tensor yang ditentukan. Secara khusus, menghitung max(0, x) .

    Pernyataan

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

  • Mengembalikan tensor dengan menerapkan fungsi aktivasi ReLU6 yaitu min(max(0, x), 6) .

    Pernyataan

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

  • Mengembalikan tensor dengan menerapkan fungsi aktivasi ReLU yang bocor ke elemen tensor yang ditentukan. Secara khusus, menghitung max(x, x * alpha) .

    Pernyataan

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

  • Mengembalikan tensor dengan menerapkan fungsi aktivasi SeLU, yaitu scale * alpha * (exp(x) - 1) jika x < 0 , dan scale * x sebaliknya.

    Catatan

    Ini dirancang untuk digunakan bersama dengan inisialisasi lapisan penskalaan varians. Silakan merujuk ke Jaringan Neural Normalisasi Mandiri untuk informasi lebih lanjut.

    Pernyataan

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

  • Mengembalikan tensor dengan menerapkan fungsi aktivasi swish, yaitu x * sigmoid(x) .

    Sumber: “Mencari Fungsi Aktivasi” (Ramachandran et al. 2017) https://arxiv.org/abs/1710.05941

    Pernyataan

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

  • Mengembalikan tensor dengan menerapkan fungsi aktivasi sigmoid keras, yaitu Relu6(x+3)/6 .

    Sumber: “Mencari MobileNetV3” (Howard dkk. 2019) https://arxiv.org/abs/1905.02244

    Pernyataan

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

  • Mengembalikan tensor dengan menerapkan fungsi aktivasi hard swish, yaitu x * Relu6(x+3)/6 .

    Sumber: “Mencari MobileNetV3” (Howard dkk. 2019) https://arxiv.org/abs/1905.02244

    Pernyataan

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

  • Mengembalikan tensor dengan menerapkan fungsi aktivasi mish, yaitu x * tanh(softplus(x)) .

    Sumber: “Mish: Fungsi Aktivasi Neural Non-Monotonik yang Teratur Sendiri” https://arxiv.org/abs/1908.08681

    Pernyataan

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

  • Mengembalikan kekuatan tensor pertama ke tensor kedua.

    Pernyataan

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

  • Mengembalikan kekuatan skalar ke tensor, menyiarkan skalar.

    Pernyataan

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

  • Mengembalikan kekuatan tensor ke skalar, menyiarkan skalar.

    Pernyataan

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

  • Mengembalikan kekuatan tensor ke skalar, menyiarkan skalar.

    Pernyataan

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

  • Mengembalikan akar tensor n berdasarkan elemen.

    Pernyataan

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

  • Mengembalikan selisih kuadrat antara x dan y .

    Pernyataan

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

    Nilai Pengembalian

    (x - y) ^ 2 .

  • Mengembalikan maksimum dua tensor berdasarkan elemen.

    Catatan

    max mendukung penyiaran.

    Pernyataan

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

  • Mengembalikan nilai maksimum skalar dan tensor berdasarkan elemen, menyiarkan skalar.

    Pernyataan

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

  • Mengembalikan nilai maksimum skalar dan tensor berdasarkan elemen, menyiarkan skalar.

    Pernyataan

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

  • Mengembalikan dua tensor berdasarkan elemen.

    Catatan

    min mendukung penyiaran.

    Pernyataan

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

  • Mengembalikan skalar dan tensor minimum berdasarkan elemen, menyiarkan skalar.

    Pernyataan

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

  • Mengembalikan skalar dan tensor minimum berdasarkan elemen, menyiarkan skalar.

    Pernyataan

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

  • Mengembalikan kesamaan kosinus antara x dan y .

    Pernyataan

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

  • Mengembalikan jarak kosinus antara x dan y . Jarak kosinus didefinisikan sebagai 1 - cosineSimilarity(x, y) .

    Pernyataan

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

  • Melakukan perkalian matriks dengan tensor lain dan menghasilkan hasilnya.

    Pernyataan

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

  • Mengembalikan konvolusi 1-D dengan input, filter, langkah, dan padding yang ditentukan.

    Prasyarat

    input harus memiliki peringkat 3 .

    Prasyarat

    filter harus memiliki peringkat 3.

    Pernyataan

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

    Parameter

    input

    Masukan.

    filter

    Filter konvolusi.

    stride

    Langkah filter geser.

    padding

    Bantalan untuk operasi.

    dilation

    Faktor dilatasi.

  • Mengembalikan konvolusi 2D dengan input, filter, langkah, dan padding yang ditentukan.

    Prasyarat

    input harus memiliki peringkat 4 .

    Prasyarat

    filter harus memiliki peringkat 4.

    Pernyataan

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

    Parameter

    input

    Masukan.

    filter

    Filter konvolusi.

    strides

    Langkah filter geser untuk setiap dimensi masukan.

    padding

    Bantalan untuk operasi

    dilations

    Faktor dilatasi untuk setiap dimensi masukan.

  • Mengembalikan konvolusi transposisi 2D dengan input, filter, langkah, dan padding yang ditentukan.

    Prasyarat

    input harus memiliki peringkat 4 .

    Prasyarat

    filter harus memiliki peringkat 4.

    Pernyataan

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

    Parameter

    input

    Masukan.

    shape

    Bentuk keluaran dari operasi dekonvolusi.

    filter

    Filter konvolusi.

    strides

    Langkah filter geser untuk setiap dimensi masukan.

    padding

    Bantalan untuk operasi

    dilations

    Faktor dilatasi untuk setiap dimensi masukan.

  • Mengembalikan konvolusi 3-D dengan input, filter, langkah, padding, dan dilatasi yang ditentukan.

    Prasyarat

    input harus memiliki peringkat 5 .

    Prasyarat

    filter harus memiliki peringkat 5.

    Pernyataan

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

    Parameter

    input

    Masukan.

    filter

    Filter konvolusi.

    strides

    Langkah filter geser untuk setiap dimensi masukan.

    padding

    Bantalan untuk operasi.

    dilations

    Faktor dilatasi untuk setiap dimensi masukan.

  • Mengembalikan konvolusi mendalam 2D ​​dengan input, filter, langkah, dan padding yang ditentukan.

    Prasyarat

    input harus memiliki peringkat 4.

    Prasyarat

    filter harus memiliki peringkat 4.

    Pernyataan

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

    Parameter

    input

    Masukan.

    filter

    Filter konvolusi mendalam.

    strides

    Langkah filter geser untuk setiap dimensi masukan.

    padding

    Bantalan untuk operasi.

  • Mengembalikan penggabungan maksimal 2D, dengan ukuran filter, langkah, dan bantalan yang ditentukan.

    Pernyataan

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

    Parameter

    input

    Masukan.

    filterSize

    Dimensi kernel pooling.

    strides

    Langkah filter geser untuk setiap dimensi masukan.

    padding

    Bantalan untuk operasi.

  • Mengembalikan penggabungan maksimal 3-D, dengan ukuran filter, langkah, dan padding yang ditentukan.

    Pernyataan

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

    Parameter

    input

    Masukan.

    filterSize

    Dimensi kernel pooling.

    strides

    Langkah filter geser untuk setiap dimensi masukan.

    padding

    Bantalan untuk operasi.

  • Mengembalikan pengumpulan rata-rata 2D, dengan ukuran filter, langkah, dan padding yang ditentukan.

    Pernyataan

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

    Parameter

    input

    Masukan.

    filterSize

    Dimensi kernel pooling.

    strides

    Langkah filter geser untuk setiap dimensi masukan.

    padding

    Bantalan untuk operasi.

  • Mengembalikan pengumpulan rata-rata 3-D, dengan ukuran filter, langkah, dan padding yang ditentukan.

    Pernyataan

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

    Parameter

    input

    Masukan.

    filterSize

    Dimensi kernel pooling.

    strides

    Langkah filter geser untuk setiap dimensi masukan.

    padding

    Bantalan untuk operasi.

  • Mengembalikan penggabungan maksimal pecahan 2-D, dengan rasio pengumpulan yang ditentukan.

    Catatan: fractionalMaxPool tidak memiliki implementasi XLA, sehingga mungkin mempunyai implikasi kinerja.

    Pernyataan

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

    Parameter

    input

    Sebuah Tensor. 4-D dengan bentuk [batch, height, width, channels] .

    poolingRatio

    Daftar Doubles . Rasio pengumpulan untuk setiap dimensi input , saat ini hanya mendukung dimensi baris dan kolom dan harus >= 1,0.

    pseudoRandom

    Bool opsional. Defaultnya adalah false . Jika disetel ke true , menghasilkan urutan pengumpulan secara acak semu, jika tidak, secara acak.

    overlapping

    Bool opsional. Defaultnya adalah false . Jika disetel ke true , artinya saat menggabungkan, nilai pada batas sel gabungan yang berdekatan digunakan oleh kedua sel.

    deterministic

    Bool Opsional. Jika disetel ke true , wilayah pengumpulan tetap akan digunakan saat melakukan iterasi pada node pecahanMaxPool2D dalam grafik komputasi.

    seed

    Int64 opsional. Defaultnya adalah 0 . Jika disetel bukan nol, penghasil angka acak akan diunggulkan berdasarkan benih yang diberikan.

    seed2

    Int64 opsional. Defaultnya adalah 0 . Benih kedua untuk menghindari benturan benih.

  • Mengembalikan salinan input yang nilai dari dimensi kedalaman dipindahkan dalam blok spasial ke dimensi tinggi dan lebar.

    Misalnya, jika diberi masukan bentuk [1, 2, 2, 1] , data_format = “NHWC” dan block_size = 2:

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

    Operasi ini akan menghasilkan tensor berbentuk [1, 1, 1, 4] :

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

    Di sini, masukan memiliki kumpulan 1 dan setiap elemen kumpulan memiliki bentuk [2, 2, 1] , keluaran yang sesuai akan memiliki satu elemen (yaitu lebar dan tinggi keduanya 1) dan akan memiliki kedalaman 4 saluran (1 * ukuran_blok * ukuran_blok). Bentuk elemen keluarannya adalah [1, 1, 4] .

    Untuk tensor masukan dengan kedalaman lebih besar, bentuk berikut [1, 2, 2, 3] , misalnya

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

    Operasi ini, untuk ukuran_blok 2, akan mengembalikan tensor bentuk berikut [1, 1, 1, 12]

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

    Demikian pula untuk masukan bentuk [1 4 4 1] berikut, dan ukuran blok 2:

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

    operator akan mengembalikan tensor bentuk berikut [1 2 2 4] :

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

    Prasyarat

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

    Prasyarat

    Banyaknya fitur harus habis dibagi kuadrat b .

    Pernyataan

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

  • Mengembalikan salinan input yang nilai dari dimensi tinggi dan lebar dipindahkan ke dimensi kedalaman.

    Misalnya, jika diberi masukan bentuk [1, 2, 2, 1] , data_format = “NHWC” dan block_size = 2:

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

    Operasi ini akan menghasilkan tensor berbentuk [1, 1, 1, 4] :

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

    Di sini, masukan memiliki kumpulan 1 dan setiap elemen kumpulan memiliki bentuk [2, 2, 1] , keluaran yang sesuai akan memiliki satu elemen (yaitu lebar dan tinggi keduanya 1) dan akan memiliki kedalaman 4 saluran (1 * ukuran_blok * ukuran_blok). Bentuk elemen keluarannya adalah [1, 1, 4] .

    Untuk tensor masukan dengan kedalaman lebih besar, bentuk berikut [1, 2, 2, 3] , misalnya

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

    Operasi ini, untuk ukuran_blok 2, akan mengembalikan tensor bentuk berikut [1, 1, 1, 12]

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

    Demikian pula untuk masukan bentuk [1 4 4 1] berikut, dan ukuran blok 2:

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

    operator akan mengembalikan tensor bentuk berikut [1 2 2 4] :

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

    Prasyarat

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

    Prasyarat

    Ketinggian masukan harus habis dibagi b .

    Prasyarat

    Lebar masukan harus habis dibagi b .

    Pernyataan

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

  • Membuat pengoptimal per bobot untuk LARS ( https://arxiv.org/pdf/1708.03888.pdf ).

    Pernyataan

    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

  • Membangun pengoptimal per bobot berbasis SGD.

    Pernyataan

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

  • Membangun pengoptimal per berat untuk Adam dengan pembusukan berat badan.

    Referensi: "Adam - Metode untuk Optimasi Stokastik"

    Pernyataan

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

  • Menghasilkan benih acak baru untuk TensorFlow.

    Pernyataan

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

  • Menggabungkan dua nilai.

    Pernyataan

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

  • Menambahkan dua nilai dan menghasilkan jumlahnya.

    Pernyataan

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

  • Rata -rata dua nilai.

    Pernyataan

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

  • Mengalikan dua nilai.

    Pernyataan

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

  • Tumpuk dua nilai.

    Pernyataan

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

  • Pernyataan

    public func PrintX10Metrics()

  • Membuat ringkasan string dari daftar pelatihan dan pengujian statistik.

    Pernyataan

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

  • Pernyataan

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

  • Memetakan fungsi di atas n utas.

    Pernyataan

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