@StatsSorceress TL; DR:
मैं इस गतिविधि से गुजर रहा हूँ कि क्या मैं स्वयं आवश्यक मेमोरी की गणना कर सकता हूँ:
सक्रियण: 532,752 * 2 * 4 / (1024 ^ 2) = 4.06 एमबी
पैरामीटर: 19,072,984 * 4 / (1024 ^ 2) * 3 = 218.27 एमबी
विविध: 128 * 9,000 * 4 / (1024 ^ 2) = 4.39 एमबी
कुल मेमोरी: (4.06 * 128 ) + 218.27 + 4.39 = 742.34 एमबी
( अगर कोई गलत है तो कृपया मुझे इस पर सही करें। FYI करें, आप पहले से ही कई गुणा गुणा कर चुके हैं, इसीलिए मैंने इसे 128 से ऊपर नहीं बढ़ाया है )
मैं आपको इस लेख और संबंधित वीडियो की ओर इशारा करता हूं । उन्होंने मुझे यह समझने में मदद की कि क्या बहुत बेहतर चल रहा है।
नोट: पूर्वानुमानों के लिए नेटवर्क का उपयोग करने के लिए आवश्यक मेमोरी दो कारणों से प्रशिक्षण के लिए आवश्यक से बहुत कम है:
- भविष्यवाणी करते समय, हम केवल नेटवर्क के माध्यम से एक छवि आगे भेजते हैं और पिछड़े नहीं (इसलिए हम मेमोरी एक्स 3 को गुणा नहीं करते हैं; नीचे देखें;
- प्रति चित्र एक भविष्यवाणी है (इसलिए हमें एक छवि के लिए आवश्यक आकार को एक बैच आकार से गुणा करने की आवश्यकता नहीं है क्योंकि हम भविष्यवाणी में बैचों का उपयोग नहीं करते हैं)।
प्रक्रिया (ट्रेन की मेमोरी)
- एक छवि पर प्रशिक्षित करने के लिए आवश्यक मेमोरी की गणना करें
- अपने बैच में छवियों की संख्या से इस संख्या को गुणा करें
( रिमेम्बर: मिनी-बैचिंग का कहना है कि हम अपने डेटा का सबसेट लेते हैं, सब्मिट में हर इमेज के लिए ग्रेडिएंट्स और एरर की गणना करते हैं, फिर इनको एवरेज करते हैं और एवरेज की दिशा में आगे बढ़ते हैं। कॉननेट्स, वेट और बायसेज के लिए साझा किया जाता है, लेकिन सक्रियणों की संख्या को बैच में छवियों की संख्या से गुणा किया जाता है। )।
चरण 1: 1 छवि के लिए मेमोरी
एक छवि को प्रशिक्षित करने के लिए, आपको स्मृति को आरक्षित करना होगा:
मॉडल पैरामीटर:
वजन और पूर्वाग्रहों प्रत्येक परत, उनके पर ढ़ाल , और उनके गति चर (एडम, Adagrad, RMSProp, आदि, अनुकूलक इस्तेमाल कर रहे हैं तो)
इसके लिए मेमोरी को अनुमानित करने के लिए, वेट और बायसेस को स्टोर करने के लिए आवश्यक मेमोरी की गणना करें और 3 से गुणा करें (अर्थात "3 से" क्योंकि हम कह रहे हैं कि वेट और बायसेस को स्टोर करने के लिए आवश्यक मेमोरी की मात्रा (लगभग) के बराबर है कि गति के लिए आवश्यक है और गति के लिए चर)
समीकरण:
convolutions:
वज़न (n) = गहराई (n) * (कर्नेल_प्रवेशन * कर्नेल_हाइट) * गहराई (n-1)
biases (n) = गहराई (n)
पूरी तरह से जुड़े (घने) परतें:
भार (n) = आउटपुट (n) * इनपुट (n)
biases (n) = आउटपुट (n)
जहाँ n वर्तमान परत है और n-1 पिछली परत है, और आउटपुट एफसी परत से आउटपुट की संख्या है और इनपुट एफसी परत के इनपुट की संख्या है (यदि पिछली परत पूरी तरह से कनेक्टेड परत नहीं है, निविष्टियों की संख्या उस परत के आकार के बराबर होती है जो चपटी होती है)।
नोट: अकेले वज़न और पूर्वाग्रह के लिए स्मृति, प्लस एक छवि के लिए सक्रियण के लिए मेमोरी (नीचे देखें), मेमोरी की कुल राशि है जो आपको भविष्यवाणियों के लिए चाहिए (दृढ़ संकल्प और कुछ अन्य चीजों के लिए स्मृति के लिए कुछ ओवरहेड को छोड़कर)।
- सक्रियण (ये कैफ़ में "ब्लब्स" हैं):
(मैं यहाँ शब्दों का प्रयोग कर रहा हूँ, मेरे साथ सहन करो)
एक कनवल्शन लेयर में प्रत्येक कन्वेक्शन " इमेज में पिक्सल्स की संख्या " उत्पन्न करता है (यानी आप एक कॉनवोल्यूशन के माध्यम से एक इमेज पास करते हैं, आपको " एम " एक्टीवेशन से मिलकर एक सिंगल फ़ीचर मैप मिलता है , जहाँ " एम " आपकी पिक्सल्स की संख्या है) छवि / इनपुट)।
पूरी तरह से जुड़ी हुई परतों के लिए, आपके द्वारा उत्पादित सक्रियणों की संख्या आपके आउटपुट के आकार के बराबर होती है।
convolutions:
सक्रियण (n) = image_width * image_height * image_num_channels
पूरी तरह से जुड़े (घने) परतें:
सक्रियण (n) = आउटपुट (n)
ध्यान दें कि नेटवर्क की शुरुआत में आपका इनपुट वास्तव में केवल एक छवि है। दृढ़ संकल्प के बाद, यह कुछ और (फीचर मैप्स) में बदल जाता है। तो वास्तव में "input_width", "image_height", और "image_num_channels" को "input_width", "input_height", और "layer_depth" से और अधिक सटीक होने के लिए बदलें। (छवियों के संदर्भ में इस अवधारणा के बारे में सोचना मेरे लिए आसान है।)
चूँकि हमें प्रत्येक लेयर (बैकवर्ड पास में उपयोग की जाने वाली एक्टिविटीज) के लिए एरर को स्टोर करने की आवश्यकता होती है, इसलिए हमें अपने स्टोरेज स्पेस में जगह बनाने के लिए कुल एक्टिविटीज़ की संख्या को 2 से गुणा करना होगा। बैच में छवियों की संख्या के साथ सक्रियण की संख्या बढ़ जाती है, इसलिए आप इस संख्या को बैच आकार से गुणा करते हैं।
चरण 2: ट्रेन बैच को मेमोरी
भार और पूर्वाग्रहों की संख्या (3 बार) और सक्रियणों की संख्या (2 बार बैच आकार)। इसे 4 से गुणा करें, और आपको बैच को प्रशिक्षित करने के लिए आवश्यक बाइट्स की संख्या मिलती है। GB में उत्तर पाने के लिए आप 1024 ^ 2 से भाग कर सकते हैं।