Halaman ini diterjemahkan oleh Cloud Translation API.

Class

Kelas-kelas berikut tersedia secara global.

Referensi yang dapat diubah, dibagikan, dan memiliki tensor.

Pernyataan

public final class Parameter<Scalar> where Scalar : TensorFlowScalar

extension Parameter: CopyableToDevice

Pegangan Tensor TFE
Kelas membungkus pointer C ke TensorHandle. Kelas ini memiliki TensorHandle dan bertanggung jawab untuk menghancurkannya.
Pernyataan
public class TFETensorHandle : _AnyTensorHandle
extension TFETensorHandle: Equatable
RMSProp
Pengoptimal RMSProp.
Mengimplementasikan algoritma optimasi RMSProp. RMSProp adalah bentuk penurunan gradien stokastik di mana gradien dibagi dengan rata-rata berjalan dari besaran terkini. RMSProp menyimpan rata-rata pergerakan gradien kuadrat untuk setiap bobot.
Referensi:
- “Kuliah 6.5 - rmsprop: Bagilah gradien dengan rata-rata berjalan dari besarannya saat ini” (Tieleman dan Hinton, 2012)
- “Menghasilkan Urutan Dengan Jaringan Neural Berulang” (Graves, 2013)
Pernyataan
public class RMSProp<Model: Differentiable>: Optimizer where Model.TangentVector: VectorProtocol & PointwiseMultiplicative & ElementaryFunctions & KeyPathIterable, Model.TangentVector.VectorSpaceScalar == Float
AdaGrad
Pengoptimal AdaGrad.
Mengimplementasikan algoritma optimasi AdaGrad (gradien adaptif). AdaGrad memiliki kecepatan pembelajaran khusus parameter, yang disesuaikan dengan seberapa sering parameter diperbarui selama pelatihan. Parameter yang menerima lebih banyak pembaruan memiliki kecepatan pembelajaran yang lebih kecil.
AdaGrad secara individual mengadaptasi kecepatan pembelajaran semua parameter model dengan menskalakannya berbanding terbalik dengan akar kuadrat dari jumlah kuadrat norma gradien.
Referensi: “Metode Subgradien Adaptif untuk Pembelajaran Online dan Optimasi Stokastik” (Duchi dkk, 2011)
Pernyataan
public class AdaGrad<Model: Differentiable>: Optimizer where Model.TangentVector: VectorProtocol & PointwiseMultiplicative & ElementaryFunctions & KeyPathIterable, Model.TangentVector.VectorSpaceScalar == Float
Ada Delta
Pengoptimal AdaDelta.
Menerapkan algoritma optimasi AdaDelta. AdaDelta adalah metode penurunan gradien stokastik berdasarkan informasi orde pertama. Ini mengadaptasi kecepatan pembelajaran berdasarkan jendela pembaruan gradien yang bergerak, alih-alih mengumpulkan semua gradien sebelumnya. Oleh karena itu, AdaDelta terus belajar meski banyak pembaruan telah dilakukan. Ini beradaptasi lebih cepat terhadap perubahan dinamika ruang masalah optimasi.
Referensi: “ADADELTA: Metode Kecepatan Pembelajaran Adaptif” (Zeiler, 2012)
Pernyataan
public class AdaDelta<Model: Differentiable>: Optimizer where Model.TangentVector: VectorProtocol & PointwiseMultiplicative & ElementaryFunctions & KeyPathIterable, Model.TangentVector.VectorSpaceScalar == Float

adam

Pengoptimal Adam.

Menerapkan algoritma optimasi Adam. Adam adalah metode penurunan gradien stokastik yang menghitung kecepatan pembelajaran adaptif individu untuk parameter berbeda dari perkiraan momen gradien orde pertama dan kedua.

Referensi: “Adam: Metode Optimasi Stokastik” (Kingma dan Ba, 2014).

Contoh:

Latih agen pembelajaran penguatan sederhana:

...
// Instantiate an agent's policy - approximated by the neural network (`net`) after defining it 
in advance.
var net = Net(observationSize: Int(observationSize), hiddenSize: hiddenSize, actionCount: actionCount)
// Define the Adam optimizer for the network with a learning rate set to 0.01.
let optimizer = Adam(for: net, learningRate: 0.01)
...
// Begin training the agent (over a certain number of episodes).
while true {
...
    // Implementing the gradient descent with the Adam optimizer:
    // Define the gradients (use withLearningPhase to call a closure under a learning phase).
    let gradients = withLearningPhase(.training) {
        TensorFlow.gradient(at: net) { net -> Tensor<Float> in
            // Return a softmax (loss) function
            return loss = softmaxCrossEntropy(logits: net(input), probabilities: target)
        }
    }
    // Update the differentiable variables of the network (`net`) along the gradients with the Adam 
optimizer.
    optimizer.update(&net, along: gradients)
    ...
    }
}

Latih jaringan permusuhan generatif (GAN):

...
// Instantiate the generator and the discriminator networks after defining them.
var generator = Generator()
var discriminator = Discriminator()
// Define the Adam optimizers for each network with a learning rate set to 2e-4 and beta1 - to 0.5.
let adamOptimizerG = Adam(for: generator, learningRate: 2e-4, beta1: 0.5)
let adamOptimizerD = Adam(for: discriminator, learningRate: 2e-4, beta1: 0.5)
...
Start the training loop over a certain number of epochs (`epochCount`).
for epoch in 1...epochCount {
    // Start the training phase.
    ...
    for batch in trainingShuffled.batched(batchSize) {
        // Implementing the gradient descent with the Adam optimizer:
        // 1) Update the generator.
        ...
        let 𝛁generator = TensorFlow.gradient(at: generator) { generator -> Tensor<Float> in
            ...
            return loss
            }
        // Update the differentiable variables of the generator along the gradients (`𝛁generator`) 
        // with the Adam optimizer.
        adamOptimizerG.update(&generator, along: 𝛁generator)

        // 2) Update the discriminator.
        ...
        let 𝛁discriminator = TensorFlow.gradient(at: discriminator) { discriminator -> Tensor<Float> in
            ...
            return loss
        }
        // Update the differentiable variables of the discriminator along the gradients (`𝛁discriminator`) 
        // with the Adam optimizer.
        adamOptimizerD.update(&discriminator, along: 𝛁discriminator)
        }
}

Pernyataan

public class Adam<Model: Differentiable>: Optimizer
where
  Model.TangentVector: VectorProtocol & PointwiseMultiplicative
    & ElementaryFunctions & KeyPathIterable,
  Model.TangentVector.VectorSpaceScalar == Float

AdaMax

Pengoptimal AdaMax.

Varian Adam berdasarkan norma tak terhingga.

Referensi: Bagian 7 dari “Adam - Metode Optimasi Stokastik”

Pernyataan

public class AdaMax<Model: Differentiable & KeyPathIterable>: Optimizer
where
  Model.TangentVector: VectorProtocol & PointwiseMultiplicative & ElementaryFunctions
    & KeyPathIterable,
  Model.TangentVector.VectorSpaceScalar == Float

Lulusan AMS

Pengoptimal AMSGrad.

Algoritma ini merupakan modifikasi dari Adam dengan sifat konvergensi yang lebih baik bila mendekati local optima.

Referensi: “Tentang Konvergensi Adam dan Sesudahnya”

Pernyataan

public class AMSGrad<Model: Differentiable & KeyPathIterable>: Optimizer
where
  Model.TangentVector: VectorProtocol & PointwiseMultiplicative & ElementaryFunctions
    & KeyPathIterable,
  Model.TangentVector.VectorSpaceScalar == Float

RAdam

Pengoptimal RAdam.

Rectified Adam, varian Adam yang memperkenalkan istilah untuk memperbaiki varian kecepatan pembelajaran adaptif.

Referensi: “Tentang Varians Kecepatan Pembelajaran Adaptif dan Lebih Lanjutnya”

Pernyataan

public class RAdam<Model: Differentiable>: Optimizer
where
  Model.TangentVector: VectorProtocol & PointwiseMultiplicative & ElementaryFunctions
    & KeyPathIterable,
  Model.TangentVector.VectorSpaceScalar == Float

Zaman Pelatihan Tidak Seragam
Urutan kumpulan sampel yang tak terbatas yang cocok untuk melatih DNN ketika ukuran sampel tidak seragam.
Batch di setiap epoch:
- semuanya mempunyai jumlah sampel yang sama persis.
- terbentuk dari sampel dengan ukuran yang sama.
- mulai dengan batch yang ukuran sampel maksimumnya adalah ukuran maksimum dari semua sampel yang digunakan dalam epoch tersebut.
Pernyataan
public final class NonuniformTrainingEpochs< Samples: Collection, Entropy: RandomNumberGenerator >: Sequence, IteratorProtocol
Pengoptimal Umum
Pengoptimal umum yang harus mampu mengungkapkan beberapa kemungkinan pengoptimalan. Pengoptimal terdiri dari pemetaan dari ParameterGroup ke ParameterGroupOptimizer. Pengoptimal ini juga berisi jumlah elemen yang bekerja dalam jumlah replika silang. Hal ini untuk efisiensi guna mencegah beberapa iterasi yang tidak efisien pada gradien.
Pernyataan
public class GeneralOptimizer<Model: EuclideanDifferentiable>: Optimizer where Model.TangentVector: VectorProtocol & ElementaryFunctions & KeyPathIterable, Model.TangentVector.VectorSpaceScalar == Float
SGD
Pengoptimal penurunan gradien stokastik (SGD).
Menerapkan algoritme penurunan gradien stokastik dengan dukungan momentum, peluruhan kecepatan pembelajaran, dan momentum Nesterov. Momentum dan momentum Nesterov (alias metode gradien akselerasi Nesterov) adalah metode pengoptimalan orde pertama yang dapat meningkatkan kecepatan pelatihan dan laju konvergensi penurunan gradien.
Referensi:
- “Metode Pendekatan Stokastik” (Robbins dan Monro, 1951)
- “Tentang Metode Pendekatan Stokastik Robbins dan Monro” (Wolfowitz, 1952)
- “Estimasi Stokastik Maksimum Fungsi Regresi” (Kiefer dan Wolfowitz, 1952)
- “Beberapa metode untuk mempercepat konvergensi metode iterasi” (Polyak, 1964)
- “Sebuah metode untuk masalah minimisasi cembung tak terbatas dengan laju konvergensi” (Nesterov, 1983)
Pernyataan
public class SGD<Model: Differentiable>: Optimizer where Model.TangentVector: VectorProtocol & ElementaryFunctions & KeyPathIterable, Model.TangentVector.VectorSpaceScalar == Float
Zaman Pelatihan
Urutan kumpulan sampel batch yang tak terbatas yang cocok untuk melatih DNN ketika sampelnya seragam.
Batch di setiap epoch semuanya memiliki ukuran yang persis sama.
Pernyataan
public final class TrainingEpochs< Samples: Collection, Entropy: RandomNumberGenerator >: Sequence, IteratorProtocol
Antrean EpochPipeline
Pernyataan
public class EpochPipelineQueue

Status Utas

Status loop pelatihan pada perangkat.

Pernyataan

public class ThreadState<Model: Layer, Opt: Optimizer>
where
  Opt.Model == Model, Opt.Scalar == Float, Model.Input == Tensor<Float>,
  Model.Output == Tensor<Float>,
  Model.TangentVector.VectorSpaceScalar == Float