Aulas

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

Classe envolvendo 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 quadrático para cada peso.

Referências:

• “Aula 6.5 - rmsprop: Divida o gradiente por uma média contínua de sua magnitude recente” (Tieleman e Hinton, 2012)
• “Gerando sequências com redes neurais recorrentes” (Graves, 2013)

Um otimizador AdaGrad.

Implementa o algoritmo de otimização AdaGrad (gradiente adaptativo). AdaGrad possui 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. Parâmetros que recebem mais atualizações apresentam taxas de aprendizado menores.

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

Referência: “Métodos Adaptativos de Subgradiente para Aprendizagem Online e Otimização Estocástica” (Duchi et al, 2011)

Um otimizador AdaDelta.

Implementa o algoritmo de otimização AdaDelta. AdaDelta é um método estocástico de descida gradiente baseado em 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, o AdaDelta continua aprendendo mesmo depois de muitas atualizações terem sido feitas. Ele se adapta mais rapidamente às mudanças na dinâmica do espaço do problema de otimização.

Referência: “ADADELTA: Um método de taxa de aprendizagem adaptativa” (Zeiler, 2012)

Otimizador Adam.

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

Referência: “Adam: Um Método para Otimização Estocástica” (Kingma e Ba, 2014).

Exemplos:

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

...
// 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 adversária 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: Seção 7 de “Adam - Um Método para Otimização Estocástica”

Otimizador AMSGrad.

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

Referência: “Sobre a Convergência de Adão e Além”

Otimizador RAdam.

Adam retificado, uma variante de Adam que introduz um termo para retificar a variação da taxa de aprendizagem adaptativa.

Referência: “Sobre a variação da taxa de aprendizagem adaptativa e além”

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

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 seja o tamanho máximo de todas as amostras usadas na época.

Otimizador geral que deve ser capaz de expressar múltiplas otimizações possíveis. O otimizador é composto por um mapeamento de ParameterGroup para ParameterGroupOptimizer. Este otimizador também contém o número de elementos trabalhando em uma soma de réplicas cruzadas. Isto é para eficiência, evitando múltiplas iterações ineficientes ao longo do gradiente.

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

Implementa o algoritmo estocástico de descida de gradiente com suporte para impulso, queda da taxa de aprendizagem e impulso de Nesterov. Momentum e Nesterov momentum (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)
• “Sobre o Método de Aproximação Estocástica de Robbins e Monro” (Wolfowitz, 1952)
• “Estimativa estocástica do máximo de uma função de regressão” (Kiefer e Wolfowitz, 1952)
• “Alguns métodos para acelerar a convergência do método de iteração” (Polyak, 1964)
• “Um método para problema de minimização convexa irrestrita com taxa de convergência” (Nesterov, 1983)

Uma sequência infinita de coleções de amostras em lote adequadas para treinar uma 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.