Hadiri Simposium Women in ML pada 7 Desember Daftar sekarang

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 output 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 output 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 output 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 output 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 output yang benar.

  • Mengembalikan logaritma kosinus hiperbolik dari 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 output 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 output yang benar.

  • Mengembalikan divergensi Kullback-Leibler (divergensi KL) antara ekspektasi dan prediksi. Mengingat dua distribusi p dan q , KL divergensi 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 output yang benar.

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

    Pernyataan

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

    Parameter

    logits

    Output enkode satu-panas dari jaringan saraf.

    labels

    Indeks (diindeks nol) dari output yang benar.

  • Mengembalikan entropi silang sigmoid (entropi silang biner) antara log 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

    Keluaran tanpa skala dari jaringan saraf.

    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 memiliki segalanya identik dengan konteks saat ini kecuali untuk fase pembelajaran yang diberikan.

    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 nol. Jika penutupan memiliki nilai kembali, nilai yang juga digunakan sebagai nilai kembali dari withContext(_:_:) fungsi.

    Nilai Kembali

    Nilai kembali, jika ada, dari body penutupan.

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

    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 nol. Jika penutupan memiliki nilai kembali, nilai yang juga digunakan sebagai nilai kembali dari withLearningPhase(_:_:) fungsi.

    Nilai Kembali

    Nilai kembali, jika ada, dari body penutupan.

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

    Pernyataan

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

    Parameter

    randomSeed

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

    body

    Penutupan nol. Jika penutupan memiliki nilai kembali, nilai yang juga digunakan sebagai nilai kembali dari withRandomSeedForTensorFlow(_:_:) fungsi.

    Nilai Kembali

    Nilai kembali, jika ada, dari body penutupan.

  • Memanggil penutupan yang diberikan dalam konteks yang memiliki segalanya 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 nol. Jika penutupan memiliki nilai kembali, nilai yang juga digunakan sebagai nilai kembali dari withRandomNumberGeneratorForTensorFlow(_:_:) fungsi.

    Nilai Kembali

    Nilai kembali, jika ada, dari body penutupan.

  • Pernyataan

    public func zip<T: TensorGroup, U: TensorGroup>(
      _ dataset1: Dataset<T>, _ dataset2: Dataset<U>
    ) -> Dataset<Zip2TensorGroup<T, U>>
  • LazyTensorBarrier memastikan semua tensor langsung (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
  • Jadikan suatu fungsi dihitung ulang dalam pullback-nya, yang dikenal sebagai "checkpointing" 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
  • Pengembalian x seperti fungsi identitas. Ketika digunakan dalam konteks di mana x sedang dibedakan sehubungan dengan, fungsi ini tidak akan menghasilkan apapun derivatif pada x .

    Pernyataan

    @_semantics("autodiff.nonvarying")
    public func withoutDerivative<T>(at x: T) -> T
  • Berlaku penutupan diberikan body untuk x . Ketika digunakan dalam konteks di mana x sedang dibedakan sehubungan dengan, fungsi ini tidak akan menghasilkan apapun derivatif pada 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 yang ditentukan.

  • Menjalankan penutupan, membuat operasi TensorFlow berjalan di 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 yang sepenuhnya memenuhi syarat dari GPU kedua mesin Anda yang terlihat 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 yang ditentukan.

  • Menjalankan penutupan, memungkinkan TensorFlow menempatkan operasi TensorFlow di perangkat apa pun. Ini akan memulihkan 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 yang ditentukan.

  • Ubah ukuran gambar menjadi 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

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

    size

    Ukuran gambar baru.

    method

    Metode pengubahan ukuran. Nilai default adalah .bilinear .

    antialias

    IFF true , menggunakan filter anti-aliasing ketika downsampling gambar.

  • Ubah ukuran gambar menjadi 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

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

    size

    Ukuran gambar baru.

  • Mengembalikan dilatasi 2-D 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-langkah filter geser untuk setiap dimensi input.

    padding

    Bantalan untuk operasi

    rates

    Laju dilatasi untuk setiap dimensi input.

  • Mengembalikan erosi 2-D 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-langkah filter geser untuk setiap dimensi input.

    padding

    Bantalan untuk operasi

    rates

    Laju dilatasi untuk setiap dimensi input.

  • 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 diberikan.

    Pernyataan

    public func constantInitializer<Scalar: TensorFlowFloatingPoint>(
      value: Scalar
    ) -> ParameterInitializer<Scalar>
  • Mengembalikan fungsi yang membuat tensor dengan menginisialisasinya ke nilai yang diberikan. Perhatikan bahwa penyiaran dari nilai yang diberikan tidak didukung.

    Pernyataan

    public func constantInitializer<Scalar: TensorFlowFloatingPoint>(
      value: Tensor<Scalar>
    ) -> ParameterInitializer<Scalar>
  • Pengembalian fungsi yang menciptakan tensor dengan melakukan Glorot (Xavier) inisialisasi seragam untuk bentuk yang ditentukan, secara acak sampel nilai-nilai skalar dari distribusi seragam antara -limit dan limit , yang dihasilkan oleh generator standar nomor acak, di mana batas adalah sqrt(6 / (fanIn + fanOut)) , dan fanIn / fanOut merupakan jumlah input dan output fitur dikalikan dengan bidang reseptif, jika ada.

    Pernyataan

    public func glorotUniform<Scalar: TensorFlowFloatingPoint>(
      seed: TensorFlowSeed = Context.local.randomSeed
    ) -> ParameterInitializer<Scalar>
  • Pengembalian fungsi yang menciptakan tensor dengan melakukan Glorot (Xavier) inisialisasi normal untuk bentuk tertentu, secara acak sampel nilai-nilai skalar dari distribusi normal terpotong berpusat pada 0 dengan standar deviasi sqrt(2 / (fanIn + fanOut)) , di mana fanIn / fanOut mewakili jumlah fitur input dan output dikalikan dengan ukuran bidang reseptif, jika ada.

    Pernyataan

    public func glorotNormal<Scalar: TensorFlowFloatingPoint>(
      seed: TensorFlowSeed = Context.local.randomSeed
    ) -> ParameterInitializer<Scalar>
  • Pengembalian fungsi yang menciptakan tensor dengan melakukan Dia (Kaiming) inisialisasi seragam untuk bentuk tertentu, secara acak sampel nilai-nilai skalar dari distribusi seragam antara -limit dan limit , yang dihasilkan oleh generator standar nomor acak, di mana batas adalah sqrt(6 / fanIn) , dan fanIn mewakili sejumlah fitur masukan dikalikan dengan bidang reseptif, jika ada.

    Pernyataan

    public func heUniform<Scalar: TensorFlowFloatingPoint>(
      seed: TensorFlowSeed = Context.local.randomSeed
    ) -> ParameterInitializer<Scalar>
  • Pengembalian fungsi yang menciptakan tensor dengan melakukan Dia (Kaiming) inisialisasi normal untuk bentuk yang ditentukan, secara acak sampel nilai-nilai skalar dari distribusi normal terpotong berpusat pada 0 dengan standar deviasi sqrt(2 / fanIn) , di mana fanIn mewakili sejumlah fitur masukan dikalikan dengan ukuran bidang reseptif, jika ada.

    Pernyataan

    public func heNormal<Scalar: TensorFlowFloatingPoint>(
      seed: TensorFlowSeed = Context.local.randomSeed
    ) -> ParameterInitializer<Scalar>
  • Pengembalian fungsi yang menciptakan tensor dengan melakukan LeCun seragam inisialisasi untuk bentuk tertentu, secara acak sampel nilai-nilai skalar dari distribusi seragam antara -limit dan limit , yang dihasilkan oleh generator standar nomor acak, di mana batas adalah sqrt(3 / fanIn) , dan fanIn mewakili sejumlah fitur masukan dikalikan dengan bidang reseptif, jika ada.

    Pernyataan

    public func leCunUniform<Scalar: TensorFlowFloatingPoint>(
      seed: TensorFlowSeed = Context.local.randomSeed
    ) -> ParameterInitializer<Scalar>
  • Pengembalian fungsi yang menciptakan tensor dengan melakukan LeCun inisialisasi normal untuk bentuk tertentu, secara acak sampel nilai-nilai skalar dari distribusi normal terpotong berpusat pada 0 dengan standar deviasi sqrt(1 / fanIn) , di mana fanIn mewakili jumlah input fitur 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-nilai yang dihasilkan mengikuti distribusi normal dengan mean mean dan standar deviasi standardDeviation , kecuali bahwa nilai-nilai yang besarnya lebih dari dua standar deviasi dari mean dijatuhkan dan resampled.

    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 dari distribusi Normal.

    standardDeviation

    Standar deviasi dari distribusi Normal.

    Nilai Kembali

    Fungsi penginisialisasi parameter normal yang terpotong.

  • Pernyataan

    public func == (lhs: TFETensorHandle, rhs: TFETensorHandle) -> Bool
  • Mengembalikan matriks identitas atau sekumpulan 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 dalam setiap matriks batch.

    batchShape

    Dimensi batch terdepan dari tensor yang ditampilkan.

  • Menghitung jejak dari matriks batch opsional. Jejak adalah jumlah sepanjang diagonal utama dari setiap matriks paling dalam.

    Input adalah tensor dengan bentuk [..., M, N] . Output adalah tensor dengan bentuk [...] .

    Prasyarat

    matrix harus menjadi 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

    Sebuah tensor bentuk [..., M, N] .

  • Mengembalikan dekomposisi Cholesky dari satu atau lebih matriks persegi.

    Input adalah tensor bentuk [..., M, M] yang 2 dimensi-paling dalam membentuk matriks persegi.

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

    Output adalah tensor dari bentuk yang sama sebagai masukan yang berisi dekomposisi Cholesky untuk semua submatriks masukan [..., :, :] .

    Pernyataan

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

    Parameter

    input

    Sebuah tensor bentuk [..., M, M] .

  • Pengembalian solusi x untuk sistem persamaan linear yang diwakili oleh Ax = b .

    Prasyarat

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

    Prasyarat

    rhs harus menjadi 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

    Masukan segitiga matriks koefisien, mewakili A di Ax = b .

    rhs

    -Kanan nilai sisi, mewakili b di Ax = b .

    lower

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

    adjoint

    Jika true , memecahkan dengan adjoint dari matrix bukan matrix . Nilai default adalah false .

    Nilai Kembali

    Solusi x untuk sistem persamaan linear yang diwakili oleh Ax = b . x memiliki bentuk yang sama seperti 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 output yang benar.

    reduction

    Pengurangan untuk diterapkan pada nilai kerugian elemen-bijaksana 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 output yang benar.

    reduction

    Pengurangan untuk diterapkan pada nilai kerugian elemen-bijaksana yang dihitung.

  • Menghitung rata-rata perbedaan mutlak 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 output 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 output yang benar.

  • Menghitung mean error logaritmik kuadrat antara predicted dan expected loss = square(log(expected) - log(predicted))

    Catatan

    Entri tensor negatif akan dijepit pada 0 untuk menghindari perilaku logaritmik undefined, sebagai 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 output yang benar.

  • Menghitung rata-rata persentase mutlak kesalahan 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 output yang benar.

  • Menghitung kerugian engsel antara predicted dan expected . loss = reduction(max(0, 1 - predicted * expected)) expected nilai-nilai yang 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 output yang benar.

    reduction

    Pengurangan untuk diterapkan pada nilai kerugian elemen-bijaksana yang dihitung.

  • Menghitung kerugian engsel kuadrat antara predicted dan expected . loss = reduction(square(max(0, 1 - predicted * expected))) expected nilai-nilai yang 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 output yang benar.

    reduction

    Pengurangan untuk diterapkan pada nilai kerugian elemen-bijaksana yang dihitung.

  • Menghitung kerugian engsel kategoris antara predicted dan expected . loss = maximum(negative - positive + 1, 0) di mana 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 output yang benar.

    reduction

    Pengurangan untuk diterapkan pada nilai kerugian elemen-bijaksana yang dihitung.

  • Menghitung logaritma dari 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 output yang benar.

    reduction

    Pengurangan untuk diterapkan pada nilai kerugian elemen-bijaksana yang dihitung.

  • Menghitung kerugian Poisson antara diprediksi dan diharapkan The Poisson loss adalah mean dari unsur-unsur 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 output yang benar.

    reduction

    Pengurangan untuk diterapkan pada nilai kerugian elemen-bijaksana yang dihitung.

  • Hilangnya perbedaan Menghitung 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 output yang benar.

    reduction

    Pengurangan untuk diterapkan pada nilai kerugian elemen-bijaksana yang dihitung.

  • Menghitung entropi silang softmax yang jarang (entropi silang kategoris) antara log dan label. Gunakan fungsi kerugian crossentropy ini ketika ada dua atau lebih kelas label. Kami berharap label diberikan sebagai bilangan bulat. Harus ada # classes nilai-nilai floating point 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 enkode satu-panas dari jaringan saraf.

    labels

    Indeks (diindeks nol) dari output yang benar.

    reduction

    Pengurangan untuk diterapkan pada nilai kerugian elemen-bijaksana yang dihitung.

  • Menghitung entropi silang softmax yang jarang (entropi silang kategoris) antara log dan label. Gunakan fungsi kerugian crossentropy ini ketika ada dua atau lebih kelas label. Kami berharap label yang akan diberikan disediakan dalam one_hot representasi. Harus ada # classes nilai-nilai floating point 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 diskalakan dari jaringan saraf.

    probabilities

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

    reduction

    Pengurangan untuk diterapkan pada nilai kerugian elemen-bijaksana yang dihitung.

  • Menghitung entropi silang sigmoid (entropi silang biner) antara logit dan label. Gunakan kerugian lintas-entropi 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

    Keluaran tanpa skala dari jaringan saraf.

    labels

    Nilai integer yang sesuai dengan output yang benar.

    reduction

    Pengurangan untuk diterapkan pada nilai kerugian elemen-bijaksana 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 output yang benar.

    delta

    Skalar floating point yang mewakili titik di mana fungsi kerugian Huber berubah dari kuadratik ke linier.

    reduction

    Pengurangan untuk diterapkan pada nilai kerugian elemen-bijaksana 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
  • Pengembalian logaritma dari 1 + x elemen-bijaksana.

    Pernyataan

    @differentiable
    public func log1p<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Pengembalian log(1 - exp(x)) dengan menggunakan pendekatan numerik yang stabil.

    Catatan

    Pendekatan ini ditunjukkan dalam 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 tangen terbalik 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 dari elemen tensor yang ditentukan.

    Pernyataan

    @differentiable
    public func exp2<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Mengembalikan sepuluh pangkat dari elemen tensor yang ditentukan.

    Pernyataan

    @differentiable
    public func exp10<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Pengembalian eksponensial dari x - 1 elemen-bijaksana.

    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 langit-langit dari elemen tensor yang ditentukan.

    Pernyataan

    @differentiable
    public func ceil<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Mengembalikan nilai lantai dari elemen tensor yang ditentukan.

    Pernyataan

    @differentiable
    public func floor<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Mengembalikan indikasi tanda dari 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, kita 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 softsign 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 di 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 di 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, menghitung exp(x) - 1 jika <0, x sebaliknya. Lihat Cepat dan Akurat Jauh Learning Network dengan Exponential Linear Unit (ELUs)

    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) , di mana P(X <= x) adalah Standard Gaussian distribusi kumulatif, dengan menghitung: x * [0,5 * (1 + tanh [√ (2 / π) * (x + 0,044715 * x^3)])].

    Lihat Gaussian Kesalahan Linear Unit .

    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
  • Pengembalian sebuah 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>
  • Pengembalian sebuah 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. Silahkan lihat Self-Normalisasi Jaringan Syaraf untuk informasi lebih lanjut.

    Pernyataan

    @differentiable
    public func selu<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Pengembalian sebuah tensor dengan menerapkan fungsi aktivasi desir, yaitu x * sigmoid(x) .

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

    Pernyataan

    @differentiable
    public func swish<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Pengembalian sebuah tensor dengan menerapkan fungsi aktivasi sigmoid keras, yaitu Relu6(x+3)/6 .

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

    Pernyataan

    @differentiable
    public func hardSigmoid<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Pengembalian sebuah tensor dengan menerapkan fungsi aktivasi desir keras, yaitu x * Relu6(x+3)/6 .

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

    Pernyataan

    @differentiable
    public func hardSwish<T>(_ x: Tensor<T>) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Pengembalian sebuah tensor dengan menerapkan fungsi aktivasi mish, yaitu x * tanh(softplus(x)) .

    Sumber: “Mish: Self regularized Non-monoton Neural Aktivasi Fungsi” 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 elemen-bijaksana n th akar tensor tersebut.

    Pernyataan

    @differentiable
    public func root<T>(_ x: Tensor<T>, _ n: Int) -> Tensor<T> where T : TensorFlowFloatingPoint
  • Pengembalian kuadrat perbedaan antara x dan y .

    Pernyataan

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

    Nilai Kembali

    (x - y) ^ 2 .

  • Mengembalikan nilai maksimum dari 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, yang 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, yang 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 nilai minimum elemen dari dua tensor.

    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 nilai minimum skalar dan tensor 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 nilai minimum skalar dan tensor 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
  • Pengembalian cosinus kesamaan antara x dan y .

    Pernyataan

    @differentiable
    public func cosineSimilarity<Scalar: TensorFlowFloatingPoint>(
      _ x: Tensor<Scalar>,
      _ y: Tensor<Scalar>
    ) -> Tensor<Scalar>
  • Pengembalian cosinus jarak antara x dan y . Jarak Cosine 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, stride, 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 pelebaran.

  • Mengembalikan konvolusi 2-D 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-langkah filter geser untuk setiap dimensi input.

    padding

    Bantalan untuk operasi

    dilations

    Faktor dilatasi untuk setiap dimensi input.

  • Mengembalikan konvolusi transposisi 2-D 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-langkah filter geser untuk setiap dimensi input.

    padding

    Bantalan untuk operasi

    dilations

    Faktor dilatasi untuk setiap dimensi input.

  • 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-langkah filter geser untuk setiap dimensi input.

    padding

    Bantalan untuk operasi.

    dilations

    Faktor dilatasi untuk setiap dimensi input.

  • Mengembalikan konvolusi kedalaman 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 yang mendalam.

    strides

    Langkah-langkah filter geser untuk setiap dimensi input.

    padding

    Bantalan untuk operasi.

  • Mengembalikan penggabungan maksimal 2-D, dengan ukuran filter, langkah, dan padding 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-langkah filter geser untuk setiap dimensi input.

    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-langkah filter geser untuk setiap dimensi input.

    padding

    Bantalan untuk operasi.

  • Mengembalikan penggabungan rata-rata 2-D, 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-langkah filter geser untuk setiap dimensi input.

    padding

    Bantalan untuk operasi.

  • Mengembalikan penggabungan 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-langkah filter geser untuk setiap dimensi input.

    padding

    Bantalan untuk operasi.

  • Mengembalikan penggabungan maksimal fraksional 2-D, dengan rasio penyatuan yang ditentukan.

    Catatan: fractionalMaxPool tidak memiliki implementasi XLA, dan dengan demikian dapat memiliki 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 . Pooling rasio untuk masing-masing dimensi input , saat ini hanya mendukung baris dan col dimensi dan harus> = 1.0.

    pseudoRandom

    Opsional Bool . Defaultnya false . Bila diatur ke true , menghasilkan urutan pooling secara pseudorandom, jika tidak, secara acak.

    overlapping

    Opsional Bool . Defaultnya false . Ketika set untuk true , itu berarti ketika pooling, nilai-nilai pada batas sel pooling yang berdekatan yang digunakan oleh kedua sel.

    deterministic

    Sebuah Opsional Bool . Ketika set untuk true , daerah pooling tetap akan digunakan saat iterasi node fractionalMaxPool2D pada grafik perhitungan.

    seed

    Opsional Int64 . Default ke 0 . Jika disetel menjadi bukan nol, generator bilangan acak diunggulkan oleh benih yang diberikan.

    seed2

    Opsional Int64 . Default ke 0 . Benih kedua untuk menghindari tumbukan benih.

  • Mengembalikan salinan input di mana nilai-nilai dari dimensi kedalaman yang pindah blok spasial dengan tinggi dan dimensi lebar.

    Sebagai contoh, diberi masukan dari bentuk [1, 2, 2, 1] , data_format = “NHWC” dan block_size = 2:

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

    Ini operasi akan menampilkan sebuah tensor bentuk [1, 1, 1, 4] :

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

    Di sini, input memiliki batch 1 dan setiap elemen bets memiliki bentuk [2, 2, 1] , output yang sesuai akan memiliki elemen tunggal (yaitu lebar dan tinggi keduanya 1) dan akan memiliki kedalaman 4 saluran (1 * ukuran_blok * ukuran_blok). Bentuk keluaran elemen [1, 1, 4] .

    Untuk tensor input dengan kedalaman yang lebih besar, di sini dari bentuk [1, 2, 2, 3] , misalnya

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

    Operasi ini, untuk block_size dari 2, akan kembali tensor berikut bentuk [1, 1, 1, 12]

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

    Demikian pula, untuk masukan berikut bentuk [1 4 4 1] , 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 berikut bentuk [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

    Jumlah fitur harus dibagi oleh persegi b .

    Pernyataan

    @differentiable(wrt: input)
    public func depthToSpace<Scalar>(_ input: Tensor<Scalar>, blockSize b: Int) -> Tensor<Scalar> where Scalar : TensorFlowScalar
  • Mengembalikan salinan input di mana nilai-nilai dari ketinggian dan dimensi lebar dipindahkan ke dimensi kedalaman.

    Sebagai contoh, diberi masukan dari bentuk [1, 2, 2, 1] , data_format = “NHWC” dan block_size = 2:

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

    Ini operasi akan menampilkan sebuah tensor bentuk [1, 1, 1, 4] :

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

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

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

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

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

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

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

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

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

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

    Precondition

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

    Precondition

    The height of the input must be divisible by b .

    Precondition

    The width of the input must be divisible by b .

    Pernyataan

    @differentiable(wrt: input)
    public func spaceToDepth<Scalar>(_ input: Tensor<Scalar>, blockSize b: Int) -> Tensor<Scalar> where Scalar : TensorFlowScalar
  • Builds a per-weight optimizer for LARS ( https://arxiv.org/pdf/1708.03888.pdf ).

    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
  • Builds a SGD based per-weight optimizer.

    Pernyataan

    public func makeSGD(
      learningRate: Float = 0.01,
      momentum: Float = 0,
      weightDecay: Float = 0,
      nesterov: Bool = false
    ) -> ParameterGroupOptimizer
  • Builds a per-weight optimizer for Adam with weight decay.

    Reference: “Adam - A Method for Stochastic Optimization”

    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
  • Generates a new random seed for TensorFlow.

    Pernyataan

    public func randomSeedForTensorFlow(using seed: TensorFlowSeed? = nil) -> TensorFlowSeed
  • Concatenates two values.

    Pernyataan

    @differentiable
    public func concatenate<T: Mergeable>(
      _ first: T,
      _ second: T
    ) -> T
  • Adds two values and produces their sum.

    Pernyataan

    @differentiable
    public func sum<T: Mergeable>(
      _ first: T,
      _ second: T
    ) -> T
  • Averages two values.

    Pernyataan

    @differentiable
    public func average<T: Mergeable>(
      _ first: T,
      _ second: T
    ) -> T
  • Multiplies two values.

    Pernyataan

    @differentiable
    public func multiply<T: Mergeable>(
      _ first: T,
      _ second: T
    ) -> T
  • Stack two values.

    Pernyataan

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

    public func PrintX10Metrics()
  • Creates a string summary of a list of training and testing stats.

    Pernyataan

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

    public func formatStatistics(train trainStats: HostStatistics, test testStats: HostStatistics)
      -> String
  • Maps a function over n threads.

    Pernyataan

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