Sınıflar

Aşağıdaki sınıflar global olarak mevcuttur.

  • Bir tensöre yönelik değiştirilebilir, paylaşılabilir, sahiplik referansı.

    beyan

    public final class Parameter<Scalar> where Scalar : TensorFlowScalar
    extension Parameter: CopyableToDevice
  • Bir C işaretçisini TensorHandle'a saran sınıf. Bu sınıf TensorHandle'ın sahibidir ve onu yok etmekten sorumludur.

    beyan

    public class TFETensorHandle : _AnyTensorHandle
    extension TFETensorHandle: Equatable
  • Bir RMSProp optimize edici.

    RMSProp optimizasyon algoritmasını uygular. RMSProp, gradyanların güncel büyüklüklerinin devam eden ortalamasına bölündüğü bir stokastik gradyan iniş biçimidir. RMSProp, her ağırlık için kare degradenin hareketli ortalamasını tutar.

    Referanslar:

    beyan

    public class RMSProp<Model: Differentiable>: Optimizer
    where
      Model.TangentVector: VectorProtocol & PointwiseMultiplicative
        & ElementaryFunctions & KeyPathIterable,
      Model.TangentVector.VectorSpaceScalar == Float
  • Bir AdaGrad iyileştirici.

    AdaGrad (uyarlanabilir degrade) optimizasyon algoritmasını uygular. AdaGrad, eğitim sırasında parametrelerin ne sıklıkta güncellendiğine göre uyarlanan, parametreye özel öğrenme oranlarına sahiptir. Daha fazla güncelleme alan parametrelerin öğrenme oranları daha düşüktür.

    AdaGrad, tüm model parametrelerinin öğrenme oranlarını, bunları gradyan normlarının karelerinin toplamının kareköküyle ters orantılı olarak ölçeklendirerek ayrı ayrı uyarlar.

    Referans: “Çevrimiçi Öğrenme ve Stokastik Optimizasyon için Uyarlanabilir Alt Derecelendirme Yöntemleri” (Duchi ve diğerleri, 2011)

    beyan

    public class AdaGrad<Model: Differentiable>: Optimizer
    where
      Model.TangentVector: VectorProtocol & PointwiseMultiplicative
        & ElementaryFunctions & KeyPathIterable,
      Model.TangentVector.VectorSpaceScalar == Float
  • Bir AdaDelta optimize edici.

    AdaDelta optimizasyon algoritmasını uygular. AdaDelta, birinci dereceden bilgiye dayanan stokastik bir gradyan iniş yöntemidir. Öğrenme oranlarını, geçmiş tüm degradeleri biriktirmek yerine, hareketli bir degrade güncellemeleri penceresine göre uyarlar. Böylece AdaDelta birçok güncelleme yapılsa bile öğrenmeye devam ediyor. Optimizasyon problem alanının değişen dinamiklerine daha hızlı uyum sağlar.

    Referans: “ADADELTA: Uyarlanabilir Bir Öğrenme Oranı Yöntemi” (Zeiler, 2012)

    beyan

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

    Adam optimizasyon algoritmasını uygular. Adam, gradyanların birinci ve ikinci dereceden momentlerinin tahminlerinden farklı parametreler için bireysel uyarlanabilir öğrenme oranlarını hesaplayan stokastik bir gradyan iniş yöntemidir.

    Referans: “Adam: Stokastik Optimizasyon İçin Bir Yöntem” (Kingma ve Ba, 2014).

    Örnekler:

    • Basit bir takviyeli öğrenme aracısını eğitin:
    ...
    // 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)
        ...
        }
    }
    
    • Üretken bir rakip ağı (GAN) eğitin:
    ...
    // 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)
            }
    }       
    

    beyan

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

    Adem'in sonsuzluk normuna dayalı bir çeşidi.

    Referans: “Adam - Stokastik Optimizasyon İçin Bir Yöntem” Bölüm 7

    beyan

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

    Bu algoritma, yerel optimuma yakın olduğunda daha iyi yakınsama özelliklerine sahip olan Adam'ın bir modifikasyonudur.

    Referans: “Adem ve Ötesinin Yakınsaması Üzerine”

    beyan

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

    Düzeltilmiş Adam, Uyarlanabilir öğrenme oranı farklılığını düzeltmek için bir terim sunan Adam'ın bir çeşidi.

    Referans: “Uyarlanabilir Öğrenme Oranının Varyansı ve Ötesi Üzerine”

    beyan

    public class RAdam<Model: Differentiable>: Optimizer
    where
      Model.TangentVector: VectorProtocol & PointwiseMultiplicative & ElementaryFunctions
        & KeyPathIterable,
      Model.TangentVector.VectorSpaceScalar == Float
  • Numuneler eşit boyutta olmadığında bir DNN'yi eğitmek için uygun olan numune partilerinin sonsuz bir koleksiyonudur.

    Her dönemdeki partiler:

    • hepsinde tam olarak aynı sayıda örnek var.
    • Benzer büyüklükteki örneklerden oluşur.
    • Maksimum örnek boyutu, çağda kullanılan tüm örneklerin maksimum boyutu olan bir partiyle başlayın.

    beyan

    public final class NonuniformTrainingEpochs<
      Samples: Collection,
      Entropy: RandomNumberGenerator
    >: Sequence, IteratorProtocol
  • Birden fazla olası optimizasyonu ifade edebilmesi gereken genel optimizer. Optimize edici, ParameterGroup'tan ParameterGroupOptimizer'a bir eşlemeden oluşur. Bu optimize edici aynı zamanda çapraz kopya toplamında çalışan öğelerin sayısını da içerir. Bu, degrade üzerinde birden fazla verimsiz yinelemeyi önlemek için verimlilik içindir.

    beyan

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

    Stokastik bir gradyan iniş (SGD) iyileştiricisi.

    Momentum, öğrenme hızı azalması ve Nesterov momentumu desteğiyle stokastik gradyan iniş algoritmasını uygular. Momentum ve Nesterov momentumu (diğer adıyla Nesterov hızlandırılmış gradyan yöntemi), gradyan inişinin eğitim hızını ve yakınsama oranını artırabilen birinci dereceden optimizasyon yöntemleridir.

    Referanslar:

    beyan

    public class SGD<Model: Differentiable>: Optimizer
    where
      Model.TangentVector: VectorProtocol & ElementaryFunctions & KeyPathIterable,
      Model.TangentVector.VectorSpaceScalar == Float
  • Numuneler tekdüze olduğunda bir DNN'yi eğitmeye uygun toplu numune koleksiyonlarının sonsuz dizisi.

    Her dönemdeki partilerin tümü tam olarak aynı boyuta sahiptir.

    beyan

    public final class TrainingEpochs<
      Samples: Collection,
      Entropy: RandomNumberGenerator
    >: Sequence, IteratorProtocol
  • beyan

    public class EpochPipelineQueue
  • Bir cihazdaki eğitim döngüsünün durumu.

    beyan

    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