Aulas

Uma referência mutável, compartilhável e proprietária de um tensor.

Classe que envolve um ponteiro C para um TensorHandle. Esta classe possui o TensorHandle e é responsável por destruí-lo.

Um otimizador RMSProp.

Implementa o algoritmo de otimização RMSProp. RMSProp é uma forma de descida gradiente estocástica onde os gradientes são divididos por uma média contínua de sua magnitude recente. RMSProp mantém uma média móvel do gradiente quadrado para cada peso.

Referências:

• “Palestra 6.5 - rmsprop: Divida o gradiente por uma média de execução da sua recente magnitude” (Tieleman e Hinton, 2012)
• “Gerando sequências com Recurrent Neural Networks” (Graves, 2013)

Um otimizador AdaGrad.

Implementa o algoritmo de otimização AdaGrad (gradiente adaptativo). O AdaGrad tem taxas de aprendizagem específicas de parâmetros, que são adaptadas em relação à frequência com que os parâmetros são atualizados durante o treinamento. Os parâmetros que recebem mais atualizações têm taxas de aprendizado menores.

O AdaGrad adapta individualmente as taxas de aprendizagem de todos os parâmetros do modelo, escalando-os inversamente proporcionais à raiz quadrada da soma contínua dos quadrados das normas de gradiente.

Referência: “Adaptive Métodos subgradiente para a aprendizagem online e estocásticos de otimização” (Duchi et al, 2011)

Um otimizador AdaDelta.

Implementa o algoritmo de otimização AdaDelta. AdaDelta é um método de descida gradiente estocástico baseado nas informações de primeira ordem. Ele adapta as taxas de aprendizagem com base em uma janela móvel de atualizações de gradiente, em vez de acumular todos os gradientes anteriores. Assim, AdaDelta continua aprendendo mesmo quando muitas atualizações foram feitas. Ele se adapta mais rápido às mudanças na dinâmica do espaço do problema de otimização.

Referência: “ADADELTA: Um Adaptive aprendizagem Método Rate” (Zeiler, 2012)

Otimizador de Adam.

Implementa o algoritmo de otimização de Adam. Adam é um método de descida gradiente estocástico que calcula taxas de aprendizagem adaptativa individuais para diferentes parâmetros de estimativas de momentos de primeira e segunda ordem dos gradientes.

Referência: “Adam: Um método para Stochastic Optimization” (Kingma e Ba, 2014).

Exemplos:

• Treine um agente de aprendizagem por reforço simples:

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

• Treine uma rede adversarial 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)
        }
}       

Otimizador AdaMax.

Uma variante de Adão baseada na norma do infinito.

Referência: Secção 7 do “Adam - Um método para Stochastic Otimização”

Otimizador AMSGrad.

Este algoritmo é uma modificação de Adam com melhores propriedades de convergência quando próximo a ótimos locais.

Referência: “na convergência de Adam and Beyond”

Otimizador RAdam.

Adam retificado, uma variante de Adam que introduz um termo para retificar a variância da taxa de aprendizagem adaptativa.

Referência: “On a variância da Adaptive Aprendizagem Taxa and Beyond”

Uma sequência infinita de coleções de lotes de amostras adequadas para treinar um DNN quando as amostras não são uniformemente dimensionadas.

Os lotes em cada época:

• todos têm exatamente o mesmo número de amostras.
• são formados a partir de amostras de tamanho semelhante.
• comece com um lote cujo tamanho máximo de amostra é o tamanho máximo de todas as amostras usadas na época.

Otimizador geral que deve ser capaz de expressar várias otimizações possíveis. O otimizador é composto de um mapeamento de ParameterGroup para ParameterGroupOptimizer. Este otimizador também contém o número de elementos trabalhando em uma soma de réplica cruzada. Isso é para eficiência para evitar várias iterações ineficientes no gradiente.

Um otimizador de descida gradiente estocástico (SGD).

Implementa o algoritmo de descida gradiente estocástico com suporte para momentum, diminuição da taxa de aprendizagem e momentum de Nesterov. Momentum e momentum de Nesterov (também conhecido como método de gradiente acelerado de Nesterov) são métodos de otimização de primeira ordem que podem melhorar a velocidade de treinamento e a taxa de convergência da descida do gradiente.

Referências:

• “Um método de aproximação estocástica” (Robbins e Monro, 1951)
• “No estocástico método de aproximação de Robbins e Monro” (Wolfowitz, 1952)
• “Estocástico Estimativa do máximo de uma função de regressão” (Kiefer e Wolfowitz, 1952)
• “Alguns métodos de acelerar a convergência do método de iteração” (Polyak, 1964)
• “Um método para irrestrita problema convexa minimização com a taxa de convergência” (Nesterov, 1983)

Uma sequência infinita de coleções de amostras de lote adequadas para treinar um DNN quando as amostras são uniformes.

Todos os lotes em cada época têm exatamente o mesmo tamanho.

O estado de um loop de treinamento em um dispositivo.