क्लास

निम्नलिखित कक्षाएं विश्व स्तर पर उपलब्ध हैं।

• पैरामीटर
  एक टेन्सर का परिवर्तनशील, साझा करने योग्य, स्वामित्व वाला संदर्भ।

  घोषणा

  public final class Parameter<Scalar> where Scalar : TensorFlowScalar

  extension Parameter: CopyableToDevice

• TFETensorHandle
  क्लास एक C पॉइंटर को TensorHandle में लपेट रहा है। यह वर्ग TensorHandle का स्वामी है और इसे नष्ट करने के लिए जिम्मेदार है।

  घोषणा

  public class TFETensorHandle : _AnyTensorHandle

  extension TFETensorHandle: Equatable

• आरएमएसप्रोप
  एक आरएमएसप्रॉप अनुकूलक।

  आरएमएसप्रॉप अनुकूलन एल्गोरिदम लागू करता है। आरएमएसप्रॉप स्टोकेस्टिक ग्रेडिएंट डिसेंट का एक रूप है जहां ग्रेडिएंट्स को उनके हाल के परिमाण के रनिंग औसत से विभाजित किया जाता है। आरएमएसप्रॉप प्रत्येक वजन के लिए वर्ग ग्रेडिएंट का मूविंग एवरेज रखता है।

  सन्दर्भ:

  • "व्याख्यान 6.5 - आरएमएसप्रॉप: ग्रेडिएंट को उसके हालिया परिमाण के रनिंग औसत से विभाजित करें" (टीलेमैन और हिंटन, 2012)
  • "आवर्ती तंत्रिका नेटवर्क के साथ अनुक्रम उत्पन्न करना" (ग्रेव्स, 2013)

  घोषणा

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

• एडाग्रैड
  एक AdaGrad अनुकूलक.

  AdaGrad (अनुकूली ग्रेडिएंट) अनुकूलन एल्गोरिदम लागू करता है। AdaGrad में पैरामीटर-विशिष्ट सीखने की दरें हैं, जिन्हें प्रशिक्षण के दौरान कितनी बार पैरामीटर अपडेट किया जाता है, इसके सापेक्ष अनुकूलित किया जाता है। जो पैरामीटर अधिक अपडेट प्राप्त करते हैं उनमें सीखने की दर कम होती है।

  AdaGrad व्यक्तिगत रूप से सभी मॉडल मापदंडों की सीखने की दरों को ग्रेडिएंट मानदंडों के वर्गों के चल रहे योग के वर्गमूल के विपरीत आनुपातिक रूप से स्केल करके अनुकूलित करता है।

  संदर्भ: "ऑनलाइन लर्निंग और स्टोचैस्टिक ऑप्टिमाइज़ेशन के लिए अनुकूली सबग्रेडिएंट तरीके" (डुची एट अल, 2011)

  घोषणा

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

• एडाडेल्टा
  एक AdaDelta अनुकूलक.

  AdaDelta अनुकूलन एल्गोरिथ्म लागू करता है। AdaDelta प्रथम क्रम की जानकारी के आधार पर एक स्टोकेस्टिक ग्रेडिएंट डिसेंट विधि है। यह सभी पिछले ग्रेडिएंट्स को जमा करने के बजाय, ग्रेडिएंट अपडेट की चलती विंडो के आधार पर सीखने की दरों को अनुकूलित करता है। इस प्रकार, कई अपडेट किए जाने के बाद भी AdaDelta सीखना जारी रखता है। यह अनुकूलन समस्या स्थान की बदलती गतिशीलता के लिए तेजी से अनुकूलित होता है।

  संदर्भ: "ADADELTA: एक अनुकूली सीखने की दर विधि" (ज़ीलर, 2012)

  घोषणा

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

• एडम
  एडम अनुकूलक.

  एडम अनुकूलन एल्गोरिदम लागू करता है। एडम एक स्टोकेस्टिक ग्रेडिएंट डिसेंट विधि है जो ग्रेडिएंट के पहले और दूसरे क्रम के क्षणों के अनुमान से विभिन्न मापदंडों के लिए व्यक्तिगत अनुकूली सीखने की दरों की गणना करता है।

  संदर्भ: "एडम: स्टोकेस्टिक ऑप्टिमाइज़ेशन के लिए एक विधि" (किंग्मा और बा, 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 अनुकूलक।

  यह एल्गोरिदम स्थानीय ऑप्टिमा के करीब होने पर बेहतर अभिसरण गुणों के साथ एडम का एक संशोधन है।

  संदर्भ: "एडम और परे के अभिसरण पर"

  घोषणा

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

• रादम
  रेडम अनुकूलक।

  रेक्टिफाइड एडम, एडम का एक प्रकार जो अनुकूली सीखने की दर भिन्नता को सुधारने के लिए एक शब्द पेश करता है।

  संदर्भ: "अनुकूली सीखने की दर और उससे आगे की भिन्नता पर"

  घोषणा

  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

• जनरलऑप्टिमाइज़र
  सामान्य अनुकूलक जो अनेक संभावित अनुकूलनों को व्यक्त करने में सक्षम होना चाहिए। ऑप्टिमाइज़र पैरामीटरग्रुप से पैरामीटरग्रुपऑप्टिमाइज़र तक मैपिंग से बना है। इस ऑप्टिमाइज़र में क्रॉस रेप्लिका योग में काम करने वाले तत्वों की संख्या भी शामिल है। यह ग्रेडिएंट पर एकाधिक अकुशल पुनरावृत्तियों को रोकने की दक्षता के लिए है।

  घोषणा

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

• एसजीडी
  एक स्टोकेस्टिक ग्रेडिएंट डिसेंट (एसजीडी) ऑप्टिमाइज़र।

  गति, सीखने की दर में गिरावट और नेस्टरोव गति के समर्थन के साथ स्टोकेस्टिक ग्रेडिएंट डिसेंट एल्गोरिदम को लागू करता है। मोमेंटम और नेस्टरोव गति (उर्फ नेस्टरोव त्वरित ग्रेडिएंट विधि) प्रथम-क्रम अनुकूलन विधियां हैं जो प्रशिक्षण गति और ग्रेडिएंट डिसेंट की अभिसरण दर में सुधार कर सकती हैं।

  सन्दर्भ:

  • "एक स्टोकेस्टिक सन्निकटन विधि" (रॉबिन्स और मोनरो, 1951)
  • "रॉबिन्स और मोनरो की स्टोकेस्टिक सन्निकटन विधि पर" (वोल्फोवित्ज़, 1952)
  • "एक प्रतिगमन फ़ंक्शन के अधिकतम का स्टोकेस्टिक अनुमान" (किफ़र और वोल्फोविट्ज़, 1952)
  • "पुनरावृत्ति विधि के अभिसरण को तेज करने के कुछ तरीके" (पॉलीक, 1964)
  • "अभिसरण की दर के साथ अनियंत्रित उत्तल न्यूनीकरण समस्या के लिए एक विधि" (नेस्टरोव, 1983)

  घोषणा

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

• प्रशिक्षणयुग
  जब नमूने एक समान हों तो डीएनएन के प्रशिक्षण के लिए उपयुक्त बैच नमूनों के संग्रह का एक अनंत क्रम।

  प्रत्येक युग में सभी बैचों का आकार बिल्कुल समान होता है।

  घोषणा

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

• एपोचपाइपलाइनक्यू
  घोषणा

  public class EpochPipelineQueue

• थ्रेडस्टेट
  किसी डिवाइस पर प्रशिक्षण लूप की स्थिति.

  घोषणा

  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