जिस तरह त्वरित समानांतर गणना के लिए 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 के लिए स्विफ्ट द्वारा प्रदान की गई परतों की सूची निम्नलिखित है:
वृद्धि
कनवल्शन
- रूपांतरण1D
- Conv2D
- Conv3D
- घना
- गहराईवारConv2D
- वियोज्यConv1D
- वियोज्यConv2D
- ट्रांसपोज़्डकॉन्व1डी
- ट्रांसपोज़्डकॉन्व2डी
- ट्रांसपोज़्डकॉन्व3डी
- जीरोपैडिंग1डी
- जीरोपैडिंग2डी
- जीरोपैडिंग3डी
एम्बेडिंग
रूपात्मक
मानकीकरण
पूलिंग
- औसतपूल1डी
- औसतपूल2डी
- औसतपूल3डी
- मैक्सपूल1डी
- मैक्सपूल2डी
- मैक्सपूल3डी
- फ्रैक्शनलमैक्सपूल2डी
- ग्लोबलएवीजीपूल1डी
- ग्लोबलएवीजीपूल2डी
- GlobalAvgPool3D
- ग्लोबलमैक्सपूल1डी
- ग्लोबलमैक्सपूल2डी
- ग्लोबलमैक्सपूल3डी
आवर्ती तंत्रिका नेटवर्क
पुन: आकार देने
अपसैंपलिंग
अनुकूलक
ऑप्टिमाइज़र मशीन लर्निंग मॉडल के प्रशिक्षण का एक प्रमुख घटक हैं, जो गणना ग्रेडिएंट के आधार पर मॉडल को अपडेट करते हैं। ये अपडेट आदर्श रूप से मॉडल के मापदंडों को इस तरह से समायोजित करेंगे जैसे कि मॉडल को प्रशिक्षित किया जाए।
ऑप्टिमाइज़र का उपयोग करने के लिए, पहले इसे उपयुक्त प्रशिक्षण मापदंडों के साथ लक्ष्य मॉडल के लिए आरंभ करें:
let optimizer = RMSProp(for: model, learningRate: 0.0001, decay: 1e-6)
इनपुट और हानि फ़ंक्शन के संबंध में एक ग्रेडिएंट प्राप्त करके एक मॉडल को प्रशिक्षित करें, और फिर अपने ऑप्टिमाइज़र का उपयोग करके उस ग्रेडिएंट के साथ मॉडल को अपडेट करें:
optimizer.update(&model, along: gradients)
अंतर्निहित अनुकूलक
TensorFlow के लिए स्विफ्ट द्वारा कई सामान्य ऑप्टिमाइज़र प्रदान किए जाते हैं। इनमें निम्नलिखित शामिल हैं: