Aulas

As classes a seguir estão disponíveis globalmente.

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

    Declaração 

    public final class Parameter<Scalar> where Scalar : TensorFlowScalar
    extension Parameter: CopyableToDevice

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

    Declaração 

    public class TFETensorHandle : _AnyTensorHandle
    extension TFETensorHandle: Equatable

  • 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:

    Declaração 

    public class RMSProp<Model: Differentiable>: Optimizer
where
  Model.TangentVector: VectorProtocol & PointwiseMultiplicative
    & ElementaryFunctions & KeyPathIterable,
  Model.TangentVector.VectorSpaceScalar == Float

  • 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 possuem 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)

    Declaração 

    public class AdaGrad<Model: Differentiable>: Optimizer
where
  Model.TangentVector: VectorProtocol & PointwiseMultiplicative
    & ElementaryFunctions & KeyPathIterable,
  Model.TangentVector.VectorSpaceScalar == Float

  • 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)

    Declaração 

    public class AdaDelta<Model: Differentiable>: Optimizer
where
  Model.TangentVector: VectorProtocol & PointwiseMultiplicative
    & ElementaryFunctions & KeyPathIterable,
  Model.TangentVector.VectorSpaceScalar == Float

  • 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)
        }
}

    Declaração 

    public class Adam<Model: Differentiable>: Optimizer
where
  Model.TangentVector: VectorProtocol & PointwiseMultiplicative
    & ElementaryFunctions & KeyPathIterable,
  Model.TangentVector.VectorSpaceScalar == Float

  • 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”

    Declaração 

    public class AdaMax<Model: Differentiable & KeyPathIterable>: Optimizer
where
  Model.TangentVector: VectorProtocol & PointwiseMultiplicative & ElementaryFunctions
    & KeyPathIterable,
  Model.TangentVector.VectorSpaceScalar == Float

  • 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”

    Declaração 

    public class AMSGrad<Model: Differentiable & KeyPathIterable>: Optimizer
where
  Model.TangentVector: VectorProtocol & PointwiseMultiplicative & ElementaryFunctions
    & KeyPathIterable,
  Model.TangentVector.VectorSpaceScalar == Float

  • 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”

    Declaração 

    public class RAdam<Model: Differentiable>: Optimizer
where
  Model.TangentVector: VectorProtocol & PointwiseMultiplicative & ElementaryFunctions
    & KeyPathIterable,
  Model.TangentVector.VectorSpaceScalar == Float

  • 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.

    Declaração 

    public final class NonuniformTrainingEpochs<
  Samples: Collection,
  Entropy: RandomNumberGenerator
>: Sequence, IteratorProtocol

  • 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.

    Declaração 

    public class GeneralOptimizer<Model: EuclideanDifferentiable>: Optimizer
where
  Model.TangentVector: VectorProtocol & ElementaryFunctions & KeyPathIterable,
  Model.TangentVector.VectorSpaceScalar == Float
  • SGD

    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:

    Declaração 

    public class SGD<Model: Differentiable>: Optimizer
where
  Model.TangentVector: VectorProtocol & ElementaryFunctions & KeyPathIterable,
  Model.TangentVector.VectorSpaceScalar == Float

  • 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.

    Declaração 

    public final class TrainingEpochs<
  Samples: Collection,
  Entropy: RandomNumberGenerator
>: Sequence, IteratorProtocol

  • Declaração 

    public class EpochPipelineQueue

  • O estado de um loop de treinamento em um dispositivo.

    Declaração 

    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