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 optimize edici.

    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şturulur.
    • 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 yinelemenin önlenmesi için verimlilik amaçlıdır.

    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