क्लास

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

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

    घोषणा

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

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

    घोषणा

    public class TFETensorHandle : _AnyTensorHandle
    extension TFETensorHandle: Equatable

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

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

    सन्दर्भ:

    घोषणा

    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

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

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

    सन्दर्भ:

    घोषणा

    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