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

  • Kelas membungkus pointer C ke TensorHandle. Kelas ini memiliki TensorHandle dan bertanggung jawab untuk menghancurkannya.

    Pernyataan

    public class TFETensorHandle : _AnyTensorHandle
    extension TFETensorHandle: Equatable

  • 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:

    Pernyataan

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

  • 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

  • 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

  • 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

  • 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

  • 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

  • Pengoptimal RAdam.

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

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

    Pernyataan

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

  • 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 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:

    Pernyataan

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

  • 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

  • Pernyataan

    public class EpochPipelineQueue

  • 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