लेयर

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

Layer Module प्रोटोकॉल का परिशोधन है, जिसमें Module अधिक सामान्य मामले को परिभाषित करता है जहां प्रकार के लिए इनपुट आवश्यक रूप से भिन्न नहीं होता है। एक मॉडल में अधिकांश घटक अलग-अलग इनपुट से निपटेंगे, लेकिन ऐसे मामले भी हैं जहां प्रकारों को इसके बजाय Module के अनुरूप होने की आवश्यकता हो सकती है।

यदि आप कोई ऐसा ऑपरेशन बनाते हैं जिसमें कोई प्रशिक्षण योग्य पैरामीटर नहीं है, तो आप इसे Layer के बजाय ParameterlessLayer के संदर्भ में परिभाषित करना चाहेंगे।

मॉडल को अक्सर Layer के रूप में परिभाषित किया जाता है, और नियमित रूप से अन्य Layer से बने होते हैं। एक मॉडल या सबयूनिट जिसे एक Layer के रूप में परिभाषित किया गया है, उसे किसी अन्य Layer की तरह ही माना जा सकता है, जिससे अन्य मॉडलों या सबयूनिट से मनमाने ढंग से जटिल मॉडल के निर्माण की अनुमति मिलती है।

अपने स्वयं के मॉडल या ऑपरेशन के लिए एक कस्टम Layer परिभाषित करने के लिए, आप आम तौर पर इसके समान एक टेम्पलेट का पालन करेंगे:

public struct MyModel: Layer {
  // Define your layers or other properties here.

  // A custom initializer may be desired to configure the model.
  public init() {}

  @differentiable
  public func callAsFunction(_ input: Tensor<Float>) -> Tensor<Float> {
    // Define the sequence of operations performed on model input to arrive at the output.
    return ...
  }
}

Layers के प्रशिक्षित घटकों, जैसे वजन और पूर्वाग्रह, साथ ही अन्य Layer को गुणों के रूप में घोषित किया जा सकता है। एक कस्टम इनिशियलाइज़र किसी मॉडल के लिए अनुकूलन योग्य मापदंडों को उजागर करने के लिए एक अच्छी जगह है, जैसे कि परतों की परिवर्तनीय संख्या या वर्गीकरण मॉडल का आउटपुट आकार। अंत में, Layer का मूल callAsFunction() है, जहां आप इनपुट और आउटपुट के प्रकारों के साथ-साथ एक में होने वाले और दूसरे को वापस करने वाले परिवर्तन को परिभाषित करेंगे।

अंतर्निर्मित परतें

मॉडल या सबयूनिट्स को परिभाषित करते समय आपके उपयोग के लिए कई सामान्य मशीन लर्निंग ऑपरेशंस को Layer के रूप में समझाया गया है। कार्यात्मक क्षेत्रों द्वारा समूहीकृत, TensorFlow के लिए स्विफ्ट द्वारा प्रदान की गई परतों की सूची निम्नलिखित है:

वृद्धि

कनवल्शन

एम्बेडिंग

रूपात्मक

मानकीकरण

पूलिंग

आवर्ती तंत्रिका नेटवर्क

पुन: आकार देने

अपसैंपलिंग

अनुकूलक

ऑप्टिमाइज़र मशीन लर्निंग मॉडल के प्रशिक्षण का एक प्रमुख घटक हैं, जो गणना ग्रेडिएंट के आधार पर मॉडल को अपडेट करते हैं। ये अपडेट आदर्श रूप से मॉडल के मापदंडों को इस तरह से समायोजित करेंगे जैसे कि मॉडल को प्रशिक्षित किया जाए।

ऑप्टिमाइज़र का उपयोग करने के लिए, पहले इसे उपयुक्त प्रशिक्षण मापदंडों के साथ लक्ष्य मॉडल के लिए आरंभ करें:

let optimizer = RMSProp(for: model, learningRate: 0.0001, decay: 1e-6)

इनपुट और हानि फ़ंक्शन के संबंध में एक ग्रेडिएंट प्राप्त करके एक मॉडल को प्रशिक्षित करें, और फिर अपने ऑप्टिमाइज़र का उपयोग करके उस ग्रेडिएंट के साथ मॉडल को अपडेट करें:

optimizer.update(&model, along: gradients)

अंतर्निहित अनुकूलक

TensorFlow के लिए स्विफ्ट द्वारा कई सामान्य ऑप्टिमाइज़र प्रदान किए जाते हैं। इनमें निम्नलिखित शामिल हैं: