केरस - परत

जैसा कि पहले सीखा गया था, केरस परतें केरस मॉडल की प्राथमिक बिल्डिंग ब्लॉक हैं। प्रत्येक परत इनपुट जानकारी प्राप्त करती है, कुछ संगणना करती है और अंत में रूपांतरित सूचना का उत्पादन करती है। एक परत का आउटपुट इसके इनपुट के रूप में अगली परत में प्रवाहित होगा। आइए इस अध्याय में परतों के बारे में पूरी जानकारी जानें।

परिचय

एक केर परत की आवश्यकता है shape of the input (input_shape) इनपुट डेटा की संरचना को समझने के लिए, initializerप्रत्येक इनपुट के लिए वजन सेट करने के लिए और अंत में इसे गैर-रैखिक बनाने के लिए आउटपुट को बदलने के लिए सक्रिय करें। बीच में, बाधाओं को सीमित करता है और उस सीमा को निर्दिष्ट करता है जिसमें इनपुट डेटा का भार उत्पन्न होता है और नियमित रूप से अनुकूलन प्रक्रिया के दौरान भार पर दंड को गतिशील रूप से लागू करके परत (और मॉडल) को अनुकूलित करने का प्रयास करेगा।

संक्षेप में, केरस परत को पूरी परत बनाने के लिए न्यूनतम विवरण से नीचे की आवश्यकता होती है।

• इनपुट डेटा का आकार
• परत में न्यूरॉन्स / इकाइयों की संख्या
• Initializers
• Regularizers
• Constraints
• Activations

आइए हम अगले अध्याय में मूल अवधारणा को समझते हैं। बुनियादी अवधारणा को समझने से पहले, आइए हम कैसेर मॉडल और परत कैसे काम करते हैं, इस विचार को प्राप्त करने के लिए अनुक्रमिक मॉडल एपीआई का उपयोग करके एक सरल केरस परत बनाएं।

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 
from keras import regularizers 
from keras import constraints 

model = Sequential() 

model.add(Dense(32, input_shape=(16,), kernel_initializer = 'he_uniform', 
   kernel_regularizer = None, kernel_constraint = 'MaxNorm', activation = 'relu')) 
model.add(Dense(16, activation = 'relu')) 
model.add(Dense(8))

कहाँ पे,

• Line 1-5 आवश्यक मॉड्यूल आयात करता है।

• Line 7 अनुक्रमिक एपीआई का उपयोग कर एक नया मॉडल बनाता है।

• Line 9 एक नया बनाता है Dense परत और मॉडल में जोड़ें। Denseकेरस द्वारा प्रदान की गई एक प्रवेश स्तर की परत है, जो अपने आवश्यक पैरामीटर के रूप में न्यूरॉन्स या इकाइयों (32) की संख्या को स्वीकार करती है। यदि परत पहली परत है, तो हमें प्रदान करने की आवश्यकता हैInput Shape, (16,)भी। अन्यथा, पिछली परत के आउटपुट का उपयोग अगली परत के इनपुट के रूप में किया जाएगा। अन्य सभी पैरामीटर वैकल्पिक हैं।

  • पहला पैरामीटर इकाइयों की संख्या (न्यूरॉन्स) का प्रतिनिधित्व करता है।

  • input_shape इनपुट डेटा के आकार का प्रतिनिधित्व करते हैं।

  • kernel_initializer उपयोग किए जाने वाले इनिशियलाइज़र का प्रतिनिधित्व करते हैं। he_uniform फ़ंक्शन को मान के रूप में सेट किया गया है।

  • kernel_regularizer का प्रतिनिधित्व regularizerइस्तेमाल किया जाएगा। कोई भी मान के रूप में सेट नहीं है।

  • kernel_constraint उपयोग किए जाने के लिए बाधा का प्रतिनिधित्व करते हैं। MaxNorm फ़ंक्शन को मान के रूप में सेट किया गया है।

  • activationसक्रियण का प्रतिनिधित्व करते हैं। relu फ़ंक्शन मान के रूप में सेट किया गया है।

• Line 10 दूसरा बनाता है Dense 16 इकाइयों और सेट के साथ परत relu सक्रियण समारोह के रूप में।

• Line 11 8 इकाइयों के साथ अंतिम घने परत बनाता है।

परतों की बुनियादी अवधारणा

आइए हम परत की मूल अवधारणा को समझते हैं और साथ ही साथ कैसे प्रत्येक अवधारणा का समर्थन करते हैं।

इनपुट आकार

मशीन लर्निंग में, पाठ, चित्र या वीडियो जैसे सभी प्रकार के इनपुट डेटा को पहले संख्याओं के सरणी में परिवर्तित किया जाएगा और फिर एल्गोरिथ्म में फीड किया जाएगा। इनपुट संख्या एकल आयामी सरणी, दो आयामी सरणी (मैट्रिक्स) या बहु-आयामी सरणी हो सकती है। हम उपयोग करके आयामी जानकारी निर्दिष्ट कर सकते हैंshape, पूर्णांकों का एक समूह। उदाहरण के लिए,(4,2) चार पंक्तियों और दो स्तंभों के साथ मैट्रिक्स का प्रतिनिधित्व करें।

>>> import numpy as np 
>>> shape = (4, 2) 
>>> input = np.zeros(shape) 
>>> print(input) 
[
   [0. 0.] 
   [0. 0.] 
   [0. 0.] 
   [0. 0.]
] 
>>>

इसी तरह, (3,4,2) 4x2 मैट्रिक्स (दो पंक्तियों और चार स्तंभों) के तीन संग्रह वाले तीन आयामी मैट्रिक्स।

>>> import numpy as np 
>>> shape = (3, 4, 2) 
>>> input = np.zeros(shape) 
>>> print(input)
[
   [[0. 0.] [0. 0.] [0. 0.] [0. 0.]] 
   [[0. 0.] [0. 0.] [0. 0.] [0. 0.]] 
   [[0. 0.] [0. 0.] [0. 0.] [0. 0.]]
]
>>>

मॉडल की पहली परत (या मॉडल की इनपुट परत) बनाने के लिए, इनपुट डेटा का आकार निर्दिष्ट किया जाना चाहिए।

initializers

मशीन लर्निंग में, वजन सभी इनपुट डेटा को सौंपा जाएगा। Initializersमॉड्यूल इन प्रारंभिक वजन को निर्धारित करने के लिए अलग-अलग कार्य प्रदान करता है। कुछ केKeras Initializer फ़ंक्शन निम्नानुसार हैं -

शून्य

उत्पन्न करता है 0 सभी इनपुट डेटा के लिए।

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 

my_init = initializers.Zeros() 
model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

कहाँ पे, kernel_initializer मॉडल के कर्नेल के लिए इनिशलाइज़र का प्रतिनिधित्व करते हैं।

लोगों

उत्पन्न करता है 1 सभी इनपुट डेटा के लिए।

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 

my_init = initializers.Ones() 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

स्थिर

एक निरंतर मान उत्पन्न करता है (कहते हैं, 5) सभी इनपुट डेटा के लिए उपयोगकर्ता द्वारा निर्दिष्ट।

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 

my_init = initializers.Constant(value = 0) model.add(
   Dense(512, activation = 'relu', input_shape = (784,), kernel_initializer = my_init)
)

कहाँ पे, value निरंतर मूल्य का प्रतिनिधित्व करते हैं

RandomNormal

इनपुट डेटा के सामान्य वितरण का उपयोग करके मूल्य उत्पन्न करता है।

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 

my_init = initializers.RandomNormal(mean=0.0, 
stddev = 0.05, seed = None) 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

कहाँ पे,

• mean उत्पन्न करने के लिए यादृच्छिक मूल्यों के माध्यम का प्रतिनिधित्व करते हैं

• stddev उत्पन्न करने के लिए यादृच्छिक मूल्यों के मानक विचलन का प्रतिनिधित्व करते हैं

• seed यादृच्छिक संख्या उत्पन्न करने के लिए मूल्यों का प्रतिनिधित्व करते हैं

RandomUniform

इनपुट डेटा के समान वितरण का उपयोग करके मूल्य उत्पन्न करता है।

from keras import initializers 

my_init = initializers.RandomUniform(minval = -0.05, maxval = 0.05, seed = None) 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

कहाँ पे,

• minval उत्पन्न करने के लिए यादृच्छिक मूल्यों की निचली सीमा का प्रतिनिधित्व करते हैं

• maxval उत्पन्न करने के लिए यादृच्छिक मूल्यों की ऊपरी सीमा का प्रतिनिधित्व करते हैं

TruncatedNormal

इनपुट डेटा के सामान्य वितरण को काटकर मान उत्पन्न करता है।

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 

my_init = initializers.TruncatedNormal(mean = 0.0, stddev = 0.05, seed = None
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

VarianceScaling

निर्दिष्ट पैमाने के साथ परत के इनपुट आकार और आउटपुट आकार के आधार पर मूल्य उत्पन्न करता है।

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 

my_init = initializers.VarianceScaling(
   scale = 1.0, mode = 'fan_in', distribution = 'normal', seed = None) 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   skernel_initializer = my_init))

कहाँ पे,

• scale स्केलिंग कारक का प्रतिनिधित्व करते हैं

• mode किसी एक का प्रतिनिधित्व करें fan_in, fan_out तथा fan_avg मूल्यों

• distribution दोनों का प्रतिनिधित्व करें normal या uniform

VarianceScaling

यह पाता है stddev नीचे दिए गए सूत्र का उपयोग करके सामान्य वितरण के लिए मूल्य और फिर सामान्य वितरण का उपयोग करके वज़न ज्ञात करें,

stddev = sqrt(scale / n)

कहाँ पे n प्रतिनिधित्व करते हैं,

• मोड = fan_in के लिए इनपुट इकाइयों की संख्या

• मोड के लिए बाहर इकाइयों की संख्या = fan_out

• मोड = fan_avg के लिए इनपुट और आउटपुट इकाइयों की औसत संख्या

इसी तरह, यह नीचे दिए गए फॉर्मूले का उपयोग करके समान वितरण के लिए सीमा पाता है और फिर समान वितरण का उपयोग करके वज़न ज्ञात करता है,

limit = sqrt(3 * scale / n)

lecun_normal

इनपुट डेटा के सामान्य सामान्य वितरण का उपयोग करके मूल्य उत्पन्न करता है।

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 

my_init = initializers.RandomUniform(minval = -0.05, maxval = 0.05, seed = None)
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

यह पाता है stddev नीचे दिए गए सूत्र का उपयोग करके और फिर सामान्य वितरण लागू करें

stddev = sqrt(1 / fan_in)

कहाँ पे, fan_in इनपुट इकाइयों की संख्या का प्रतिनिधित्व करते हैं।

lecun_uniform

इनपुट डेटा के लेकोन समान वितरण का उपयोग करके मूल्य उत्पन्न करता है।

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 

my_init = initializers.lecun_uniform(seed = None) 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

यह पाता है limit नीचे दिए गए सूत्र का उपयोग करना और फिर समान वितरण लागू करना

limit = sqrt(3 / fan_in)

कहाँ पे,

• fan_in इनपुट इकाइयों की संख्या का प्रतिनिधित्व करता है

• fan_out आउटपुट इकाइयों की संख्या का प्रतिनिधित्व करता है

glorot_normal

इनपुट डेटा का सामान्य वितरण ग्लोरट का उपयोग करके मूल्य उत्पन्न करता है।

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 

my_init = initializers.glorot_normal(seed=None) model.add(
   Dense(512, activation = 'relu', input_shape = (784,), kernel_initializer = my_init)
)

यह पाता है stddev नीचे दिए गए सूत्र का उपयोग करके और फिर सामान्य वितरण लागू करें

stddev = sqrt(2 / (fan_in + fan_out))

कहाँ पे,

• fan_in इनपुट इकाइयों की संख्या का प्रतिनिधित्व करता है

• fan_out आउटपुट इकाइयों की संख्या का प्रतिनिधित्व करता है

glorot_uniform

इनपुट डेटा के ग्लोरोट समान वितरण का उपयोग करके मूल्य उत्पन्न करता है।

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 

my_init = initializers.glorot_uniform(seed = None) 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

यह पाता है limit नीचे दिए गए सूत्र का उपयोग करना और फिर समान वितरण लागू करना

limit = sqrt(6 / (fan_in + fan_out))

कहाँ पे,

• fan_in इनपुट इकाइयों की संख्या का प्रतिनिधित्व करते हैं।

• fan_out आउटपुट इकाइयों की संख्या का प्रतिनिधित्व करता है

he_normal

वह इनपुट डेटा के सामान्य वितरण का उपयोग करके मूल्य उत्पन्न करता है।

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 

my_init = initializers.RandomUniform(minval = -0.05, maxval = 0.05, seed = None) 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

यह नीचे दिए गए सूत्र का उपयोग करके stddev पाता है और फिर सामान्य वितरण लागू करता है।

stddev = sqrt(2 / fan_in)

कहाँ पे, fan_in इनपुट इकाइयों की संख्या का प्रतिनिधित्व करते हैं।

he_uniform

वह इनपुट डेटा के समान वितरण का उपयोग करके मूल्य उत्पन्न करता है।

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 

my_init = initializers.he_normal(seed = None) 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

यह पाता है limit नीचे दिए गए सूत्र का उपयोग करना और फिर समान वितरण लागू करना।

limit = sqrt(6 / fan_in)

कहाँ पे, fan_in इनपुट इकाइयों की संख्या का प्रतिनिधित्व करते हैं।

ओर्थोगोनल

एक यादृच्छिक ऑर्थोगोनल मैट्रिक्स उत्पन्न करता है।

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 

my_init = initializers.Orthogonal(gain = 1.0, seed = None) 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

कहाँ पे, gain मैट्रिक्स के गुणन कारक का प्रतिनिधित्व करते हैं।

पहचान

पहचान मैट्रिक्स उत्पन्न करता है।

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 

my_init = initializers.Identity(gain = 1.0) model.add(
   Dense(512, activation = 'relu', input_shape = (784,), kernel_initializer = my_init)
)

प्रतिबन्ध

मशीन लर्निंग में, अनुकूलन चरण के दौरान पैरामीटर (वजन) पर एक बाधा निर्धारित की जाएगी। <> बाधा मॉड्यूल परत पर कसना निर्धारित करने के लिए अलग-अलग कार्य प्रदान करता है। कुछ बाधा कार्य इस प्रकार हैं।

NonNeg

कांस्ट्रेन्स नॉन-निगेटिव होने का वेट करता है।

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 

my_init = initializers.Identity(gain = 1.0) model.add(
   Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init)
)

कहाँ पे, kernel_constraint परत में उपयोग की जाने वाली बाधा का प्रतिनिधित्व करते हैं।

UnitNorm

कांस्ट्रेन्स वज़न यूनिट मानदंड है।

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import constraints 

my_constrain = constraints.UnitNorm(axis = 0) 
model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_constraint = my_constrain))

MaxNorm

दिए गए मूल्य से कम या बराबर होने के लिए वजन कम होता है।

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import constraints 

my_constrain = constraints.MaxNorm(max_value = 2, axis = 0) 
model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_constraint = my_constrain))

कहाँ पे,

• max_value ऊपरी सीमा का प्रतिनिधित्व करते हैं

• अक्ष उस आयाम का प्रतिनिधित्व करता है जिसमें बाधा को लागू किया जाना है। जैसे आकार में (2,3,4) अक्ष 0 पहले आयाम को दर्शाता है, 1 दूसरे आयाम को दर्शाता है और 2 को तीसरे आयाम को दर्शाता है

MinMaxNorm

निर्धारित न्यूनतम और अधिकतम मूल्यों के बीच कसौटी पर कसने के लिए वजन।

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import constraints 

my_constrain = constraints.MinMaxNorm(min_value = 0.0, max_value = 1.0, rate = 1.0, axis = 0) 
model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_constraint = my_constrain))

कहाँ पे, rate उस दर का प्रतिनिधित्व करें जिस पर वजन की कमी लागू होती है।

Regularizers

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

एल 1 रेगुलराइज़र

यह एल 1 आधारित नियमितीकरण प्रदान करता है।

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import regularizers 

my_regularizer = regularizers.l1(0.) 
model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_regularizer = my_regularizer))

कहाँ पे, kernel_regularizer उस दर का प्रतिनिधित्व करें जिस पर वजन की कमी लागू होती है।

एल 2 नियमित

यह एल 2 आधारित नियमितीकरण प्रदान करता है।

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import regularizers 

my_regularizer = regularizers.l2(0.) 
model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_regularizer = my_regularizer))

एल 1 और एल 2 नियमित

यह एल 1 और एल 2 आधारित नियमितीकरण प्रदान करता है।

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import regularizers 

my_regularizer = regularizers.l2(0.) 
model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,),
   kernel_regularizer = my_regularizer))

सक्रियण

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

जैसा कि आप एकल धारणा की अवधारणा को याद करते हैं, एक परसेप्ट्रॉन (न्यूरॉन) का आउटपुट केवल सक्रियण फ़ंक्शन का परिणाम है, जो कि किसी भी उपलब्ध होने पर इसके संबंधित वजन और समग्र पूर्वाग्रह के साथ गुणा किए गए सभी इनपुट के योग को स्वीकार करता है।

result = Activation(SUMOF(input * weight) + bias)

तो, सक्रियण समारोह मॉडल के सफल सीखने में एक महत्वपूर्ण भूमिका निभाता है। Keras सक्रियण मॉड्यूल में बहुत अधिक सक्रियण फ़ंक्शन प्रदान करता है। मॉड्यूल में उपलब्ध सभी सक्रियणों को जानें।

रैखिक

रैखिक फ़ंक्शन लागू करता है। कुछ नहीं करता।

from keras.models import Sequential 
from keras.layers import Activation, Dense 

model = Sequential() 
model.add(Dense(512, activation = 'linear', input_shape = (784,)))

कहाँ पे, activationपरत के सक्रियण कार्य को संदर्भित करता है। यह केवल फ़ंक्शन के नाम से निर्दिष्ट किया जा सकता है और परत इसी एक्टिविस्ट का उपयोग करेगा।

ELU

घातीय रैखिक इकाई को लागू करता है।

from keras.models import Sequential 
from keras.layers import Activation, Dense 

model = Sequential() 
model.add(Dense(512, activation = 'elu', input_shape = (784,)))

सेलु

स्केल्ड घातीय रैखिक इकाई को लागू करता है।

from keras.models import Sequential 
from keras.layers import Activation, Dense 

model = Sequential() 
model.add(Dense(512, activation = 'selu', input_shape = (784,)))

Relu

रेक्टीफाइड लीनियर यूनिट लागू करता है।

from keras.models import Sequential 
from keras.layers import Activation, Dense 

model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,)))

softmax

सॉफ्टमैक्स फ़ंक्शन लागू करता है।

from keras.models import Sequential 
from keras.layers import Activation, Dense 

model = Sequential() 
model.add(Dense(512, activation = 'softmax', input_shape = (784,)))

softplus

सॉफ्टप्लस फ़ंक्शन लागू करता है।

from keras.models import Sequential 
from keras.layers import Activation, Dense 

model = Sequential() 
model.add(Dense(512, activation = 'softplus', input_shape = (784,)))

softsign

Softsign फ़ंक्शन लागू करता है।

from keras.models import Sequential 
from keras.layers import Activation, Dense 

model = Sequential() 
model.add(Dense(512, activation = 'softsign', input_shape = (784,)))

tanh

हाइपरबोलिक स्पर्शरेखा फ़ंक्शन लागू करता है।

from keras.models import Sequential 
from keras.layers import Activation, Dense 
model = Sequential() 
model.add(Dense(512, activation = 'tanh', input_shape = (784,)))

अवग्रह

सिग्मॉइड फ़ंक्शन को लागू करता है।

from keras.models import Sequential 
from keras.layers import Activation, Dense 

model = Sequential() 
model.add(Dense(512, activation = 'sigmoid', input_shape = (784,)))

hard_sigmoid

हार्ड सिग्मॉइड फ़ंक्शन को लागू करता है।

from keras.models import Sequential 
from keras.layers import Activation, Dense 

model = Sequential() 
model.add(Dense(512, activation = 'hard_sigmoid', input_shape = (784,)))

घातीय

घातीय कार्य को लागू करता है।

from keras.models import Sequential 
from keras.layers import Activation, Dense 

model = Sequential() 
model.add(Dense(512, activation = 'exponential', input_shape = (784,)))

अनु क्रमांक	परतें और विवरण
1	घनी परत Dense layer नियमित रूप से गहराई से जुड़ा तंत्रिका नेटवर्क परत है।
2	ड्रॉपआउट लेयर्स Dropout मशीन लर्निंग में महत्वपूर्ण अवधारणा में से एक है।
3	समतल परतें Flatten इनपुट समतल करने के लिए उपयोग किया जाता है।
4	Reshape Layers Reshape का उपयोग इनपुट के आकार को बदलने के लिए किया जाता है।
5	परमिशन लेयर्स Permute पैटर्न का उपयोग करके इनपुट के आकार को बदलने के लिए भी उपयोग किया जाता है।
6	पुनरावर्तक परतें RepeatVector सेट संख्या के लिए इनपुट को दोहराने के लिए उपयोग किया जाता है, n का समय।
7	लैम्ब्डा लेयर्स Lambda एक अभिव्यक्ति या फ़ंक्शन का उपयोग करके इनपुट डेटा को बदलने के लिए उपयोग किया जाता है।
8	कन्वेंशन लेयर्स केरस में कन्वर्सेशन आधारित एएनएन बनाने के लिए बहुत सारी परतें हैं, जिन्हें कन्वर्सेशन न्यूरल नेटवर्क (सीएनएन) कहा जाता है ।
9	पूलिंग लेयर इसका उपयोग लौकिक डेटा पर अधिकतम पूलिंग ऑपरेशन करने के लिए किया जाता है।
10	स्थानीय रूप से जुड़ी हुई परत स्थानीय रूप से जुड़ी परतें Conv1D परत के समान होती हैं, लेकिन अंतर Conv1D परत वजन साझा किया जाता है, लेकिन यहां वजन अनसोल्ड हैं।
1 1	मर्ज लेयर इसका उपयोग इनपुट की सूची को मर्ज करने के लिए किया जाता है।
12	एम्बेडिंग लेयर यह इनपुट लेयर में एम्बेडिंग ऑपरेशन करता है।