टेन्सरफ़्लो के साथ वर्गीकरण के लिए तंत्रिका नेटवर्क

इस लेख के एक भाग के रूप में प्रकाशित किया गया था डेटा साइंस ब्लॉगथॉन

इस लेख में, मैं एक वर्गीकरण समस्या को हल करने के लिए TensorFlow के साथ तंत्रिका नेटवर्क मॉडल बनाने जा रहा हूं। आइए एक साथ एक्सप्लोर करें कि हम Tensorflow में वर्गीकरण समस्या को कैसे हल कर सकते हैं। लेकिन सबसे पहले, मैं यह सुनिश्चित करना चाहूंगा कि हम इन सवालों के जवाब देने में सक्षम हैं:

तंत्रिका नेटवर्क है?

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

वर्गीकरण क्या है?

वर्गीकरण समस्या में भविष्यवाणी करना शामिल है कि कोई चीज एक वर्ग से संबंधित है या नहीं। दूसरे शब्दों में, इसे करते समय हम यह देखने का प्रयास करते हैं कि कुछ न कुछ है।

वर्गीकरण के प्रकार

• मान लीजिए कि आप भविष्यवाणी करना चाहते हैं कि किसी व्यक्ति को मधुमेह है या नहीं। अगर आप इस तरह की स्थिति का सामना कर रहे हैं, तो दो संभावनाएँ हैं, है ना? कहा जाता है बाइनरी वर्गीकरण।
• मान लीजिए कि आप यह पहचानना चाहते हैं कि फोटो किसी खिलौने की है, किसी व्यक्ति की है या बिल्ली की है, है ना? यह कहा जाता है बहु-श्रेणी वर्गीकरण क्योंकि दो से अधिक विकल्प हैं।
• मान लीजिए आप यह तय करना चाहते हैं कि किसी लेख को कौन सी श्रेणियां निर्दिष्ट की जानी चाहिए। हो तो कहा जाता है बहु-लेबल वर्गीकरण, क्योंकि एक लेख में एक से अधिक श्रेणी नियत की जा सकती है। आइए इस लेख के माध्यम से अपनी व्याख्या लेते हैं। हम इस लेख को "डीप लर्निंग, टेंसरफ्लो, क्लासिफिकेशन" आदि जैसी श्रेणियां प्रदान कर सकते हैं

अब हम आगे बढ़ सकते हैं क्योंकि हम जिस समस्या पर काम कर रहे हैं उसकी एक आम समझ है। तो, यह कोडिंग का समय है। मुझे आशा है कि आप उन्हें मेरे साथ लिख रहे हैं क्योंकि बेहतर होने, कम गलतियाँ करने का एकमात्र तरीका अधिक कोड लिखना है।

हम उन पुस्तकालयों को आयात करना शुरू कर रहे हैं जिनका हम उपयोग करेंगे:

np के रूप में numpy आयात करें pd के रूप में पांडा आयात करें

डेटासट बनाना

काम करने के लिए डेटासेट बनाने का समय आ गया है:

sklearn.datasets से make_circles नमूने आयात करें = 1000 X, y = make_circles (नमूने, शोर = 0.03, random_state = 42)

प्रिंट (x >> [[0.75424625 0.23148074] [-0.75615888 0.15325888]

प्रिंट (वाई) >> [1 1 1 1 0 1 1 1 1 0]

ठीक है, हमने अपने डेटासेट को और अधिक विस्तार से देखा है, लेकिन हम अभी भी इसके बारे में कुछ नहीं जानते हैं, है ना? इसीलिए यहां एक महत्वपूर्ण कदम डेटा के साथ एक होना है, और विज़ुअलाइज़ेशन ऐसा करने का सबसे अच्छा तरीका है।

सर्कल = pd.DataFrame ({'X0' : X[:, 0], 'X1' : X[:, 1], 'लेबल' : y}) Circle.head()

यहां एक सवाल उठता है कि हम किस तरह के लेबल से निपट रहे हैं?

Circle.label.value_counts() >> 1 500 0 500 नाम: लेबल, dtype: int64

ऐसा लगता है कि हम निपट रहे हैं एक द्विआधारी वर्गीकरण समस्या, क्योंकि हमारे पास 2 लेबल (0 और 1) हैं।

plt.scatter(X[:,0], X[:,1], c = y, cmap = plt.cm.RdYlBu)

जैसा कि मैंने ऊपर उल्लेख किया है, डेटा प्राप्त करने का सबसे अच्छा तरीका विज़ुअलाइज़ेशन है। अब प्लॉट खुद कहता है कि हमें कैसा मॉडल बनाना है। हम एक ऐसा मॉडल बनाएंगे जो नीले बिंदुओं को लाल बिंदुओं से अलग करने में सक्षम होगा।

किसी भी तंत्रिका नेटवर्क मॉडल के निर्माण से पहले, हमें अपने इनपुट और आउटपुट सुविधाओं के आकार की जांच करनी चाहिए। वे वही होना चाहिए!

प्रिंट (X.shape, y.shape) Print(len(X), len(y)) >> (1000, 2) (1000,) 1000 1000

हमारे पास प्रत्येक सुविधा के लिए समान मान हैं, लेकिन X का आकार अलग है? क्यों? चलो पता करते हैं।

एक्स [0], वाई [0] >> (सरणी ([0.75424625, 0.23148074]), 1)

ठीक है, हमारे पास 2 y के लिए 1 X विशेषताएँ हैं। जिससे हम बिना किसी परेशानी के आगे बढ़ सकें।

Tensorflow के साथ वर्गीकरण के लिए तंत्रिका नेटवर्क मॉडलिंग में कदम

TensorFlow में एक मॉडल बनाने के लिए निश्चित चरण होते हैं:

• एक मॉडल बनाना - कार्यात्मक या अनुक्रमिक एपीआई का उपयोग करके एक तंत्रिका नेटवर्क की परतों को एक साथ रखें
• एक मॉडल संकलित करना - यह परिभाषित करना कि मॉडल के प्रदर्शन को कैसे मापा जाना चाहिए, और इसे कैसे सुधारना चाहिए (नुकसान कार्य और अनुकूलक)
• एक मोड फिटिंगl - किसी मॉडल को डेटा में पैटर्न खोजने देना

हम अनुक्रमिक एपीआई का उपयोग करेंगे। तो चलो शुरू हो जाओ

tf.random.set_seed(42)

model_1 = tf.keras.अनुक्रमिक ([tf.keras.layers.Dense (1)])

 ऑप्टिमाइज़र = tf.keras.optimizers.SGD (), #SGD का मतलब स्टोचैस्टिक ग्रेडिएंट डिसेंट मेट्रिक्स = ['सटीकता']) मॉडल_1.फिट (X, y, epochs = 5)

>> युग 1/5 32/32 [=================================] - 1s 1ms/चरण - हानि: 2.8544 - सटीकता: 0.4600 युग 2/5 32/32 [==============================] - 0s 2ms/चरण - हानि : 0.7131 - सटीकता: 0.5430 युग 3/5 32/32 [=============================] - 0s 2ms/चरण - हानि: 0.6973 - सटीकता: 0.5090 युग 4/5 32/32 [=============================] - 0s 2ms /चरण - हानि: 0.6950 - सटीकता: 0.5010 युग 5/5 32/32 [=================================] - 0s 1ms/चरण - हानि: 0.6942 - सटीकता: 0.4830

मॉडल की सटीकता लगभग 50% है जिसका मूल रूप से मतलब है कि मॉडल सिर्फ अनुमान लगा रहा है, आइए इसे लंबे समय तक प्रशिक्षित करने का प्रयास करें

मॉडल_1.फिट (एक्स, वाई, युग = 200, वर्बोज़ = 0) # हम प्रशिक्षण प्रक्रिया को हटाने के लिए वर्बोज़ = 0 सेट करते हैं) मॉडल_1.मूल्यांकन (एक्स, वाई)

>> 32/32 [==============================] - 0s 1ms/चरण - हानि: 0.6935 - सटीकता: 0.5000 [0.6934829950332642, 0.5]

200 युगों के बाद भी, यह अभी भी ऐसा प्रदर्शन करता है जैसे यह अनुमान लगा रहा हो कि अगला चरण अधिक परतों को जोड़ना और लंबे समय तक प्रशिक्षण देना है।

tf.random.set_seed(42)

मॉडल_2 = tf.keras.अनुक्रमिक ([tf.keras.layers.Dense (1), tf.keras.layers.Dense (1)]) model_2.compile (हानि = tf.keras.losses.BinaryCrossenttropy (), अनुकूलक = tf.keras.optimizers.SGD(), मेट्रिक्स = ['accuracy']) model_2.fit(X, y, epochs = 100, वर्बोज़ = 0)

 मॉडल_2. मूल्यांकन (एक्स, वाई)

>> 32/32 [==============================] - 0s 1ms/चरण - हानि: 0.6933 - सटीकता: 0.5000 [0.6933314800262451, 0.5]

फिर भी रत्ती भर भी बदलाव नहीं है, लगता है कुछ गड़बड़ है।

Tensorflow के साथ वर्गीकरण मॉडल के लिए तंत्रिका नेटवर्क में सुधार

किसी मॉडल को विभिन्न चरणों में सुधारने के विभिन्न तरीके हैं:

• मॉडल बनाना – अधिक परतें जोड़ें, छिपी हुई इकाइयों (न्यूरॉन्स) की संख्या बढ़ाएं, प्रत्येक परत के सक्रियण कार्यों को बदलें
• एक मॉडल का संकलन – विभिन्न अनुकूलन कार्यों का प्रयास करें, उदाहरण के लिए एसजीडी() के बजाय एडम() का उपयोग करें।
• एक मॉडल फिट करना - हम युगों की संख्या बढ़ा सकते हैं

आइए कोशिश करते हैं अधिक न्यूरॉन्स जोड़ें और कोशिश ऐडम अनुकूलक

tf.random.set_seed(42)

model_3 = tf.keras.Sequential([tf.keras.layers.Dense(100), # 100 सघन न्यूरॉन्स जोड़ें tf.keras.layers.Dense(10), # 10 न्यूरॉन्स tf.keras.layers.Dense के साथ एक और परत जोड़ें (1) ]) model_3.compile(loss=tf.keras.losses.BinaryCrossenttropy(),Optimizer=tf.keras.optimizers.Adam(), मेट्रिक्स=['accuracy']) model_3.fit(X, y, epochs) =100, क्रिया = 0)

मॉडल_3.मूल्यांकन (एक्स, वाई) >> 32/32 [==============================] - 0s 1ms/चरण - हानि: 0.6980 - सटीकता: 0.5080 [0.6980254650115967, 0.5080000162124634]

अब भी नहीं सुधर रहे! आइए डेटा की कल्पना करें कि क्या गलत हो रहा है।

तंत्रिका नेटवर्क मॉडल की कल्पना करें

हमारे मॉडल की भविष्यवाणियों की कल्पना करने के लिए हम एक फंक्शन प्लॉट_डिसीजन_बाउंड्री () बनाने जा रहे हैं जो:

• एक प्रशिक्षित मॉडल, सुविधाएँ और लेबल लेता है
• भिन्न X मानों का एक मेशग्रिड बनाएँ।
• मेशग्रिड में भविष्यवाणियां करता है।
• लाइन के साथ भविष्यवाणियों को प्लॉट करें।

नोट:  यह फ़ंक्शन दो संसाधनों से अनुकूलित किया गया है:

CS231n एमएल मूल बातें के साथ बनाया गया 

def प्लॉट_डिसीजन_बाउंड्री (मॉडल, एक्स, वाई): # प्लॉट की अक्ष सीमाओं को परिभाषित करें और एक मेशग्रिड बनाएं x_min, x_max = X[:, 0].min() - 0.1, X[:, 0].max() + 0.1 y_min, y_max = X[:, 1].min() - 0.1, X[:, 1].max() + 0.1 xx, yy = np.meshgrid(np.linspace(x_min, x_max, 100), np .linspace(y_min, y_max, 100)) # X मान बनाएं (हम इन सभी पर भविष्यवाणी करने जा रहे हैं) x_in = np.c_[xx.ravel(), yy.ravel()] # प्रशिक्षित का उपयोग करके भविष्यवाणियां करें मॉडल y_pred = model.predict(x_in) # मल्टी-क्लास के लिए चेक करें

 if len(y_pred[0]) > 1: Print("Doing multiclassclassification...") # हमें अपनी भविष्यवाणियों को प्लॉट करने के लिए तैयार करने के लिए उन्हें फिर से आकार देना होगा y_pred = np.argmax(y_pred, axis=1).reshape( xx.shape) और: प्रिंट ("बाइनरी वर्गीकरण करना ...") y_pred = np.round(y_pred).reshape(xx.shape) # प्लॉट डिसीजन बाउंड्री plt.contourf(xx, yy, y_pred, cmap=plt. cm.RdYlBu, alpha=0.7) plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.RdYlBu) plt.xlim(xx.min( ), xx.max ()) plt.ylim (yy.min (), yy.max ()) प्लॉट_डिसीजन_बाउंड्री (मॉडल_3, एक्स, वाई)

यह रहा! फिर से विज़ुअलाइज़ेशन हमें दिखाता है कि क्या गलत है और क्या करना है? हमारा मॉडल डेटा के माध्यम से एक सीधी रेखा खींचने की कोशिश कर रहा है, लेकिन हमारा डेटा एक सीधी रेखा से वियोज्य नहीं है। हमारी वर्गीकरण समस्या में कुछ कमी है? यह क्या है?

यह अरैखिकता है! हमें कुछ अरेखीय रेखाओं की आवश्यकता है। अब आप भ्रमित हो सकते हैं, यदि आप सोच रहे हैं कि आपने इस तरह का कार्य पहले नहीं देखा है, तो आप गलत हैं, क्योंकि आपके पास है। आइए उन्हें नेत्रहीन देखें। विज़ुअलाइज़ेशन हमेशा बेहतर काम करता है!

Neural Network में कुछ सक्रियण कार्य हैं जिनका हम उपयोग कर सकते हैं, जैसे रेलु, अवग्रह. चलिए थोड़ा बनाते हैं खिलौना टेंसर और उस पर उन कार्यों की जाँच करें।

तंत्रिका नेटवर्क के लिए सक्रियण कार्य

A = tf.cast(tf.range(-12,12), tf.float32) Print(A) >> tf.Tensor( [-12. -11. -10. -9. -8. -7. - 6. -5. -4. -3. -2. -1. 0. 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11.], आकार = (24,), dtype=float32)

आइए देखें कि हमारा खिलौना टेंसर कैसा दिखता है?

plt.plot (ए)

ऐसा लगता है, सीधी रेखा! 

अब आइए सक्रियण कार्यों को फिर से देखें कि वे हमारे टेंसर के साथ क्या करते हैं?

अवग्रह:

def सिग्मॉइड (एक्स): वापसी 1 / (1 + tf.exp (-x)) सिग्मॉइड (ए) plt.plot (सिग्मॉइड (ए))

एक गैर-सीधी रेखा!

रेलू:

def relu (x): वापसी tf.अधिकतम (0, x) plt.plot (relu (ए))

एक और गैर-सीधी रेखा!

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

X_train, y_train = X[:800], y[:800] X_test, y_test = X[800:], y[800:] X_train.shape, X_test.shape >>((800, 2), (200, 2) ))

tf.random.set_seed(42)

model_4 = tf.keras.Sequential([tf.keras.layers.Dense(4, सक्रियण = 'relu'), # हम इसे सही कर सकते हैं "tf.keras.activeations.relu" भी tf.keras.layers.Dense(4) , सक्रियण = 'रिल्यू'), tf.keras.layers.Dense (1, सक्रियण = 'सिग्मॉइड') ]) model_4.compile (हानि = tf.keras.loss.binary_crossentropy, अनुकूलक = tf.keras.optimizers.Adam ( lr = 0.01), मेट्रिक्स = ['सटीकता']) model_4.fit(X_train, y_train, epochs = 25, वर्बोज़ = 0)

मॉडल का मूल्यांकन करें

हानि, सटीकता = मॉडल_4. मूल्यांकन (X_test, y_test) प्रिंट (एफ 'परीक्षण सेट पर मॉडल हानि: {हानि}') प्रिंट (एफ 'परीक्षण सेट पर मॉडल सटीकता: {100 * सटीकता}')

>> 7/7 [==============================] - 0s 2ms/चरण - हानि: 0.1247 - सटीकता: 1.0000 परीक्षण सेट पर मॉडल हानि: 0.1246885135769844 परीक्षण सेट पर मॉडल सटीकता: 100.0

plt.figure(figsize=(12, 6)) plt.subplot(1, 2, 1) plt.title("ट्रेन") प्लॉट_डिसीजन_बाउंड्री(मॉडल_4, एक्स=एक्स_ट्रेन, y=y_train) plt.सबप्लॉट(1, 2, 2) plt.title ("टेस्ट") प्लॉट_डिसीजन_बाउंड्री (मॉडल_4, एक्स = एक्स_टेस्ट, वाई = वाई_टेस्ट) पीएलटी.शो ()

आइए इस लेख में हम किस बारे में बात कर रहे हैं, इस पर एक संक्षिप्त नज़र डालें। साथ में हमने देखा कि TensorFlow के साथ तंत्रिका नेटवर्क में एक वर्गीकरण कार्य कैसे किया जाए। हमने पहले तरीके से 3 मॉडल बनाए जो मन में आए, और विज़ुअलाइज़ेशन की मदद से हमने महसूस किया कि हम कहाँ गलत थे, हमने रैखिकता, गैर-रैखिकता की खोज की और अंत में, हम एक सामान्यीकृत मॉडल बनाने में कामयाब रहे। मैं इन सभी कोड्स के साथ जो दिखाने की कोशिश कर रहा था और मैं जो कदम उठा रहा था वह यह था कि कुछ भी 100 प्रतिशत सटीक या निश्चित नहीं है, सब कुछ हर दिन बदलता रहता है। यह अनुमान लगाने के लिए कि किस प्रकार के डेटा में आपको किस समस्या का सामना करना पड़ सकता है और यह देखने के लिए कि कौन से संयोजन बेहतर परिणाम देते हैं, आपको केवल बहुत अधिक कोड लिखने और अनुभव प्राप्त करने की आवश्यकता है।

मुझे उम्मीद है कि लेख आपके लिए थोड़ा मददगार था और कुछ योगदान दिया।

इस लेख में दिखाया गया मीडिया एनालिटिक्स विद्या के स्वामित्व में नहीं है और लेखक के विवेक पर उपयोग किया जाता है

सम्बंधित

स्रोत: https://www.analyticsvidhya.com/blog/2021/11/neural-network-for-classification-with-tensorflow/