Classes

Une référence mutable, partageable et propriétaire à un tenseur.

Classe encapsulant un pointeur C vers un TensorHandle. Cette classe possède le TensorHandle et est responsable de sa destruction.

Un optimiseur RMSProp.

Implémente l'algorithme d'optimisation RMSProp. RMSProp est une forme de descente de gradient stochastique où les gradients sont divisés par une moyenne mobile de leur ampleur récente. RMSProp conserve une moyenne mobile du carré du gradient pour chaque poids.

Références :

• « Cours 6.5 - rmsprop : Divisez le gradient par une moyenne mobile de son ampleur récente » (Tieleman et Hinton, 2012)
• «Générer des séquences avec des réseaux de neurones récurrents» (Graves, 2013)

Un optimiseur AdaGrad.

Implémente l'algorithme d'optimisation AdaGrad (gradient adaptatif). AdaGrad propose des taux d'apprentissage spécifiques aux paramètres, qui sont adaptés en fonction de la fréquence à laquelle les paramètres sont mis à jour pendant la formation. Les paramètres qui reçoivent davantage de mises à jour ont des taux d'apprentissage plus faibles.

AdaGrad adapte individuellement les taux d'apprentissage de tous les paramètres du modèle en les mettant à l'échelle inversement proportionnelle à la racine carrée de la somme courante des carrés des normes de gradient.

Référence : « Méthodes adaptatives de sous-gradient pour l'apprentissage en ligne et l'optimisation stochastique » (Duchi et al, 2011)

Un optimiseur AdaDelta.

Implémente l'algorithme d'optimisation AdaDelta. AdaDelta est une méthode de descente de gradient stochastique basée sur les informations du premier ordre. Il adapte les taux d'apprentissage en fonction d'une fenêtre mobile de mises à jour des dégradés, au lieu d'accumuler tous les dégradés passés. Ainsi, AdaDelta continue d'apprendre même lorsque de nombreuses mises à jour ont été effectuées. Il s'adapte plus rapidement à la dynamique changeante de l'espace des problèmes d'optimisation.

Référence : « ADADELTA : Une méthode de taux d'apprentissage adaptatif » (Zeiler, 2012)

Optimiseur Adam.

Implémente l'algorithme d'optimisation Adam. Adam est une méthode de descente de gradient stochastique qui calcule les taux d'apprentissage adaptatifs individuels pour différents paramètres à partir d'estimations des moments de premier et de second ordre des gradients.

Référence : « Adam : Une méthode d'optimisation stochastique » (Kingma et Ba, 2014).

Exemples :

• Former un agent d'apprentissage par renforcement simple :

...
// 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)
    ...
    }
}

• Former un réseau contradictoire génératif (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)
        }
}       

Optimiseur AdaMax.

Une variante d'Adam basée sur la norme de l'infini.

Référence : Section 7 de « Adam - Une méthode d'optimisation stochastique »

Optimiseur AMSGrad.

Cet algorithme est une modification d'Adam avec de meilleures propriétés de convergence lorsqu'il est proche des optimums locaux.

Référence : « Sur la convergence d’Adam et au-delà »

Optimiseur RAdam.

Adam rectifié, une variante d'Adam qui introduit un terme pour rectifier la variance du taux d'apprentissage adaptatif.

Référence : « Sur la variance du taux d'apprentissage adaptatif et au-delà »

Une séquence infinie de collections de lots d'échantillons adaptée à la formation d'un DNN lorsque les échantillons ne sont pas de taille uniforme.

Les lots à chaque époque :

• tous ont exactement le même nombre d’échantillons.
• sont formés à partir d’échantillons de taille similaire.
• commencez par un lot dont la taille maximale de l’échantillon est la taille maximale de tous les échantillons utilisés à l’époque.

Optimiseur général qui doit être capable d'exprimer plusieurs optimisations possibles. L'optimiseur est composé d'un mappage de ParameterGroup vers ParameterGroupOptimizer. Cet optimiseur contient également le nombre d'éléments travaillant dans une somme de répliques croisées. C'est pour des raisons d'efficacité afin d'éviter plusieurs itérations inefficaces sur le dégradé.

Un optimiseur de descente de gradient stochastique (SGD).

Implémente l'algorithme de descente de gradient stochastique avec prise en charge de l'élan, de la décroissance du taux d'apprentissage et de l'élan de Nesterov. L'élan et l'élan Nesterov (alias la méthode du gradient accéléré Nesterov) sont des méthodes d'optimisation de premier ordre qui peuvent améliorer la vitesse d'entraînement et le taux de convergence de la descente du gradient.

Références :

• « Une méthode d'approximation stochastique » (Robbins et Monro, 1951)
• « Sur la méthode d'approximation stochastique de Robbins et Monro » (Wolfowitz, 1952)
• « Estimation stochastique du maximum d'une fonction de régression » (Kiefer et Wolfowitz, 1952)
• «Quelques méthodes pour accélérer la convergence de la méthode d'itération» (Polyak, 1964)
• « Une méthode pour un problème de minimisation convexe sans contrainte avec le taux de convergence » (Nesterov, 1983)

Une séquence infinie de collections d'échantillons par lots adaptée à la formation d'un DNN lorsque les échantillons sont uniformes.

Les lots de chaque époque ont tous exactement la même taille.

L’état d’une boucle d’entraînement sur un appareil.