Corsi

Un riferimento mutevole, condivisibile, proprietario di un tensore.

Classe che racchiude un puntatore C in un TensorHandle. Questa classe possiede TensorHandle ed è responsabile della sua distruzione.

Un ottimizzatore RMSProp.

Implementa l'algoritmo di ottimizzazione RMSProp. RMSProp è una forma di discesa del gradiente stocastica in cui i gradienti sono divisi per una media corrente della loro grandezza recente. RMSProp mantiene una media mobile del gradiente quadrato per ciascun peso.

Riferimenti:

• "Lezione 6.5 - rmsprop: dividere il gradiente per una media progressiva della sua grandezza recente" (Tieleman e Hinton, 2012)
• "Generazione di sequenze con reti neurali ricorrenti" (Graves, 2013)

Un ottimizzatore AdaGrad.

Implementa l'algoritmo di ottimizzazione AdaGrad (gradiente adattivo). AdaGrad ha tassi di apprendimento specifici per i parametri, che sono adattati in base alla frequenza con cui i parametri vengono aggiornati durante la formazione. I parametri che ricevono più aggiornamenti hanno tassi di apprendimento inferiori.

AdaGrad adatta individualmente i tassi di apprendimento di tutti i parametri del modello ridimensionandoli in modo inversamente proporzionale alla radice quadrata della somma parziale dei quadrati delle norme del gradiente.

Riferimento: "Metodi dei sottogradienti adattivi per l'apprendimento online e l'ottimizzazione stocastica" (Duchi et al, 2011)

Un ottimizzatore AdaDelta.

Implementa l'algoritmo di ottimizzazione AdaDelta. AdaDelta è un metodo di discesa del gradiente stocastico basato sulle informazioni del primo ordine. Adatta i tassi di apprendimento in base a una finestra mobile di aggiornamenti dei gradienti, invece di accumulare tutti i gradienti passati. Pertanto, AdaDelta continua ad apprendere anche dopo aver effettuato numerosi aggiornamenti. Si adatta più velocemente alle mutevoli dinamiche dello spazio problematico di ottimizzazione.

Riferimento: "ADADELTA: un metodo di tasso di apprendimento adattivo" (Zeiler, 2012)

Ottimizzatore di Adam.

Implementa l'algoritmo di ottimizzazione di Adam. Adam è un metodo stocastico di discesa del gradiente che calcola i tassi di apprendimento adattivo individuali per diversi parametri dalle stime dei momenti di primo e secondo ordine dei gradienti.

Riferimento: "Adam: un metodo per l'ottimizzazione stocastica" (Kingma e Ba, 2014).

Esempi:

• Formare un semplice agente di apprendimento per rinforzo:

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

• Formare una rete avversaria generativa (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)
        }
}       

Ottimizzatore AdaMax.

Una variante di Adamo basata sulla norma dell'infinito.

Riferimento: Sezione 7 di "Adam - Un metodo per l'ottimizzazione stocastica"

Ottimizzatore AMSGrad.

Questo algoritmo è una modifica di Adam con migliori proprietà di convergenza quando è vicino all'ottimale locale.

Riferimento: “Sulla convergenza di Adamo e oltre”

Ottimizzatore RAdam.

Adam rettificato, una variante di Adam che introduce un termine per rettificare la varianza del tasso di apprendimento adattivo.

Riferimento: “Sulla varianza del tasso di apprendimento adattivo e oltre”

Una sequenza infinita di raccolte di lotti di campioni adatta per addestrare una DNN quando i campioni non hanno dimensioni uniformi.

I lotti in ogni epoca:

• hanno tutti esattamente lo stesso numero di campioni.
• sono formati da campioni di dimensioni simili.
• iniziare con un lotto la cui dimensione massima del campione è la dimensione massima di tutti i campioni utilizzati nell'epoca.

Ottimizzatore generale che dovrebbe essere in grado di esprimere molteplici ottimizzazioni possibili. L'ottimizzatore è composto da una mappatura da ParametroGroup a ParametroGroupOptimizer. Questo ottimizzatore contiene anche il numero di elementi che lavorano in una somma di repliche incrociate. Questo serve per l'efficienza per prevenire più iterazioni inefficienti sul gradiente.

Un ottimizzatore di discesa del gradiente stocastico (SGD).

Implementa l'algoritmo di discesa del gradiente stocastico con supporto per lo slancio, il decadimento del tasso di apprendimento e lo slancio di Nesterov. Il momento e il momento di Nesterov (noto anche come metodo del gradiente accelerato di Nesterov) sono metodi di ottimizzazione del primo ordine che possono migliorare la velocità di allenamento e il tasso di convergenza della discesa del gradiente.

Riferimenti:

• “Un metodo di approssimazione stocastica” (Robbins e Monro, 1951)
• “Sul metodo dell’approssimazione stocastica di Robbins e Monro” (Wolfowitz, 1952)
• “Stima stocastica del massimo di una funzione di regressione” (Kiefer e Wolfowitz, 1952)
• "Alcuni metodi per accelerare la convergenza del metodo di iterazione" (Polyak, 1964)
• “Un metodo per problemi di minimizzazione convessa non vincolata con velocità di convergenza” (Nesterov, 1983)

Una sequenza infinita di raccolte di campioni batch adatte all'addestramento di una DNN quando i campioni sono uniformi.

I lotti di ciascuna epoca hanno tutti esattamente la stessa dimensione.

Lo stato di un ciclo di addestramento su un dispositivo.