केरास ट्यूटोरियल

केरास क्या है?

Keras एक ओपन सोर्स न्यूरल नेटवर्क लाइब्रेरी है जो Python जो थेनो या टेन्सरफ्लो के ऊपर चलता है। इसे मॉड्यूलर, तेज़ और उपयोग में आसान बनाने के लिए डिज़ाइन किया गया है। इसे Google इंजीनियर फ़्राँस्वा चोलेट ने विकसित किया था। केरास निम्न-स्तरीय गणना को संभाल नहीं पाता है। इसके बजाय, यह इसे करने के लिए एक अन्य लाइब्रेरी का उपयोग करता है, जिसे "बैकएंड" कहा जाता है।

केरास निम्न-स्तरीय API के लिए उच्च-स्तरीय API आवरण है, जो TensorFlow, CNTK या Theano के शीर्ष पर चलने में सक्षम है। केरास उच्च-स्तरीय API हमारे द्वारा मॉडल बनाने, परतों को परिभाषित करने या कई इनपुट-आउटपुट मॉडल सेट करने के तरीके को संभालता है। इस स्तर पर, केरास हमारे मॉडल को लॉस और ऑप्टिमाइज़र फ़ंक्शन, फ़िट फ़ंक्शन के साथ प्रशिक्षण प्रक्रिया के साथ संकलित करता है। केरास में Python निम्न-स्तरीय API को संभाल नहीं पाता है जैसे कि कम्प्यूटेशनल ग्राफ बनाना, टेंसर या अन्य चर बनाना, क्योंकि इसे "बैकएंड" इंजन द्वारा नियंत्रित किया गया है।

बैकएंड क्या है?

बैकएंड केरास में एक शब्द है जो टेंसरफ्लो या थेनो जैसी अन्य लाइब्रेरी की मदद से टेंसर उत्पाद, कन्वोल्यूशन और कई अन्य चीजों जैसे सभी निम्न-स्तरीय गणना करता है। इसलिए, "बैकएंड इंजन" मॉडल की गणना और विकास करेगा। टेंसरफ्लो डिफ़ॉल्ट "बैकएंड इंजन" है लेकिन हम इसे कॉन्फ़िगरेशन में बदल सकते हैं।

थीनो, टेन्सरफ्लो, और CNTK बैकएंड

थेनो एक ओपन सोर्स प्रोजेक्ट है जिसे मॉन्ट्रियल विश्वविद्यालय, क्यूबेक, कनाडा में MILA समूह द्वारा विकसित किया गया था। यह पहला व्यापक रूप से इस्तेमाल किया जाने वाला फ्रेमवर्क था। यह एक है Python लाइब्रेरी जो Numpy या Scipy का उपयोग करके गणितीय संचालन के लिए बहु-आयामी सरणियों में मदद करती है। Theano तेजी से गणना के लिए GPU का उपयोग कर सकता है, यह ग्रेडिएंट की गणना के लिए स्वचालित रूप से प्रतीकात्मक ग्राफ़ भी बना सकता है। अपनी वेबसाइट पर, Theano दावा करता है कि यह संख्यात्मक रूप से अस्थिर अभिव्यक्तियों को पहचान सकता है और उन्हें अधिक स्थिर एल्गोरिदम के साथ गणना कर सकता है, यह हमारे अस्थिर अभिव्यक्तियों के लिए बहुत उपयोगी है।

दूसरी ओर, Tensorflow डीप लर्निंग फ्रेमवर्क में उभरता सितारा है। Google की Brain टीम द्वारा विकसित यह सबसे लोकप्रिय डीप लर्निंग टूल है। बहुत सारी विशेषताओं के साथ, और शोधकर्ता डीप लर्निंग उद्देश्यों के लिए इस फ्रेमवर्क को विकसित करने में मदद करने के लिए योगदान करते हैं।

केरास के लिए एक और बैकएंड इंजन है Microsoft कॉग्निटिव टूलकिट या CNTK. यह एक ओपन-सोर्स डीप लर्निंग फ्रेमवर्क है जिसे किसके द्वारा विकसित किया गया था Microsoft टीम। यह बड़े पैमाने पर डीप लर्निंग मॉडल को प्रशिक्षित करने के लिए मल्टी GPU या मल्टी-मशीन पर चल सकता है। कुछ मामलों में, CNTK को Tensorflow या Theano जैसे अन्य फ्रेमवर्क की तुलना में तेज़ बताया गया था। इस Keras CNN ट्यूटोरियल में आगे, हम Theano, TensorFlow और CNTK के बैकएंड की तुलना करेंगे।

बैकएंड की तुलना

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

अन्य बेंचमार्क परीक्षण द्वारा किया जाता है जसमीत भाटियाउन्होंने बताया कि कुछ परीक्षणों में थेनो टेन्सरफ्लो से धीमा है। लेकिन परीक्षण किए गए प्रत्येक नेटवर्क के लिए समग्र सटीकता लगभग समान है।

तो, थेनो, टेन्सरफ्लो और सीटीके के बीच यह स्पष्ट है कि टेन्सरफ्लो थेनो से बेहतर है। टेन्सरफ्लो के साथ, गणना का समय बहुत कम है और सीएनएन दूसरों की तुलना में बेहतर है।

इस केरास में अगला Python ट्यूटोरियल में, हम केरास और टेंसरफ्लो के बीच अंतर के बारे में जानेंगे (केरास बनाम टेन्सरफ्लो).

केरास बनाम टेन्सरफ्लो

पैरामीटर्स	Keras	टेन्सलफ्लो
प्रकार	उच्च-स्तरीय API आवरण	निम्न-स्तरीय API
जटिलता	यदि आप उपयोग करना आसान है Python भाषा	आपको Tensorflow के कुछ फ़ंक्शन का उपयोग करने का सिंटैक्स सीखने की आवश्यकता है
उद्देश्य	मानक परतों के साथ मॉडल बनाने के लिए तीव्र परिनियोजन	आपको मनमाना कम्प्यूटेशनल ग्राफ या मॉडल परतें बनाने की अनुमति देता है
टूल्स	TFDBG जैसे अन्य API डीबग टूल का उपयोग करता है	आप Tensorboard विज़ुअलाइज़ेशन टूल का उपयोग कर सकते हैं
समुदाय	बड़े सक्रिय समुदाय	बड़े सक्रिय समुदाय और व्यापक रूप से साझा संसाधन

केरास के लाभ

तेजी से तैनाती और समझने में आसान

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

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

model = Sequential()
model.add(Dense(64, activation='relu', input_dim=50)) #input shape of 50
model.add(Dense(28, activation='relu')) #input shape of 50
model.add(Dense(10, activation='softmax'))

API के अनुकूल होने के कारण, हम प्रक्रिया को आसानी से समझ सकते हैं। एक सरल फ़ंक्शन के साथ कोड लिखना और कई पैरामीटर सेट करने की आवश्यकता नहीं है।

बड़ा सामुदायिक समर्थन

ऐसे बहुत से AI समुदाय हैं जो अपने डीप लर्निंग फ्रेमवर्क के लिए केरास का उपयोग करते हैं। उनमें से कई अपने कोड और ट्यूटोरियल आम जनता के लिए प्रकाशित करते हैं।

एकाधिक बैकएंड रखें

आप केरास के साथ अपने बैकएंड के रूप में टेन्सरफ्लो, सीएनटीके और थेनो चुन सकते हैं। आप अपनी ज़रूरतों के हिसाब से अलग-अलग प्रोजेक्ट के लिए अलग-अलग बैकएंड चुन सकते हैं। हर बैकएंड का अपना अलग फ़ायदा होता है।

क्रॉस-प्लेटफ़ॉर्म और आसान मॉडल परिनियोजन

विभिन्न समर्थित उपकरणों और प्लेटफार्मों के साथ, आप किसी भी डिवाइस पर केरास को तैनात कर सकते हैं जैसे

कोरएमएल के साथ आईओएस
Android टेन्सरफ्लो के साथ Android,
.js समर्थन वाला वेब ब्राउज़र
क्लाउड इंजन
रास्पबेरी पाई

मल्टी GPU समर्थन

आप केरास को एक ही GPU पर प्रशिक्षित कर सकते हैं या एक साथ कई GPU का उपयोग कर सकते हैं। क्योंकि केरास में डेटा समानांतरता के लिए अंतर्निहित समर्थन है, इसलिए यह बड़ी मात्रा में डेटा को संसाधित कर सकता है और इसे प्रशिक्षित करने के लिए आवश्यक समय को कम कर सकता है।

केरास के नुकसान

निम्न-स्तरीय API को संभाल नहीं सकता

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

केरास स्थापित करना

इस अनुभाग में, हम केरास को स्थापित करने के लिए उपलब्ध विभिन्न तरीकों पर गौर करेंगे

प्रत्यक्ष स्थापना या वर्चुअल वातावरण

कौन सा बेहतर है? वर्तमान पायथन में सीधे इंस्टॉल करें या वर्चुअल वातावरण का उपयोग करें? यदि आपके पास कई प्रोजेक्ट हैं तो मैं वर्चुअल वातावरण का उपयोग करने का सुझाव देता हूं। जानना चाहते हैं क्यों? ऐसा इसलिए है क्योंकि अलग-अलग प्रोजेक्ट केरास लाइब्रेरी के अलग-अलग संस्करण का उपयोग कर सकते हैं।

उदाहरण के लिए, मेरे पास एक परियोजना है जिसके लिए Python 3.5 पुराने केरास-थेनो बैकएंड के साथ ओपनसीवी 3.3 का उपयोग कर रहा हूं, लेकिन अन्य प्रोजेक्ट में मुझे केरास के नवीनतम संस्करण और टेन्सरफ्लो के बैकएंड का उपयोग करना होगा। Python 3.6.6 समर्थन करते हैं

हम नहीं चाहते कि केरास लाइब्रेरी एक दूसरे से टकराएँ, है न? इसलिए हम एक विशिष्ट प्रकार की लाइब्रेरी के साथ प्रोजेक्ट को स्थानीयकृत करने के लिए एक वर्चुअल एनवायरनमेंट का उपयोग करते हैं या हम अपने लिए गणना करने के लिए क्लाउड सर्विस जैसे किसी अन्य प्लेटफ़ॉर्म का उपयोग कर सकते हैं जैसे Amazon वेब सेवा.

केरास को स्थापित करना Amazon वेब सेवा (AWS)

Amazon वेब सर्विस एक ऐसा प्लेटफॉर्म है जो शोधकर्ताओं या किसी अन्य उद्देश्य के लिए क्लाउड कंप्यूटिंग सेवा और उत्पाद प्रदान करता है। AWS अपने हार्डवेयर, नेटवर्किंग, डेटाबेस आदि को किराए पर देता है ताकि हम इसे सीधे इंटरनेट से इस्तेमाल कर सकें। डीप लर्निंग उद्देश्य के लिए लोकप्रिय AWS सेवाओं में से एक है Amazon मशीन इमेज डीप लर्निंग सर्विस या डीएल

AWS का उपयोग कैसे करें, इस पर विस्तृत निर्देशों के लिए, यह देखें ट्यूटोरियल

एएमआई पर ध्यान दें: आपके पास निम्नलिखित एएमआई उपलब्ध होगी

AWS डीप लर्निंग AMI, AWS EC2 सेवा में एक वर्चुअल वातावरण है जो शोधकर्ताओं या चिकित्सकों को डीप लर्निंग के साथ काम करने में मदद करता है। DLAMI छोटे CPU इंजन से लेकर उच्च-शक्ति वाले मल्टी GPU इंजन तक प्री-कॉन्फ़िगर किए गए CUDA, cuDNN के साथ उपलब्ध है, और कई तरह के डीप लर्निंग फ्रेमवर्क के साथ आता है।

यदि आप इसे तुरंत उपयोग करना चाहते हैं, तो आपको डीप लर्निंग एएमआई चुनना चाहिए क्योंकि यह लोकप्रिय डीप लर्निंग फ्रेमवर्क के साथ पहले से इंस्टॉल आता है।

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

केरास को कैसे स्थापित करें Amazon SageMaker

Amazon सेजमेकर एक डीप लर्निंग प्लेटफॉर्म है जो आपको सर्वोत्तम एल्गोरिदम के साथ डीप लर्निंग नेटवर्क को प्रशिक्षित करने और तैनात करने में मदद करता है।

एक शुरुआती के रूप में, यह केरास का उपयोग करने का अब तक का सबसे आसान तरीका है। नीचे केरास को अपने कंप्यूटर पर इंस्टॉल करने की प्रक्रिया बताई गई है। Amazon सेजमेकर:

चरण 1) खोलें Amazon SageMaker

पहले चरण में, खोलें Amazon साधु बनानेवाला कंसोल पर जाएं और Create notebook instance पर क्लिक करें।

चरण 2) विवरण दर्ज करें

अपनी नोटबुक का नाम दर्ज करें.
एक IAM रोल बनाएँ। यह एक AMI रोल बनाएगा Amazon प्रारूप में आईएएम की भूमिका Amazonसेजमेकर-एक्सिक्यूशनरोल-YYYYMMDD|HHmmSS.
अंत में, नोटबुक इंस्टेंस बनाएँ चुनें। कुछ क्षणों के बाद, Amazon सेजमेकर ने एक नोटबुक इंस्टैंस लॉन्च किया।

नोट: यदि आप अपने VPC से संसाधनों तक पहुँचना चाहते हैं, तो डायरेक्ट इंटरनेट एक्सेस को सक्षम के रूप में सेट करें। अन्यथा, इस नोटबुक इंस्टेंस में इंटरनेट एक्सेस नहीं होगा, इसलिए मॉडल को प्रशिक्षित या होस्ट करना असंभव है

चरण 3) इंस्टैंस लॉन्च करें

इंस्टैंस लॉन्च करने के लिए ओपन पर क्लिक करें

चरण 4) कोडिंग शुरू करें

In Jupyter, नया> conda_tensorflow_p36 पर क्लिक करें और आप कोड करने के लिए तैयार हैं

लिनक्स में केरास स्थापित करें

टेन्सरफ्लो के बैकएंड इंजन के साथ केरास को सक्षम करने के लिए, हमें पहले टेन्सरफ्लो को इंस्टॉल करना होगा। सीपीयू (कोई जीपीयू नहीं) के साथ टेन्सरफ्लो को इंस्टॉल करने के लिए यह कमांड चलाएँ

pip install --upgrade tensorflow

यदि आप tensorflow के लिए GPU समर्थन सक्षम करना चाहते हैं तो आप इस कमांड का उपयोग कर सकते हैं

pip install --upgrade tensorflow-gpu

चलो चेक इन करें Python टाइप करके देखें कि क्या हमारी स्थापना सफल है

user@user:~$ python
Python 3.6.4 (default, Mar 20 2018, 11:10:20) 
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import tensorflow
>>>

यदि कोई त्रुटि संदेश नहीं है, तो स्थापना प्रक्रिया सफल है

केरास स्थापित करें

Tensorflow को इंस्टॉल करने के बाद, चलिए keras को इंस्टॉल करना शुरू करते हैं। टर्मिनल में यह कमांड टाइप करें

pip install keras

यह केरास और इसकी सभी निर्भरताओं को स्थापित करना शुरू कर देगा। आपको कुछ इस तरह दिखना चाहिए:

अब हमारे सिस्टम में Keras इंस्टॉल हो गया है!

सत्यापित किया जा रहा

केरास का उपयोग शुरू करने से पहले, हमें कॉन्फ़िगरेशन फ़ाइल खोलकर जांच करनी चाहिए कि क्या हमारे केरास बैकएंड के रूप में टेन्सरफ्लो का उपयोग करते हैं:

gedit ~/.keras/keras.json

आपको कुछ इस तरह दिखना चाहिए

{
    "floatx": "float32",
    "epsilon": 1e-07,
    "backend": "tensorflow",
    "image_data_format": "channels_last"
}

जैसा कि आप देख सकते हैं, “बैकएंड” टेंसरफ़्लो का उपयोग करता है। इसका मतलब है कि केरास अपने बैकएंड के रूप में टेंसरफ़्लो का उपयोग कर रहा है जैसा कि हमने उम्मीद की थी

और अब इसे टर्मिनल पर टाइप करके चलाएँ

user@user:~$ python3
Python 3.6.4 (default, Mar 20 2018, 11:10:20) 
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import keras
Using TensorFlow backend.
>>>

केरास को कैसे स्थापित करें Windows

इससे पहले कि हम स्थापित करें टेन्सलफ्लो और केरास, हमें स्थापित करना चाहिए Python, pip, और virtualenv. यदि आपने पहले से ही ये लाइब्रेरीज़ इंस्टॉल कर ली हैं, तो आपको अगले चरण पर जाना चाहिए, अन्यथा यह करें:

स्थापित करें Python 3 यहाँ से डाउनलोड करके संपर्क

पाइप चलाकर स्थापित करें इसका

इस कमांड के साथ virtualenv स्थापित करें

pip3 install –U pip virtualenv

स्थापित करें Microsoft दृश्य C++ 2015 पुनर्वितरणीय अद्यतन 3

Visual Studio डाउनलोड साइट पर जाएँ https://www.microsoft.com/en-us/download/details.aspx?id=53587
पुनर्वितरण योग्य और निर्माण उपकरण चुनें
डाउनलोड और स्थापित करें Microsoft दृश्य C++ 2015 पुनर्वितरणीय अद्यतन 3

फिर इस स्क्रिप्ट को चलाएँ

pip3 install virtualenv

वर्चुअल वातावरण सेटअप करें

इसका उपयोग कार्य प्रणाली को मुख्य प्रणाली से अलग करने के लिए किया जाता है।

virtualenv –-system-site-packages –p python3 ./venv

वातावरण को सक्रिय करें

.\venv\Scripts\activate

वातावरण तैयार करने के बाद, Tensorflow और Keras की स्थापना Linux की तरह ही रहती है। इस डीप लर्निंग विद केरस ट्यूटोरियल में आगे, हम डीप लर्निंग के लिए केरस की बुनियादी बातों के बारे में जानेंगे।

डीप लर्निंग के लिए केरास फंडामेंटल्स

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

यहाँ अनुक्रमिक मॉडल बनाने का तरीका और डीप लर्निंग में आमतौर पर इस्तेमाल की जाने वाली कुछ परतें बताई गई हैं

1. अनुक्रमिक मॉडल

from keras.models import Sequential
from keras.layers import Dense, Activation,Conv2D,MaxPooling2D,Flatten,Dropout

model = Sequential()

2. कन्वोल्यूशनल परत

यह एक केरास है Python 320x320x3 के इनपुट आकार के साथ इनपुट परत के रूप में कन्वोल्यूशनल परत का उदाहरण, 48×3 आकार के 3 फिल्टर के साथ और सक्रियण फ़ंक्शन के रूप में ReLU का उपयोग करें।

input_shape=(320,320,3) #this is the input shape of an image 320x320x3
model.add(Conv2D(48, (3, 3), activation='relu', input_shape= input_shape))

एक अन्य प्रकार है

model.add(Conv2D(48, (3, 3), activation='relu'))

3. मैक्सPoolinजी परत

इनपुट प्रतिनिधित्व को डाउनसैंपल करने के लिए, MaxPool2d का उपयोग करें और कर्नेल आकार निर्दिष्ट करें

model.add(MaxPooling2D(pool_size=(2, 2)))

4. सघन परत

केवल आउटपुट आकार निर्दिष्ट करके एक पूर्णतः कनेक्टेड परत जोड़ना

model.add(Dense(256, activation='relu'))

5. ड्रॉपआउट परत

50% संभावना के साथ ड्रॉपआउट परत जोड़ना

model.add(Dropout(0.5))

संकलन, प्रशिक्षण और मूल्यांकन

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

model.compile(loss='mean_squared_error', optimizer='adam')

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

model.fit(X_train, X_train, batch_size=32, epochs=10, validation_data=(x_val, y_val))

हमारा अंतिम चरण परीक्षण डेटा के साथ मॉडल का मूल्यांकन करना है।

score = model.evaluate(x_test, y_test, batch_size=32)

आइए सरल रेखीय प्रतिगमन का उपयोग करके देखें

import keras
from keras.models import Sequential
from keras.layers import Dense, Activation
import numpy as np
import matplotlib.pyplot as plt 
 
x = data = np.linspace(1,2,200)
y = x*4 + np.random.randn(*x.shape) * 0.3


model = Sequential()
model.add(Dense(1, input_dim=1, activation='linear'))

model.compile(optimizer='sgd', loss='mse', metrics=['mse'])

weights = model.layers[0].get_weights()
w_init = weights[0][0][0]
b_init = weights[1][0]
print('Linear regression model is initialized with weights w: %.2f, b: %.2f' % (w_init, b_init)) 


model.fit(x,y, batch_size=1, epochs=30, shuffle=False)

weights = model.layers[0].get_weights()
w_final = weights[0][0][0]
b_final = weights[1][0]
print('Linear regression model is trained to have weight w: %.2f, b: %.2f' % (w_final, b_final))

predict = model.predict(data)

plt.plot(data, predict, 'b', data , y, 'k.')
plt.show()

डेटा को प्रशिक्षित करने के बाद, आउटपुट इस तरह दिखना चाहिए

प्रारंभिक वजन के साथ

Linear regression model is initialized with weights w: 0.37, b: 0.00

और अंतिम वजन

Linear regression model is trained to have weight w: 3.70, b: 0.61

केरास में पूर्व-प्रशिक्षित मॉडल को बेहतर बनाना और उनका उपयोग कैसे करें

हम फाइन ट्यून मॉडल का उपयोग क्यों करते हैं और इसका उपयोग कब करते हैं

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

उदाहरण के लिए, यदि हम वर्गीकरण समस्या को हल करने के लिए अपने स्वयं के केरास मॉडल को प्रशिक्षित करना चाहते हैं, लेकिन हमारे पास केवल थोड़ी मात्रा में डेटा है, तो हम इसका उपयोग करके हल कर सकते हैं लर्निंग ट्रांसफर + फ़ाइन-ट्यूनिंग विधि.

पहले से प्रशिक्षित नेटवर्क और भार का उपयोग करके हमें पूरे नेटवर्क को प्रशिक्षित करने की आवश्यकता नहीं है। हमें केवल अंतिम परत को प्रशिक्षित करने की आवश्यकता है जिसका उपयोग हमारे कार्य को हल करने के लिए किया जाता है, जिसे हम फाइन-ट्यूनिंग विधि कहते हैं।

नेटवर्क मॉडल तैयारी

पूर्व-प्रशिक्षित मॉडल के लिए, हम विभिन्न प्रकार के मॉडल लोड कर सकते हैं जो केरास की लाइब्रेरी में पहले से मौजूद हैं, जैसे:

वीजीजी 16
आरंभV3
रेसनेट
मोबाइलनेट
Xception
इनसेप्शनResNetV2

लेकिन इस प्रक्रिया में, हम VGG16 नेटवर्क मॉडल और मॉडल के लिए अपने वजन के रूप में इमेजनेट का उपयोग करेंगे। हम छवियों का उपयोग करके 8 विभिन्न प्रकार की कक्षाओं को वर्गीकृत करने के लिए एक नेटवर्क को ठीक करेंगे। कागल प्राकृतिक छवियाँ डेटासेट

VGG16 मॉडल आर्किटेक्चर

स्रोत

AWS S3 बकेट पर अपना डेटा अपलोड करना

हमारी प्रशिक्षण प्रक्रिया के लिए, हम 8 अलग-अलग वर्गों जैसे हवाई जहाज, कार, बिल्ली, कुत्ता, फूल, फल, मोटरबाइक और व्यक्ति से प्राकृतिक छवियों की एक तस्वीर का उपयोग करेंगे। सबसे पहले, हमें अपना डेटा अपलोड करना होगा Amazon एस3 बकेट.

Amazon S3 बाल्टी

चरण 1) अपने S3 खाते में लॉगिन करने के बाद, आइए क्लॉकिंग द्वारा एक बकेट बनाएं बाल्टी बनाएँ

चरण 2) अब अपने अकाउंट के अनुसार बकेट का नाम और अपना क्षेत्र चुनें। सुनिश्चित करें कि बकेट का नाम उपलब्ध है। उसके बाद क्लिक करें बनाएँ.

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

चरण 4) अब आप अपने बकेट में अपना प्रशिक्षण डेटा अपलोड करना शुरू करें। यहाँ मैं tar.gz फ़ाइल अपलोड करूँगा जिसमें प्रशिक्षण और परीक्षण प्रक्रिया के लिए चित्र शामिल हैं।

चरण 5) अब अपनी फ़ाइल पर क्लिक करें और कॉपी करें संपर्क ताकि हम इसे डाउनलोड कर सकें.

डेटा तैयारी

हमें Keras ImageData का उपयोग करके अपना प्रशिक्षण डेटा तैयार करना होगाGenerator.

सबसे पहले आपको S3 बकेट से अपनी फ़ाइल के लिंक के साथ wget का उपयोग करके डाउनलोड करना होगा।

!wget https://s3.us-east-2.amazonaws.com/naturalimages02/images.tar.gz		
!tar -xzf images.tar.gz

डेटा डाउनलोड करने के बाद आइए प्रशिक्षण प्रक्रिया शुरू करें।

from keras.preprocessing.image import ImageDataGenerator
import numpy as np
import matplotlib.pyplot as plt

train_path = 'images/train/'
test_path = 'images/test/'
batch_size = 16
image_size = 224
num_class = 8


train_datagen = ImageDataGenerator(validation_split=0.3,
                                   shear_range=0.2,
                                   zoom_range=0.2,
                                   horizontal_flip=True)

train_generator = train_datagen.flow_from_directory(
                        directory=train_path,
                        target_size=(image_size,image_size),
                        batch_size=batch_size,
                        class_mode='categorical',
                        color_mode='rgb',
                        shuffle=True)

इमेजडाटाGenerator एक निर्देशिका से X_training डेटा बनाएगा। उस निर्देशिका में उप-निर्देशिका का उपयोग प्रत्येक ऑब्जेक्ट के लिए एक वर्ग के रूप में किया जाएगा। छवि को RGB रंग मोड के साथ लोड किया जाएगा, Y_training डेटा के लिए श्रेणीबद्ध वर्ग मोड के साथ, 16 के बैच आकार के साथ। अंत में, डेटा को शफ़ल करें।

आइए matplotlib के साथ प्लॉट करके अपनी छवियों को यादृच्छिक रूप से देखें

x_batch, y_batch = train_generator.next()

fig=plt.figure()
columns = 4
rows = 4
for i in range(1, columns*rows):
    num = np.random.randint(batch_size)
    image = x_batch[num].astype(np.int)
    fig.add_subplot(rows, columns, i)
    plt.imshow(image)
plt.show()

उसके बाद हम इमेजनेट प्री-ट्रेन्ड वेट के साथ VGG16 से अपना नेटवर्क मॉडल बनाते हैं। हम इन परतों को स्थिर कर देंगे ताकि परतें प्रशिक्षित न हो सकें, जिससे हमें गणना समय कम करने में मदद मिलेगी।

VGG16 से अपना मॉडल बनाना

import keras
from keras.models import Model, load_model
from keras.layers import Activation, Dropout, Flatten, Dense
from keras.preprocessing.image import ImageDataGenerator
from keras.applications.vgg16 import VGG16


#Load the VGG model
base_model = VGG16(weights='imagenet', include_top=False, input_shape=(image_size, image_size, 3))

print(base_model.summary())

    # Freeze the layers 
for layer in base_model.layers:
    layer.trainable = False
 
# # Create the model
model = keras.models.Sequential()

# # Add the vgg convolutional base model
model.add(base_model)
 
# # Add new layers
model.add(Flatten())
model.add(Dense(1024, activation='relu'))
model.add(Dense(1024, activation='relu'))
model.add(Dense(num_class, activation='softmax'))
 
# # Show a summary of the model. Check the number of trainable parameters    
print(model.summary())

जैसा कि आप नीचे देख सकते हैं, हमारे नेटवर्क मॉडल का सारांश। VGG16 लेयर्स से इनपुट से, फिर हम 2 पूरी तरह से कनेक्टेड लेयर जोड़ते हैं जो 1024 फीचर्स निकालेंगे और एक आउटपुट लेयर जो सॉफ्टमैक्स एक्टिवेशन के साथ 8 क्लासेस की गणना करेगी।

Layer (type)                 Output Shape              Param #   
=================================================================
vgg16 (Model)                (None, 7, 7, 512)         14714688  
_________________________________________________________________
flatten_1 (Flatten)          (None, 25088)             0         
_________________________________________________________________
dense_1 (Dense)              (None, 1024)              25691136  
_________________________________________________________________
dense_2 (Dense)              (None, 1024)              1049600   
_________________________________________________________________
dense_3 (Dense)              (None, 8)                 8200      
=================================================================
Total params: 41,463,624
Trainable params: 26,748,936
Non-trainable params: 14,714,688

प्रशिक्षण

# # Compile the model
from keras.optimizers import SGD

model.compile(loss='categorical_crossentropy',
          optimizer=SGD(lr=1e-3),
          metrics=['accuracy'])

# # Start the training process
# model.fit(x_train, y_train, validation_split=0.30, batch_size=32, epochs=50, verbose=2)

# # #save the model
# model.save('catdog.h5')

history = model.fit_generator(
        train_generator,
        steps_per_epoch=train_generator.n/batch_size,
        epochs=10)
        
model.save('fine_tune.h5')

# summarize history for accuracy
import matplotlib.pyplot as plt

plt.plot(history.history['loss'])
plt.title('loss')
plt.ylabel('loss')
plt.xlabel('epoch')
plt.legend(['loss'], loc='upper left')
plt.show()

परिणाम

Epoch 1/10
432/431 [==============================] - 53s 123ms/step - loss: 0.5524 - acc: 0.9474 
Epoch 2/10
432/431 [==============================] - 52s 119ms/step - loss: 0.1571 - acc: 0.9831
Epoch 3/10
432/431 [==============================] - 51s 119ms/step - loss: 0.1087 - acc: 0.9871
Epoch 4/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0624 - acc: 0.9926
Epoch 5/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0591 - acc: 0.9938
Epoch 6/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0498 - acc: 0.9936
Epoch 7/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0403 - acc: 0.9958
Epoch 8/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0248 - acc: 0.9959
Epoch 9/10
432/431 [==============================] - 51s 119ms/step - loss: 0.0466 - acc: 0.9942
Epoch 10/10
432/431 [==============================] - 52s 120ms/step - loss: 0.0338 - acc: 0.9947

जैसा कि आप देख सकते हैं, हमारे नुकसान में काफी कमी आई है और सटीकता लगभग 100% है। अपने मॉडल का परीक्षण करने के लिए, हमने इंटरनेट से यादृच्छिक रूप से छवियों को चुना और परीक्षण के लिए एक अलग वर्ग के साथ परीक्षण फ़ोल्डर पर रखा।

हमारे मॉडल का परीक्षण

model = load_model('fine_tune.h5')

test_datagen = ImageDataGenerator()
train_generator = train_datagen.flow_from_directory(
                        directory=train_path,
                        target_size=(image_size,image_size),
                        batch_size=batch_size,
                        class_mode='categorical',
                        color_mode='rgb',
                        shuffle=True)

test_generator = test_datagen.flow_from_directory(
                        directory=test_path, 
                        target_size=(image_size, image_size),
                        color_mode='rgb',
                        shuffle=False,
                        class_mode='categorical',
                        batch_size=1)

filenames = test_generator.filenames
nb_samples = len(filenames)

fig=plt.figure()
columns = 4
rows = 4
for i in range(1, columns*rows -1):
    x_batch, y_batch = test_generator.next()

    name = model.predict(x_batch)
    name = np.argmax(name, axis=-1)
    true_name = y_batch
    true_name = np.argmax(true_name, axis=-1)

    label_map = (test_generator.class_indices)
    label_map = dict((v,k) for k,v in label_map.items()) #flip k,v
    predictions = [label_map[k] for k in name]
    true_value = [label_map[k] for k in true_name]

    image = x_batch[0].astype(np.int)
    fig.add_subplot(rows, columns, i)
    plt.title(str(predictions[0]) + ':' + str(true_value[0]))
    plt.imshow(image)
plt.show()

और हमारा परीक्षण नीचे दिया गया है! 1 छवियों के परीक्षण में से केवल 14 छवि गलत अनुमानित है!

केरास के साथ फेस रिकॉग्निशन न्यूरल नेटवर्क

हमें मान्यता की आवश्यकता क्यों है?

हमें किसी व्यक्ति के चेहरे, वस्तु के प्रकार, उसके चेहरे से उसकी अनुमानित आयु, या यहां तक कि उस व्यक्ति के चेहरे के भावों को जानने या पहचानने में आसानी के लिए पहचान की आवश्यकता होती है।

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

तो यह कैसे काम करता है? हर बार जब हम अपने दोस्त के चेहरे पर निशान लगाते हैं, तो Facebook का AI इसे सीखता है और सही परिणाम मिलने तक इसका अनुमान लगाने की कोशिश करता है। यही सिस्टम हम अपना खुद का फेस रिकॉग्निशन बनाने के लिए इस्तेमाल करेंगे। आइए डीप लर्निंग का इस्तेमाल करके अपना खुद का फेस रिकॉग्निशन बनाना शुरू करें

नेटवर्क मॉडल

हम VGG16 नेटवर्क मॉडल का उपयोग करेंगे लेकिन VGGFace वेट के साथ।

VGG16 मॉडल आर्किटेक्चर

VGGFace क्या है? यह पारखी, ओमकार एम. एट अल द्वारा प्रस्तुत डीप फेस रिकॉग्निशन का केरास कार्यान्वयन है। "डीप फेस रिकॉग्निशन।" BMVC (2015)। यह फ्रेमवर्क नेटवर्क आर्किटेक्चर के रूप में VGG16 का उपयोग करता है।

आप VGGFace को यहां से डाउनलोड कर सकते हैं GitHub

from keras.applications.vgg16 import VGG16
from keras_vggface.vggface import VGGFace

face_model = VGGFace(model='vgg16', 
                weights='vggface',
                input_shape=(224,224,3)) 
face_model.summary()

जैसा कि आप नेटवर्क सारांश देख सकते हैं

_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
input_1 (InputLayer)         (None, 224, 224, 3)       0         
_________________________________________________________________
conv1_1 (Conv2D)             (None, 224, 224, 64)      1792      
_________________________________________________________________
conv1_2 (Conv2D)             (None, 224, 224, 64)      36928     
_________________________________________________________________
pool1 (MaxPooling2D)         (None, 112, 112, 64)      0         
_________________________________________________________________
conv2_1 (Conv2D)             (None, 112, 112, 128)     73856     
_________________________________________________________________
conv2_2 (Conv2D)             (None, 112, 112, 128)     147584    
_________________________________________________________________
pool2 (MaxPooling2D)         (None, 56, 56, 128)       0         
_________________________________________________________________
conv3_1 (Conv2D)             (None, 56, 56, 256)       295168    
_________________________________________________________________
conv3_2 (Conv2D)             (None, 56, 56, 256)       590080    
_________________________________________________________________
conv3_3 (Conv2D)             (None, 56, 56, 256)       590080    
_________________________________________________________________
pool3 (MaxPooling2D)         (None, 28, 28, 256)       0         
_________________________________________________________________
conv4_1 (Conv2D)             (None, 28, 28, 512)       1180160   
_________________________________________________________________
conv4_2 (Conv2D)             (None, 28, 28, 512)       2359808   
_________________________________________________________________
conv4_3 (Conv2D)             (None, 28, 28, 512)       2359808   
_________________________________________________________________
pool4 (MaxPooling2D)         (None, 14, 14, 512)       0         
_________________________________________________________________
conv5_1 (Conv2D)             (None, 14, 14, 512)       2359808   
_________________________________________________________________
conv5_2 (Conv2D)             (None, 14, 14, 512)       2359808   
_________________________________________________________________
conv5_3 (Conv2D)             (None, 14, 14, 512)       2359808   
_________________________________________________________________
pool5 (MaxPooling2D)         (None, 7, 7, 512)         0         
_________________________________________________________________
flatten (Flatten)            (None, 25088)             0         
_________________________________________________________________
fc6 (Dense)                  (None, 4096)              102764544 
_________________________________________________________________
fc6/relu (Activation)        (None, 4096)              0         
_________________________________________________________________
fc7 (Dense)                  (None, 4096)              16781312  
_________________________________________________________________
fc7/relu (Activation)        (None, 4096)              0         
_________________________________________________________________
fc8 (Dense)                  (None, 2622)              10742334  
_________________________________________________________________
fc8/softmax (Activation)     (None, 2622)              0         
=================================================================
Total params: 145,002,878
Trainable params: 145,002,878
Non-trainable params: 0
_________________________________________________________________
Traceback (most recent call last):

हम करेंगे लर्निंग ट्रांसफर + छोटे डेटासेट के साथ प्रशिक्षण को तेज़ बनाने के लिए फ़ाइन ट्यूनिंग। सबसे पहले, हम बेस लेयर्स को फ़्रीज़ कर देंगे ताकि लेयर्स को प्रशिक्षित न किया जा सके।

for layer in face_model.layers:
    layer.trainable = False

फिर हम अपने परीक्षण चेहरों को पहचानने के लिए अपनी खुद की परत जोड़ते हैं। हम 2 पूरी तरह से जुड़ी हुई परत और 5 लोगों का पता लगाने के लिए एक आउटपुट परत जोड़ेंगे।

from keras.models import Model, Sequential
from keras.layers import Input, Convolution2D, ZeroPadding2D, MaxPooling2D, Flatten, Dense, Dropout, Activation

person_count = 5

last_layer = face_model.get_layer('pool5').output

x = Flatten(name='flatten')(last_layer)
x = Dense(1024, activation='relu', name='fc6')(x)
x = Dense(1024, activation='relu', name='fc7')(x)
out = Dense(person_count, activation='softmax', name='fc8')(x)

custom_face = Model(face_model.input, out)

आइये देखें हमारा नेटवर्क सारांश

Layer (type)                 Output Shape              Param #
=================================================================
input_1 (InputLayer)         (None, 224, 224, 3)       0
_________________________________________________________________
conv1_1 (Conv2D)             (None, 224, 224, 64)      1792
_________________________________________________________________
conv1_2 (Conv2D)             (None, 224, 224, 64)      36928
_________________________________________________________________
pool1 (MaxPooling2D)         (None, 112, 112, 64)      0
_________________________________________________________________
conv2_1 (Conv2D)             (None, 112, 112, 128)     73856
_________________________________________________________________
conv2_2 (Conv2D)             (None, 112, 112, 128)     147584
_________________________________________________________________
pool2 (MaxPooling2D)         (None, 56, 56, 128)       0
_________________________________________________________________
conv3_1 (Conv2D)             (None, 56, 56, 256)       295168
_________________________________________________________________
conv3_2 (Conv2D)             (None, 56, 56, 256)       590080
_________________________________________________________________
conv3_3 (Conv2D)             (None, 56, 56, 256)       590080
_________________________________________________________________
pool3 (MaxPooling2D)         (None, 28, 28, 256)       0
_________________________________________________________________
conv4_1 (Conv2D)             (None, 28, 28, 512)       1180160
_________________________________________________________________
conv4_2 (Conv2D)             (None, 28, 28, 512)       2359808
_________________________________________________________________
conv4_3 (Conv2D)             (None, 28, 28, 512)       2359808
_________________________________________________________________
pool4 (MaxPooling2D)         (None, 14, 14, 512)       0
_________________________________________________________________
conv5_1 (Conv2D)             (None, 14, 14, 512)       2359808
_________________________________________________________________
conv5_2 (Conv2D)             (None, 14, 14, 512)       2359808
_________________________________________________________________
conv5_3 (Conv2D)             (None, 14, 14, 512)       2359808
_________________________________________________________________
pool5 (MaxPooling2D)         (None, 7, 7, 512)         0
_________________________________________________________________
flatten (Flatten)            (None, 25088)             0
_________________________________________________________________
fc6 (Dense)                  (None, 1024)              25691136
_________________________________________________________________
fc7 (Dense)                  (None, 1024)              1049600
_________________________________________________________________
fc8 (Dense)                  (None, 5)                 5125
=================================================================
Total params: 41,460,549
Trainable params: 26,745,861
Non-trainable params: 14,714,688

जैसा कि आप ऊपर देख सकते हैं, pool5 परत के बाद, इसे एक एकल फीचर वेक्टर में समतल कर दिया जाएगा जिसका उपयोग अंतिम पहचान के लिए सघन परत द्वारा किया जाएगा।

अपने चेहरे को तैयार करना

अब हम अपने चेहरे तैयार करते हैं। मैंने 5 मशहूर लोगों की एक निर्देशिका बनाई है

जैक मा
जेसन Statham
जॉनी डेप
रॉबर्ट डाउनी जूनियर
रोवन एटकिंसन

प्रत्येक फ़ोल्डर में प्रत्येक प्रशिक्षण और मूल्यांकन प्रक्रिया के लिए 10 चित्र हैं। यह डेटा की बहुत छोटी मात्रा है लेकिन यही चुनौती है, है ना?

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

from keras.preprocessing.image import ImageDataGenerator
batch_size = 5
train_path = 'data/'
eval_path = 'eval/'

train_datagen = ImageDataGenerator(rescale=1./255,
                                   shear_range=0.2,
                                   zoom_range=0.2,
                                   horizontal_flip=True)

valid_datagen = ImageDataGenerator(rescale=1./255,
                                   shear_range=0.2,
                                   zoom_range=0.2,
                                   horizontal_flip=True)

train_generator = train_datagen.flow_from_directory(
                        train_path,
                        target_size=(image_size,image_size),
                        batch_size=batch_size,
                        class_mode='sparse',
                        color_mode='rgb')

valid_generator = valid_datagen.flow_from_directory(
    directory=eval_path,
    target_size=(224, 224),
    color_mode='rgb',
    batch_size=batch_size,
    class_mode='sparse',
    shuffle=True,
)

हमारे मॉडल का प्रशिक्षण

आइए अपने नेटवर्क को लॉस फंक्शन और ऑप्टिमाइज़र के साथ संकलित करके अपनी प्रशिक्षण प्रक्रिया शुरू करें। यहाँ, हम अपने लॉस फंक्शन के रूप में sparse_categorical_crossentropy का उपयोग करते हैं, और हमारे लर्निंग ऑप्टिमाइज़र के रूप में SGD की मदद लेते हैं।

from keras.optimizers import SGD

custom_face.compile(loss='sparse_categorical_crossentropy',
                         optimizer=SGD(lr=1e-4, momentum=0.9),
                         metrics=['accuracy'])

history = custom_face.fit_generator(
        train_generator,
        validation_data=valid_generator,
        steps_per_epoch=49/batch_size,
        validation_steps=valid_generator.n,
        epochs=50)

custom_face.evaluate_generator(generator=valid_generator)
        
custom_face.save('vgg_face.h5')
Epoch 25/50
10/9 [==============================] - 60s 6s/step - loss: 1.4882 - acc: 0.8998 - val_loss: 1.5659 - val_acc: 0.5851
Epoch 26/50
10/9 [==============================] - 59s 6s/step - loss: 1.4882 - acc: 0.8998 - val_loss: 1.5638 - val_acc: 0.5809
Epoch 27/50
10/9 [==============================] - 60s 6s/step - loss: 1.4779 - acc: 0.8597 - val_loss: 1.5613 - val_acc: 0.5477
Epoch 28/50
10/9 [==============================] - 60s 6s/step - loss: 1.4755 - acc: 0.9199 - val_loss: 1.5576 - val_acc: 0.5809
Epoch 29/50
10/9 [==============================] - 60s 6s/step - loss: 1.4794 - acc: 0.9153 - val_loss: 1.5531 - val_acc: 0.5892
Epoch 30/50
10/9 [==============================] - 60s 6s/step - loss: 1.4714 - acc: 0.8953 - val_loss: 1.5510 - val_acc: 0.6017
Epoch 31/50
10/9 [==============================] - 60s 6s/step - loss: 1.4552 - acc: 0.9199 - val_loss: 1.5509 - val_acc: 0.5809
Epoch 32/50
10/9 [==============================] - 60s 6s/step - loss: 1.4504 - acc: 0.9199 - val_loss: 1.5492 - val_acc: 0.5975
Epoch 33/50
10/9 [==============================] - 60s 6s/step - loss: 1.4497 - acc: 0.8998 - val_loss: 1.5490 - val_acc: 0.5851
Epoch 34/50
10/9 [==============================] - 60s 6s/step - loss: 1.4453 - acc: 0.9399 - val_loss: 1.5529 - val_acc: 0.5643
Epoch 35/50
10/9 [==============================] - 60s 6s/step - loss: 1.4399 - acc: 0.9599 - val_loss: 1.5451 - val_acc: 0.5768
Epoch 36/50
10/9 [==============================] - 60s 6s/step - loss: 1.4373 - acc: 0.8998 - val_loss: 1.5424 - val_acc: 0.5768
Epoch 37/50
10/9 [==============================] - 60s 6s/step - loss: 1.4231 - acc: 0.9199 - val_loss: 1.5389 - val_acc: 0.6183
Epoch 38/50
10/9 [==============================] - 59s 6s/step - loss: 1.4247 - acc: 0.9199 - val_loss: 1.5372 - val_acc: 0.5934
Epoch 39/50
10/9 [==============================] - 60s 6s/step - loss: 1.4153 - acc: 0.9399 - val_loss: 1.5406 - val_acc: 0.5560
Epoch 40/50
10/9 [==============================] - 60s 6s/step - loss: 1.4074 - acc: 0.9800 - val_loss: 1.5327 - val_acc: 0.6224
Epoch 41/50
10/9 [==============================] - 60s 6s/step - loss: 1.4023 - acc: 0.9800 - val_loss: 1.5305 - val_acc: 0.6100
Epoch 42/50
10/9 [==============================] - 59s 6s/step - loss: 1.3938 - acc: 0.9800 - val_loss: 1.5269 - val_acc: 0.5975
Epoch 43/50
10/9 [==============================] - 60s 6s/step - loss: 1.3897 - acc: 0.9599 - val_loss: 1.5234 - val_acc: 0.6432
Epoch 44/50
10/9 [==============================] - 60s 6s/step - loss: 1.3828 - acc: 0.9800 - val_loss: 1.5210 - val_acc: 0.6556
Epoch 45/50
10/9 [==============================] - 59s 6s/step - loss: 1.3848 - acc: 0.9599 - val_loss: 1.5234 - val_acc: 0.5975
Epoch 46/50
10/9 [==============================] - 60s 6s/step - loss: 1.3716 - acc: 0.9800 - val_loss: 1.5216 - val_acc: 0.6432
Epoch 47/50
10/9 [==============================] - 60s 6s/step - loss: 1.3721 - acc: 0.9800 - val_loss: 1.5195 - val_acc: 0.6266
Epoch 48/50
10/9 [==============================] - 60s 6s/step - loss: 1.3622 - acc: 0.9599 - val_loss: 1.5108 - val_acc: 0.6141
Epoch 49/50
10/9 [==============================] - 60s 6s/step - loss: 1.3452 - acc: 0.9399 - val_loss: 1.5140 - val_acc: 0.6432
Epoch 50/50
10/9 [==============================] - 60s 6s/step - loss: 1.3387 - acc: 0.9599 - val_loss: 1.5100 - val_acc: 0.6266

जैसा कि आप देख सकते हैं, हमारी सत्यापन सटीकता 64% तक है, यह प्रशिक्षण डेटा की एक छोटी राशि के लिए एक अच्छा परिणाम है। हम इसे और अधिक परत जोड़कर या अधिक प्रशिक्षण चित्र जोड़कर सुधार सकते हैं ताकि हमारा मॉडल चेहरों के बारे में अधिक जान सके और अधिक सटीकता प्राप्त कर सके।

आइए एक परीक्षण चित्र के साथ अपने मॉडल का परीक्षण करें

from keras.models import load_model
from keras.preprocessing.image import load_img, save_img, img_to_array
from keras_vggface.utils import preprocess_input

test_img = image.load_img('test.jpg', target_size=(224, 224))
img_test = image.img_to_array(test_img)
img_test = np.expand_dims(img_test, axis=0)
img_test = utils.preprocess_input(img_test)
predictions = model.predict(img_test)
predicted_class=np.argmax(predictions,axis=1)

labels = (train_generator.class_indices)
labels = dict((v,k) for k,v in labels.items())
predictions = [labels[k] for k in predicted_class]
print(predictions)
['RobertDJr']

रॉबर्ट डाउनी जूनियर की तस्वीर को हमारे परीक्षण चित्र के रूप में उपयोग करने पर पता चलता है कि भविष्यवाणी किया गया चेहरा सच है!

लाइव कैम का उपयोग करके भविष्यवाणी!

अगर हम वेबकैम से इनपुट लेकर इसे लागू करने में अपनी कुशलता का परीक्षण करें तो कैसा रहेगा? हायर फेस कैस्केड के साथ ओपनसीवी का उपयोग करके अपना चेहरा ढूंढ़ने और अपने नेटवर्क मॉडल की मदद से हम व्यक्ति को पहचान सकते हैं।

पहला कदम है अपने और अपने दोस्त के चेहरे तैयार करना। हमारे पास जितना ज़्यादा डेटा होगा, परिणाम उतना ही बेहतर होगा!

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

#Load trained model
from keras.models import load_model
from keras_vggface import utils
import cv2

image_size = 224
device_id = 0 #camera_device id 

model = load_model('my faces.h5')

#make labels according to your dataset folder 
labels = dict(fisrtname=0,secondname=1) #and so on
print(labels)

cascade_classifier = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
camera = cv2.VideoCapture(device_id)

while camera.isOpened():
    ok, cam_frame = camera.read()
    if not ok:
        break
    
    gray_img=cv2.cvtColor(cam_frame, cv2.COLOR_BGR2GRAY)
    faces= cascade_classifier.detectMultiScale(gray_img, minNeighbors=5)

    for (x,y,w,h) in faces:
        cv2.rectangle(cam_frame,(x,y),(x+w,y+h),(255,255,0),2)
        roi_color = cam_frame [y:y+h, x:x+w]
        roi color = cv2.cvtColor(roi_color, cv2.COLOR_BGR2RGB)
        roi_color = cv2.resize(roi_color, (image_size, image_size))
        image = roi_color.astype(np.float32, copy=False)
        image = np.expand_dims(image, axis=0)
        image = preprocess_input(image, version=1) # or version=2
        preds = model.predict(image)
        predicted_class=np.argmax(preds,axis=1)

        labels = dict((v,k) for k,v in labels.items())
        name = [labels[k] for k in predicted_class]

        cv2.putText(cam_frame,str(name), 
                    (x + 10, y + 10), cv2.FONT_HERSHEY_SIMPLEX, 1, (255,0,255), 2)
        
    cv2.imshow('video image', cam_frame)
    key = cv2.waitKey(30)
    if key == 27: # press 'ESC' to quit
        break

camera.release()
cv2.destroyAllWindows()

कौन बेहतर है? केरास या टेन्सरफ्लो

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

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

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

सारांश

तो आइये इस ट्यूटोरियल में हमने जो कुछ भी चर्चा की और किया है, उसका सारांश प्रस्तुत करें।

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