इकाइयों:
"न्यूरॉन्स", या "कोशिकाएं", या परत के अंदर जो कुछ भी है, उसकी मात्रा।
यह प्रत्येक परत की एक संपत्ति है, और हाँ, यह आउटपुट आकार से संबंधित है (जैसा कि हम बाद में देखेंगे)। आपके चित्र में, इनपुट लेयर को छोड़कर, जो वैचारिक रूप से अन्य परतों से भिन्न है, आपके पास है:
- छिपी परत 1: 4 इकाइयाँ (4 न्यूरॉन्स)
- छिपी परत 2: 4 इकाइयाँ
- अंतिम परत: 1 इकाई
आकृतियाँ
आकृतियाँ मॉडल के कॉन्फ़िगरेशन के परिणाम हैं। आकृतियाँ टुपल्स हैं जो दर्शाती हैं कि प्रत्येक आयाम में एक एरे या टेन्सर के कितने तत्व हैं।
Ex: एक आकृति का (30,4,10)मतलब 3 आयामों के साथ एक सरणी या टेंसर होता है, जिसमें पहले आयाम में 30 तत्व होते हैं, दूसरे में 4 और तीसरे में 10, कुल 30 * 4 * 10 = 1200 तत्व या संख्या।
इनपुट आकार
परतों के बीच प्रवाह क्या हैं दसियों। आकृतियों के साथ सेंसर को मैट्रिस के रूप में देखा जा सकता है।
केरस में, इनपुट परत खुद एक परत नहीं है, बल्कि एक टेंसर है। यह शुरुआती टेंसर है जिसे आप पहली छिपी हुई परत पर भेजते हैं। इस टेंसर का आपके प्रशिक्षण डेटा के समान आकार होना चाहिए।
उदाहरण: यदि आपके पास RGB (3 चैनल) में 50x50 पिक्सेल की 30 छवियां हैं, तो आपके इनपुट डेटा का आकार है (30,50,50,3)। फिर आपके इनपुट लेयर टेन्सर में यह आकृति होनी चाहिए (विवरण "केयर्स में आकार" अनुभाग में विवरण देखें)।
प्रत्येक प्रकार की परत को कुछ निश्चित आयामों के साथ इनपुट की आवश्यकता होती है:
Dense परतों को इनपुट की आवश्यकता होती है (batch_size, input_size)
- या
(batch_size, optional,...,optional, input_size)
- 2 डी कन्वेन्शनल लेयर्स को इनपुट की आवश्यकता है:
- अगर का उपयोग कर
channels_last:(batch_size, imageside1, imageside2, channels)
- अगर का उपयोग कर
channels_first:(batch_size, channels, imageside1, imageside2)
- 1D संकल्प और आवर्तक परतों का उपयोग करें
(batch_size, sequence_length, features)
अब, इनपुट आकार केवल वही है जिसे आपको परिभाषित करना चाहिए, क्योंकि आपका मॉडल इसे नहीं जान सकता है। केवल आप ही जानते हैं कि, आपके प्रशिक्षण डेटा के आधार पर।
अन्य सभी आकृतियों की गणना स्वचालित रूप से प्रत्येक परत की इकाइयों और विशिष्टताओं के आधार पर की जाती है।
आकृतियों और इकाइयों के बीच संबंध - आउटपुट आकृति
इनपुट आकार को देखते हुए, अन्य सभी आकार परतों की गणना के परिणाम हैं।
प्रत्येक परत की "इकाइयां" आउटपुट आकार (टेंसर का आकार जो परत द्वारा निर्मित होती है और जो अगली परत का इनपुट होगा) को परिभाषित करेगी।
प्रत्येक प्रकार की परत एक विशेष तरीके से काम करती है। घनीभूत परतों में "इकाइयों" के आधार पर आउटपुट आकार होता है, दृढ़ परतों में "फिल्टर" के आधार पर आउटपुट आकार होता है। लेकिन यह हमेशा कुछ लेयर प्रॉपर्टी पर आधारित होता है। (प्रत्येक परत आउटपुट के लिए प्रलेखन देखें)
आइए दिखाते हैं कि "घने" परतों के साथ क्या होता है, जो आपके ग्राफ में दिखाया गया प्रकार है।
घने परत का आउटपुट आकार होता है (batch_size,units)। तो, हाँ, इकाइयों, परत की संपत्ति, आउटपुट आकार को भी परिभाषित करती है।
- छिपी परत 1: 4 इकाइयां, आउटपुट आकार
(batch_size,4):।
- छिपी परत 2: 4 इकाइयां, आउटपुट आकार
(batch_size,4):।
- अंतिम परत: 1 इकाई, आउटपुट आकार
(batch_size,1):।
तौल
वजन पूरी तरह से इनपुट और आउटपुट आकृतियों के आधार पर स्वचालित रूप से गणना की जाएगी। फिर से, प्रत्येक प्रकार की परत एक निश्चित तरीके से काम करती है। लेकिन भार एक मैट्रिक्स होगा जो कुछ गणितीय ऑपरेशन द्वारा इनपुट आकार को आउटपुट आकार में बदलने में सक्षम है।
एक घनी परत में, वजन सभी इनपुटों को गुणा करता है। यह एक कॉलम प्रति इनपुट और एक पंक्ति प्रति यूनिट के साथ एक मैट्रिक्स है, लेकिन यह अक्सर बुनियादी कार्यों के लिए महत्वपूर्ण नहीं है।
छवि में, यदि प्रत्येक तीर पर एक गुणन संख्या होती है, तो सभी संख्याएँ मिलकर भार मैट्रिक्स बनाती हैं।
करस में आकार
इससे पहले, मैंने 30 छवियों, 50x50 पिक्सल और 3 चैनलों का एक उदाहरण दिया था, जिसमें इनपुट आकार का था (30,50,50,3)।
चूंकि इनपुट आकार केवल एक है जिसे आपको परिभाषित करने की आवश्यकता है, केरस पहली परत में इसकी मांग करेगा।
लेकिन इस परिभाषा में, केरेस पहले आयाम की उपेक्षा करता है, जो बैच आकार है। आपका मॉडल किसी भी बैच आकार से निपटने में सक्षम होना चाहिए, इसलिए आप केवल अन्य आयामों को परिभाषित करते हैं:
input_shape = (50,50,3)
#regardless of how many images I have, each image has this shape
वैकल्पिक रूप से, या जब इसे कुछ प्रकार के मॉडल की आवश्यकता होती है, तो आप बैच आकार वाले आकार को पास कर सकते हैं batch_input_shape=(30,50,50,3)या batch_shape=(30,50,50,3)। यह आपके प्रशिक्षण की संभावनाओं को इस अद्वितीय बैच आकार तक सीमित करता है, इसलिए इसका उपयोग केवल तभी किया जाना चाहिए जब वास्तव में आवश्यक हो।
किसी भी तरह से आप चुनते हैं, मॉडल में दसियों का बैच आयाम होगा।
इसलिए, भले ही आपने उपयोग किया हो input_shape=(50,50,3), जब केरे आपको संदेश भेजता है, या जब आप मॉडल सारांश प्रिंट करते हैं, तो यह दिखाई देगा (None,50,50,3)।
पहला आयाम बैच आकार है, यह Noneइसलिए है क्योंकि यह इस बात पर निर्भर करता है कि आप प्रशिक्षण के लिए कितने उदाहरण देते हैं। (यदि आपने स्पष्ट रूप से बैच आकार को परिभाषित किया है, तो आपके द्वारा परिभाषित संख्या इसके बजाय दिखाई देगी None)
इसके अलावा, उन्नत कार्यों में, जब आप वास्तव में टेंसर्स (लैम्बडा परतों के अंदर या नुकसान फ़ंक्शन में, उदाहरण के लिए) पर सीधे काम करते हैं, तो बैच आकार आयाम होगा।
- इसलिए, इनपुट आकार को परिभाषित करते समय, आप बैच आकार की उपेक्षा करते हैं:
input_shape=(50,50,3)
- सीधे टेनसर्स पर ऑपरेशन करते समय, आकृति फिर से होगी
(30,50,50,3)
- Keras आप एक संदेश भेजता है, आकार हो जाएगा
(None,50,50,3)या (30,50,50,3), तो यह आपको भेजता संदेश की किस प्रकार पर निर्भर करता है।
मंद
और अंत में, क्या है dim?
यदि आपके इनपुट आकार में केवल एक आयाम है, तो आपको इसे टपल के रूप में देने की आवश्यकता नहीं है, आप input_dimस्केलर नंबर के रूप में देते हैं ।
तो, आपके मॉडल में, जहां आपकी इनपुट परत में 3 तत्व हैं, आप इन दोनों में से किसी का उपयोग कर सकते हैं:
input_shape=(3,) - अल्पविराम आवश्यक है जब आपके पास केवल एक आयाम हो input_dim = 3
लेकिन जब सीधे टेंसरों के साथ काम करते हैं, तो अक्सर dimयह संदर्भित करेगा कि एक टेंसर के कितने आयाम हैं। उदाहरण के लिए आकार के साथ एक तन्यता (25,10909) के 2 आयाम हैं।
केर में अपनी छवि को परिभाषित करना
कार्स के पास इसे करने के दो तरीके हैं, Sequentialमॉडल, या कार्यात्मक एपीआई Model। मुझे अनुक्रमिक मॉडल का उपयोग करना पसंद नहीं है, बाद में आपको इसे वैसे भी भूलना होगा क्योंकि आप शाखाओं के साथ मॉडल चाहते हैं।
पुनश्च: यहाँ मैंने अन्य पहलुओं को अनदेखा किया, जैसे कि सक्रियण कार्य।
अनुक्रमिक मॉडल के साथ :
from keras.models import Sequential
from keras.layers import *
model = Sequential()
#start from the first hidden layer, since the input is not actually a layer
#but inform the shape of the input, with 3 elements.
model.add(Dense(units=4,input_shape=(3,))) #hidden layer 1 with input
#further layers:
model.add(Dense(units=4)) #hidden layer 2
model.add(Dense(units=1)) #output layer
कार्यात्मक एपीआई मॉडल के साथ :
from keras.models import Model
from keras.layers import *
#Start defining the input tensor:
inpTensor = Input((3,))
#create the layers and pass them the input tensor to get the output tensor:
hidden1Out = Dense(units=4)(inpTensor)
hidden2Out = Dense(units=4)(hidden1Out)
finalOut = Dense(units=1)(hidden2Out)
#define the model's start and end points
model = Model(inpTensor,finalOut)
दसियों का आकार
याद रखें कि आप परतों को परिभाषित करते समय बैच आकारों की उपेक्षा करते हैं:
- inpTensor:
(None,3)
- hidden1Out:
(None,4)
- hidden2Out:
(None,4)
- finalOut:
(None,1)
input_shape=पैरामीटर के बारे में एक प्रश्न यह रहता है: तर्क के पहले मूल्य को किस आयाम तक संदर्भित किया जाता है? मुझे चीजें पसंद हैंinput_shape=(728, ), इसलिए मेरे दिमाग में पहला तर्क कॉलम (निश्चित) और दूसरा पंक्तियों (अलग-अलग) के लिए संदर्भित है। लेकिन यह पायथन के एरियर्स के पंक्ति-प्रमुख क्रम के साथ कैसे बैठता है?