Adán

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

Optimizador de Adam.

Implementa el algoritmo de optimización de Adam. Adam es un método de descenso de gradiente estocástico que calcula las tasas de aprendizaje adaptativo individual para diferentes parámetros a partir de estimaciones de momentos de primer y segundo orden de los gradientes.

Referencia: “Adam: Un método para la optimización estocástica” (Kingma y Ba, 2014).

Ejemplos:

• Entrene a un simple agente de aprendizaje por refuerzo:

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

• Entrene una red generativa adversaria (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)
        }
}       

• Modelo

  Declaración

  public typealias Model = Model

• tasa de aprendizaje

  La tasa de aprendizaje.

  Declaración

  public var learningRate: Float

• beta1

  Coeficiente utilizado para calcular los primeros momentos de los gradientes.

  Declaración

  public var beta1: Float

• beta2

  Un coeficiente utilizado para calcular los segundos momentos de los gradientes.

  Declaración

  public var beta2: Float

• épsilon

  Un pequeño escalar agregado al denominador para mejorar la estabilidad numérica.

  Declaración

  public var epsilon: Float

• decaer

  La tasa de aprendizaje decae.

  Declaración

  public var decay: Float

• paso

  El paso actual.

  Declaración

  public var step: Int

• firstMoments

  Los primeros momentos de los pesos.

  Declaración

  public var firstMoments: Model.TangentVector

• secondMoments

  Los segundos momentos de los pesos.

  Declaración

  public var secondMoments: Model.TangentVector

• init (para: learningRate: beta1: beta2: epsilon: decay :)

  Declaración

  public init(
    for model: __shared Model,
    learningRate: Float = 1e-3,
    beta1: Float = 0.9,
    beta2: Float = 0.999,
    epsilon: Float = 1e-8,
    decay: Float = 0
  )

  Parámetros

  learningRate	La tasa de aprendizaje. El valor predeterminado es 1e-3 .
  beta1	La tasa de caída exponencial para las estimaciones del primer momento. El valor predeterminado es 0.9 .
  beta2	La tasa de caída exponencial para las estimaciones del segundo momento. El valor por defecto es 0.999 .
  epsilon	Un pequeño escalar agregado al denominador para mejorar la estabilidad numérica. El valor por defecto es 1e-8 .
  decay	La tasa de aprendizaje decae. El valor por defecto es 0 .

• actualizar (_: a lo largo :)

  Declaración

  public func update(_ model: inout Model, along direction: Model.TangentVector)

• init (copiando: a :)

  Declaración

  public required init(copying other: Adam, to device: Device)