מחלקות

השיעורים הבאים זמינים ברחבי העולם.

• פָּרָמֶטֶר
  התייחסות ניתנת לשינוי, ניתנת לשיתוף, בעלות על טנזור.

  הַצהָרָה

  public final class Parameter<Scalar> where Scalar : TensorFlowScalar

  extension Parameter: CopyableToDevice

• TFETensorHandle
  כיתה עוטפת מצביע C ל-TensorHandle. מחלקה זו היא הבעלים של TensorHandle והיא אחראית להשמדתו.

  הַצהָרָה

  public class TFETensorHandle : _AnyTensorHandle

  extension TFETensorHandle: Equatable

• RMSProp
  מייעל RMSProp.

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

  הפניות:

  • "הרצאה 6.5 - rmsprop: חלקו את השיפוע בממוצע רץ של הגודל האחרון שלו" (Tieleman and Hinton, 2012)
  • "יצירת רצפים עם רשתות עצביות חוזרות" (גרייבס, 2013)

  הַצהָרָה

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

• אדאגראד
  אופטימיזציית AdaGrad.

  מיישמת את אלגוריתם האופטימיזציה של AdaGrad (הדרגתי אדפטיבית). ל-AdaGrad יש שיעורי למידה ספציפיים לפרמטרים, המותאמים ביחס לתדירות עדכון הפרמטרים במהלך האימון. לפרמטרים שמקבלים יותר עדכונים יש שיעורי למידה קטנים יותר.

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

  התייחסות: "שיטות משנה אדפטיביות ללמידה מקוונת ואופטימיזציה סטוכסטית" (Duchi et al, 2011)

  הַצהָרָה

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

• AdaDelta
  אופטימיזציה של AdaDelta.

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

  התייחסות: "ADADELTA: An Adaptive Learning Rate Method" (זיילר, 2012)

  הַצהָרָה

  public class AdaDelta<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 class Adam<Model: Differentiable>: Optimizer
  where
    Model.TangentVector: VectorProtocol & PointwiseMultiplicative
      & ElementaryFunctions & KeyPathIterable,
    Model.TangentVector.VectorSpaceScalar == Float

• עדמקס
  אופטימיזציית AdaMax.

  גרסה של אדם המבוססת על נורמת האינסוף.

  הפניה: סעיף 7 של "אדם - שיטה לאופטימיזציה סטוכסטית"

  הַצהָרָה

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

• AMSGrad
  מייעל AMSGrad.

  אלגוריתם זה הוא שינוי של אדם עם תכונות התכנסות טובות יותר כשהוא קרוב לאופטימיות מקומית.

  התייחסות: "על ההתכנסות של אדם ומעבר לו"

  הַצהָרָה

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

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

  אדם מתוקן, גרסה של אדם שמציגה מונח לתיקון השונות של שיעור הלמידה האדפטיבית.

  התייחסות: "על השונות של קצב הלמידה ההסתגלותית ומעבר לכך"

  הַצהָרָה

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

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

  המנות בכל תקופה:

  • לכולם יש בדיוק אותו מספר של דוגמאות.
  • נוצרים מדגימות בגודל דומה.
  • התחל עם אצווה שגודל המדגם המקסימלי שלה הוא הגודל המרבי על כל הדגימות ששימשו בתקופה.

  הַצהָרָה

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

• GeneralOptimizer
  אופטימיזציה כללית שאמורה להיות מסוגלת לבטא מספר אופטימיזציות אפשריות. האופטימיזר מורכב ממיפוי מ- ParameterGroup ל- ParameterGroupOptimizer. מייעל זה מכיל גם את מספר האלמנטים הפועלים בסכום העתק צולב. זה נועד ליעילות כדי למנוע איטרציות לא יעילות מרובות על פני השיפוע.

  הַצהָרָה

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

• SGD
  מייעל ירידה בשיפוע סטוכסטי (SGD).

  מיישם את אלגוריתם הירידה הסטוכסטית עם תמיכה במומנטום, דעיכת קצב למידה ומומנטום Nesterov. מומנטום ומומנטום Nesterov (המכונה גם שיטת השיפוע המואץ של Nesterov) הן שיטות אופטימיזציה מסדר ראשון שיכולות לשפר את מהירות האימון וקצב ההתכנסות של ירידה בשיפוע.

  הפניות:

  • "שיטת קירוב סטוכסטית" (רובינס ומונרו, 1951)
  • "על שיטת הקירוב הסטוכסטי של רובינס ומונרו" (וולפוביץ, 1952)
  • "הערכה סטוכסטית של המקסימום של פונקציית רגרסיה" (קיפר ווולפוביץ, 1952)
  • "כמה שיטות להאצת שיטת ההתכנסות של איטרציה" (Polyak, 1964)
  • "שיטה לבעיית מזעור קמור ללא מגבלה עם קצב ההתכנסות" (Nesterov, 1983)

  הַצהָרָה

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

• עידן הדרכה
  רצף אינסופי של אוספים של דגימות אצווה המתאימות לאימון DNN כאשר הדגימות אחידות.

  לקבוצות בכל תקופה יש בדיוק אותו גודל.

  הַצהָרָה

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

• EpochPipelineQueue
  הַצהָרָה

  public class EpochPipelineQueue

• ThreadState
  המצב של לולאת אימון במכשיר.

  הַצהָרָה

  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