পার্থক্যযোগ্য

public protocol Differentiable

একটি প্রকার যা গাণিতিকভাবে একটি পার্থক্যযোগ্য বহুগুণকে উপস্থাপন করে যার স্পর্শক স্থানগুলি সসীম-মাত্রিক।

• স্পর্শক ভেক্টর
  একটি ভিন্নতাযোগ্য মানের ডেরিভেটিভের প্রতিনিধিত্বকারী একটি প্রকার।

  গাণিতিকভাবে, এটি ডিফারেনশিয়াবল টাইপ দ্বারা উপস্থাপিত ডিফারেনশিয়াবল ম্যানিফোল্ডের স্পর্শক বান্ডেলের সমতুল্য।

  ঘোষণা

  associatedtype TangentVector: Differentiable & AdditiveArithmetic
    where TangentVector.TangentVector == TangentVector

• বরাবর অগ্রসর:)
  প্রদত্ত দিক বরাবর self সরানো. রিমেনিয়ান জ্যামিতিতে, এটি সূচকীয় মানচিত্রের সমতুল্য, যা প্রদত্ত স্পর্শক ভেক্টর বরাবর জিওডেসিক পৃষ্ঠের উপর self সরায়।

  ঘোষণা

  mutating mutating func move(along direction: TangentVector)

• zeroTangentVectorInitializer
  একটি বন্ধ যা একটি শূন্য স্পর্শক ভেক্টর তৈরি করে, 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 }

• zeroTangentVector এক্সটেনশন পদ্ধতি
  zeroTangentVectorInitializer ব্যবহার করে একটি স্পর্শক ভেক্টর শুরু হয়। move(along: zeroTangentVector) self পরিবর্তন করা উচিত নয়।

  ঘোষণা

  var zeroTangentVector: TangentVector { get }

• রিকম্পিউটেশন ইনপুলব্যাকের সাথে(_:) এক্সটেনশন পদ্ধতি
  ঘোষণা

  @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	ষষ্ঠ স্তর।

  ফেরত মূল্য

  ক্রমিক প্রয়োগের পরে চূড়ান্ত স্তরের আউটপুট।