אדם

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

אדם אופטימיזציה.

מיישם את אלגוריתם האופטימיזציה של Adam. אדם היא שיטת השתלשלות גרדיאנט סטוכסטית המחשבת שיעורי למידה אדפטיבית אינדיבידואלית עבור פרמטרים שונים מתוך הערכות של רגעים מסדר ראשון ושני של הגרדיאנטים.

התייחסות: "אדם: שיטה לאופטימיזציה סטוכסטית" (Kingma and Ba, 2014).

דוגמאות:

• אמן סוכן למידה פשוט לחיזוק:

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

• אימון רשת יריבות יצירתית (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)
        }
}       

• דֶגֶם
  הַצהָרָה

  public typealias Model = Model

• קצב למידה
  קצב הלמידה.

  הַצהָרָה

  public var learningRate: Float

• בטא1
  מקדם המשמש לחישוב הרגעים הראשונים של השיפועים.

  הַצהָרָה

  public var beta1: Float

• בטא2
  מקדם המשמש לחישוב הרגעים השניים של השיפועים.

  הַצהָרָה

  public var beta2: Float

• אפסילון
  סקלאר קטן נוסף למכנה כדי לשפר את היציבות המספרית.

  הַצהָרָה

  public var epsilon: Float

• לִדעוֹך
  קצב הלמידה דעיכה.

  הַצהָרָה

  public var decay: Float

• שָׁלָב
  השלב הנוכחי.

  הַצהָרָה

  public var step: Int

• firstMoments
  הרגעים הראשונים של המשקולות.

  הַצהָרָה

  public var firstMoments: Model.TangentVector

• secondMoments
  הרגעים השניים של המשקולות.

  הַצהָרָה

  public var secondMoments: Model.TangentVector

• init(for:learningRate:beta1:beta2:epsilon:decay:)
  הַצהָרָה

  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
  )

  פרמטרים

  learningRate	קצב הלמידה. ערך ברירת המחדל הוא 1e-3 .
  beta1	קצב הדעיכה האקספוננציאלי עבור הערכות הרגע הראשון. ערך ברירת המחדל הוא 0.9 .
  beta2	קצב הדעיכה האקספוננציאלי עבור הערכות הרגע השני. ערך ברירת המחדל הוא 0.999 .
  epsilon	סקלאר קטן נוסף למכנה כדי לשפר את היציבות המספרית. ערך ברירת המחדל הוא 1e-8 .
  decay	קצב הלמידה דעיכה. ערך ברירת המחדל הוא 0 .

• עדכון(_:לצד:)
  הַצהָרָה

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

• init(copying:to:)
  הַצהָרָה

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