विभेदक

public protocol Differentiable

एक प्रकार जो गणितीय रूप से एक अलग-अलग मैनिफोल्ड का प्रतिनिधित्व करता है जिसका स्पर्शरेखा स्थान परिमित-आयामी है।

  • एक प्रकार जो एक अलग-अलग मूल्य के डेरिवेटिव का प्रतिनिधित्व करता है।

    गणितीय रूप से, यह अवकलनीय प्रकार द्वारा दर्शाए गए अवकलनीय मैनिफोल्ड के स्पर्शरेखा बंडल के बराबर है।

    घोषणा

    associatedtype TangentVector: Differentiable & AdditiveArithmetic
      where TangentVector.TangentVector == TangentVector
  • चालें self दिए गए दिशा के साथ। Riemannian ज्यामिति में, इस घातीय नक्शा है, जो चाल के बराबर है self दिया स्पर्श वेक्टर साथ Geodesic सतह पर।

    घोषणा

    mutating mutating func move(along direction: TangentVector)
  • एक बंद है कि एक शून्य स्पर्श वेक्टर पैदा करता है, से कम से कम आवश्यक जानकारी पर कब्जा self

    move(along: zeroTangentVectorInitializer()) संशोधित नहीं करना चाहिए self

    कुछ मामलों में, के शून्य स्पर्श वेक्टर self के बराबर है TangentVector.zero । अन्य मामलों में, शून्य स्पर्श वेक्टर सूचना के आधार पर निर्भर करता है में self , इस तरह के एक n आयामी सरणी प्रकार के लिए आकार के रूप में। विभेदक प्रोग्रामिंग के लिए, यह अधिक स्मृति कुशल एक कस्टम परिभाषित करने के लिए है zeroTangentVectorInitializer संपत्ति है जो एक बंद है कि कैप्चर और उपयोग करता है केवल आवश्यक जानकारी एक शून्य स्पर्श वेक्टर बनाने के लिए देता है। उदाहरण के लिए:

    struct Vector {
        var scalars: [Float]
        var count: Int { scalars.count }
        init(scalars: [Float]) { ... }
        init(repeating repeatedElement: Float, count: Int) { ... }
    }
    
    extension Vector: AdditiveArithmetic { ... }
    
    extension Vector: Differentiable {
        typealias TangentVector = Vector
    
        @noDerivative
        var zeroTangentVectorInitializer: () -> TangentVector {
            let count = self.count
            return { TangentVector(repeating: 0, count: count) }
        }
    }
    

    घोषणा

    var zeroTangentVectorInitializer: () -> TangentVector { get }
  • एक स्पर्श वेक्टर का उपयोग कर प्रारंभ zeroTangentVectorInitializermove(along: zeroTangentVector) संशोधित नहीं करना चाहिए self

    घोषणा

    var zeroTangentVector: TangentVector { get }
  • withRecomputationInPullbacks(_:)

    विस्तार विधि

    घोषणा

    @differentiable(wrt: self)
    func withRecomputationInPullbacks<Result : Differentiable>(
      _ body: @escaping @differentiable (Self) -> Result
    ) -> Result
  • व्युत्पन्न के साथ (_ :)

    विस्तार विधि

    के व्युत्पन्न को दिया बंद लागू होता है self

    रिटर्न self एक पहचान समारोह की तरह। जब रिटर्न वैल्यू का उपयोग उस संदर्भ में किया जाता है जहां इसे संबंध में विभेदित किया जाता है, तो दिए गए क्लोजर को रिटर्न वैल्यू के व्युत्पन्न पर लागू होता है।

    घोषणा

    @differentiable(wrt: self)
    func withDerivative(_ body: @escaping (inout TangentVector) -> Void) -> Self
  • रिटर्न उत्पादन, सिवाय इसके कि पहली परत के इनपुट है, पिछले परत के उत्पादन के लिए परतों के एक दृश्य लगाने से गणना की self

    घोषणा

    @differentiable
    public func sequenced<L1: Layer, L2: Layer>(through l1: L1, _ l2: L2) -> L2.Output
    where L1.Input == Self, L1.Output == L2.Input

    मापदंडों

    l1

    पहली परत।

    l2

    दूसरी परत।

    प्रतिलाभ की मात्रा

    अनुक्रमिक अनुप्रयोग के बाद अंतिम परत का आउटपुट।

  • रिटर्न उत्पादन, सिवाय इसके कि पहली परत के इनपुट है, पिछले परत के उत्पादन के लिए परतों के एक दृश्य लगाने से गणना की self

    घोषणा

    @differentiable
    public func sequenced<L1: Layer, L2: Layer, L3: Layer>(through l1: L1, _ l2: L2, _ l3: L3)
      -> L3.Output
    where L1.Input == Self, L1.Output == L2.Input, L2.Output == L3.Input

    मापदंडों

    l1

    पहली परत।

    l2

    दूसरी परत।

    l3

    तीसरी परत।

    प्रतिलाभ की मात्रा

    अनुक्रमिक अनुप्रयोग के बाद अंतिम परत का आउटपुट।

  • रिटर्न उत्पादन, सिवाय इसके कि पहली परत के इनपुट है, पिछले परत के उत्पादन के लिए परतों के एक दृश्य लगाने से गणना की self

    घोषणा

    @differentiable
    public func sequenced<L1: Layer, L2: Layer, L3: Layer, L4: Layer>(
      through l1: L1, _ l2: L2, _ l3: L3, _ l4: L4
    ) -> L4.Output
    where
      L1.Input == Self, L1.Output == L2.Input, L2.Output == L3.Input,
      L3.Output == L4.Input

    मापदंडों

    l1

    पहली परत।

    l2

    दूसरी परत।

    l3

    तीसरी परत।

    l4

    चौथी परत।

    प्रतिलाभ की मात्रा

    अनुक्रमिक अनुप्रयोग के बाद अंतिम परत का आउटपुट।

  • रिटर्न उत्पादन, सिवाय इसके कि पहली परत के इनपुट है, पिछले परत के उत्पादन के लिए परतों के एक दृश्य लगाने से गणना की self

    घोषणा

    @differentiable
    public func sequenced<L1: Layer, L2: Layer, L3: Layer, L4: Layer, L5: Layer>(
      through l1: L1, _ l2: L2, _ l3: L3, _ l4: L4, _ l5: L5
    ) -> L5.Output
    where
      L1.Input == Self, L1.Output == L2.Input, L2.Output == L3.Input, L3.Output == L4.Input,
      L4.Output == L5.Input

    मापदंडों

    l1

    पहली परत।

    l2

    दूसरी परत।

    l3

    तीसरी परत।

    l4

    तीसरी परत।

    l5

    पांचवीं परत।

    प्रतिलाभ की मात्रा

    अनुक्रमिक अनुप्रयोग के बाद अंतिम परत का आउटपुट।

  • रिटर्न उत्पादन, सिवाय इसके कि पहली परत के इनपुट है, पिछले परत के उत्पादन के लिए परतों के एक दृश्य लगाने से गणना की self

    घोषणा

    @differentiable
    public func sequenced<L1: Layer, L2: Layer, L3: Layer, L4: Layer, L5: Layer, L6: Layer>(
      through l1: L1, _ l2: L2, _ l3: L3, _ l4: L4, _ l5: L5, _ l6: L6
    ) -> L6.Output
    where
      L1.Input == Self, L1.Output == L2.Input, L2.Output == L3.Input, L3.Output == L4.Input,
      L4.Output == L5.Input, L5.Output == L6.Input

    मापदंडों

    l1

    पहली परत।

    l2

    दूसरी परत।

    l3

    तीसरी परत।

    l4

    तीसरी परत।

    l5

    पांचवीं परत।

    l6

    छठी परत।

    प्रतिलाभ की मात्रा

    अनुक्रमिक अनुप्रयोग के बाद अंतिम परत का आउटपुट।