मशीन-लर्निंग मॉडल बनाने के लिए TensorFlow एक बहुमुखी उपकरण है।
इस पोस्ट में, हम देखेंगे कि एक ओपन-सोर्स मशीन लर्निंग फ्रेमवर्क, TensorFlow के साथ फेस रिकग्निशन सिस्टम कैसे बनाया जाता है। हम एक मॉडल को प्रशिक्षित करने और मूल्यांकन करने के लिए डेटा एकत्र करने और तैयार करने से लेकर एक सफल चेहरा पहचान प्रणाली बनाने में आवश्यक प्रक्रियाओं पर ध्यान देंगे।
आपको कोड स्निपेट और वास्तविक दुनिया के उदाहरणों की सहायता से चेहरे की पहचान बनाने के लिए TensorFlow के साथ प्रत्यक्ष अनुभव प्राप्त होगा। जैसे ही हम आगे बढ़ते हैं, आपका अनुसरण करने के लिए स्वागत है।
TensorFlow का परिचय
TensorFlow एक फ्री और ओपन-सोर्स लाइब्रेरी है। यह एक सांकेतिक गणित टूलबॉक्स है जो डेटा प्रवाह और अलग-अलग प्रोग्रामिंग का उपयोग करता है। आप इसके साथ कई प्रकार के कार्यों को संभाल सकते हैं, जिसमें डीप भी शामिल है तंत्रिका नेटवर्क प्रशिक्षण.
TensorFlow शक्तिशाली और अनुकूलनीय है। इसी तरह, यह विकास और विकास के लिए एक महान उपकरण है मशीन लर्निंग मॉडल की तैनाती. आप कई परतों और टेंसर संचालन के साथ जटिल मॉडल बना सकते हैं। इसके अलावा, पुस्तकालय में पूर्व-निर्मित मॉडल विशिष्ट आवश्यकताओं के लिए ठीक-ठीक किए जा सकते हैं।
इसके अलावा, TensorFlow का एक विशाल और विस्तृत उपयोगकर्ता समुदाय है। इसलिए, प्लेटफॉर्म पर नए लोगों के लिए ढेर सारी जानकारी और मदद है।
टेंसरफ्लो के लिए लोकप्रिय है यंत्र अधिगम भाग में क्योंकि यह एंड-टू-एंड वर्कफ़्लो प्रदान करता है। तो, आप आसानी से मॉडल बना सकते हैं, प्रशिक्षित कर सकते हैं और तैनात कर सकते हैं। यह विशिष्ट मांगों को पूरा करने के लिए मॉडल में सुधार और स्केलिंग के लिए उपकरण और रणनीतियां प्रदान करता है। यह डेटा प्री-प्रोसेसिंग से लेकर मॉडल परिनियोजन तक भिन्न होता है।
फेस रिकग्निशन क्या है?
चेहरा पहचान एक है कंप्यूटर दृष्टि वह कार्य जो किसी व्यक्ति के चेहरे के आधार पर उसकी पहचान करता है। यह तकनीक चेहरे के लक्षणों को पहचानती है, जैसे आंखों, नाक और मुंह का आकार और बनावट।
और, यह एक मैच की पहचान करने के लिए उनकी तुलना ज्ञात चेहरों के डेटाबेस से करता है। फेस रिकग्निशन के कई उपयोग हैं, जिनमें सुरक्षा प्रणालियाँ, फोटो संगठन और बायोमेट्रिक प्रमाणीकरण शामिल हैं।
मशीन लर्निंग में सफलताओं के परिणामस्वरूप हाल के वर्षों में फेस रिकग्निशन एल्गोरिदम की सटीकता में काफी वृद्धि हुई है।
आवश्यक पुस्तकालयों का आयात करना
कुछ भी शुरू करने से पहले, हमें अपने मॉडल के लिए आवश्यक पुस्तकालयों को आयात करना होगा। Tensorflow (tf) को मॉडल बनाने और प्रशिक्षित करने के लिए आयात और उपयोग किया जाता है। <(पी>
"numpy" गणितीय गणना और डेटा प्रोसेसिंग करता है।
"matplotlib.pyplot" को plt के रूप में आयात किया जाता है और इसके लिए उपयोग किया जाता है डेटा चार्टिंग और विज़ुअलाइज़ेशन.
अंत में, "LFW लोगों को लाएं" स्केलेर से आयात किया जाता है। डेटासेट और चेहरे की पहचान डेटासेट को लोड करने के लिए उपयोग किया जाता है। यह फंक्शन स्किकिट-लर्न टूलकिट का हिस्सा है। इस फ़ंक्शन के लिए धन्यवाद, हमें कोई अन्य डेटासेट अपलोड करने की आवश्यकता नहीं थी। यह स्किट-लर्न में पहले से ही निर्मित है।
और, यह आपको एक विस्तृत श्रृंखला तक पहुंच प्रदान करता है मशीन सीखने के लिए डेटासेट अनुप्रयोग। इस परिदृश्य में, हम "जंगली में लेबल किए गए चेहरे" (LFW) डेटासेट को पुनः प्राप्त करने के लिए LFW लोगों को लाने की विधि का उपयोग करते हैं। इसमें लोगों के चेहरों के साथ-साथ उनके साथ जाने वाले लेबल की तस्वीरें भी शामिल हैं।
ये पुस्तकालय हमारे चेहरा पहचान मॉडल के कार्यान्वयन और मूल्यांकन में महत्वपूर्ण हैं।
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt from sklearn.datasets
import fetch_lfw_people
फेस रिकग्निशन डेटासेट को प्रीप्रोसेसिंग और लोड करना
इस भाग में, हम चेहरे की पहचान डेटा को प्रीप्रोसेस करने के लिए "fetch lfw people" फ़ंक्शन का उपयोग करते हैं। सबसे पहले, हम "कम से कम चेहरे प्रति व्यक्ति = 60" विकल्प के साथ lfw लोगों को लाने का उपयोग करते हैं। यह इंगित करता है कि हम केवल उन व्यक्तियों को डेटासेट में शामिल करना चाहते हैं जिनके पास कम से कम 60 फ़ोटो हैं। इसलिए, हम यह सुनिश्चित करते हैं कि हमारे मॉडल में सीखने के लिए पर्याप्त डेटा हो। साथ ही, यह ओवरफिटिंग के खतरे को कम करता है।
फ़ेस ऑब्जेक्ट से डेटा और लेबल तब निकाले जाते हैं और वेरिएबल्स X और y को असाइन किए जाते हैं। एक्स होल।
अब हम पूर्व-संसाधित डेटा और लेबल का उपयोग करके अपने चेहरे की पहचान करने वाले मॉडल को प्रशिक्षित करने के लिए तैयार हैं।
faces = fetch_lfw_people(min_faces_per_person=60)
X = faces.data
y = faces.target
target_names = faces.target_names
विभाजन प्रशिक्षण और परीक्षण सेट
इस चरण में, हम sklearn.model चयन से ट्रेन टेस्ट स्प्लिट विधि का उपयोग करके अपने फेस रिकग्निशन डेटासेट को दो हिस्सों में विभाजित करते हैं। इस विभाजन का लक्ष्य प्रशिक्षण के बाद हमारे मॉडल के प्रदर्शन का आकलन करना है
ट्रेन टेस्ट स्प्लिट फंक्शन इनपुट डेटा X और लेबल y के रूप में स्वीकार करता है। और, यह उन्हें प्रशिक्षण और परीक्षण सेटों में विभाजित करता है। हम इस उदाहरण में परीक्षण आकार = 0.2 का चयन करते हैं। इसका तात्पर्य है कि डेटा का 20% परीक्षण सेट के रूप में और 80% प्रशिक्षण सेट के रूप में उपयोग किया जाएगा। इसके अलावा, हम यह सुनिश्चित करने के लिए यादृच्छिक स्थिति = 42 का उपयोग करते हैं कि हर बार कोड किए जाने पर डेटा लगातार विभाजित होता है।
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
डेटा तैयार करना
प्रीप्रोसेसिंग डेटा का उद्देश्य इसे मॉडल में प्रवेश के लिए तैयार करना है। इस कोड में डेटा को प्रत्येक डेटा बिंदु को 255 से विभाजित करके प्रीप्रोसेस किया जाता है।
इसे हासिल करने के लिए हमें क्या प्रेरणा मिली? सामान्यीकरण एक प्रीप्रोसेसिंग प्रक्रिया है जिसका उपयोग मशीन लर्निंग में यह गारंटी देने के लिए किया जाता है कि सभी सुविधाएँ समान पैमाने पर हैं। इस परिदृश्य में, 255 से विभाजित करने पर डेटा 0 से 1 की श्रेणी में आ जाता है, जो सामान्य चित्र डेटा सामान्यीकरण चरण है।
यह मॉडल के अभिसरण को गति देता है और इसके प्रदर्शन को बढ़ा सकता है।
X_train = X_train / 255.0
X_test = X_test / 255.0
मोड बनाना
हम उस व्यक्ति की पहचान करना चाहते हैं जिसका चेहरा तस्वीर में दिखाई दे रहा है। इस मामले में, हम पूरी तरह से जुड़े नेटवर्क का उपयोग करेंगे, जिसे अक्सर सघन नेटवर्क के रूप में जाना जाता है। यह एक कृत्रिम तंत्रिका नेटवर्क है जिसका उपयोग मॉडल बनाने के लिए किया गया था।
मानव मस्तिष्क कैसे संचालित होता है और कैसे व्यवस्थित होता है, इसके बाद कृत्रिम तंत्रिका नेटवर्क तैयार किए जाते हैं। वे सूचना-प्रसंस्करण नोड्स या न्यूरॉन्स से बने होते हैं जो आपस में जुड़े होते हैं। घने नेटवर्क में एक परत में प्रत्येक न्यूरॉन उसके ऊपर की परत में प्रत्येक न्यूरॉन से जुड़ा होता है।
इस कोड में मॉडल की चार परतें होती हैं। अगली परत में डालने के लिए, इनपुट डेटा को पहली परत में एक आयामी सरणी में चपटा किया जाता है। तदनुसार, निम्नलिखित दो परतों में 128 और 64 न्यूरॉन्स पूरी तरह से जुड़े हुए हैं।
ReLU सक्रियण फ़ंक्शन इन परतों द्वारा उपयोग किया जाने वाला एक अद्वितीय सक्रियण फ़ंक्शन है। इसके साथ, हम इनपुट और आउटपुट के बीच गैर-रैखिक सहसंबंध सीखने के लिए मॉडल प्राप्त कर सकते हैं। अंतिम परत भविष्यवाणी करने के लिए सॉफ्टमैक्स सक्रियण फ़ंक्शन का उपयोग करती है। और, यह पूरी तरह से जुड़ी हुई परत है जिसमें उतने ही न्यूरॉन्स होते हैं जितने संभावित वर्ग होते हैं।
model = tf.keras.models.Sequential([
tf.keras.layers.Flatten(input_shape=(62 * 47,)),
tf.keras.layers.Dense(128, activation='relu'),
tf.keras.layers.Dense(64, activation='relu'),
tf.keras.layers.Dense(len(target_names), activation='softmax')
])
मॉडल का संकलन
मॉडल को "संकलन" फ़ंक्शन का उपयोग करके संकलित किया गया है। हमें प्रशिक्षण के लिए मॉडल तैयार करने की जरूरत है। इसलिए, हम ऑप्टिमाइज़र, लॉस फ़ंक्शन और मेट्रिक्स को परिभाषित करेंगे जिनका उपयोग मॉडल का आकलन करने के लिए किया जाएगा।
प्रशिक्षण के दौरान, ऑप्टिमाइज़र मॉडल के मापदंडों को बदलने का प्रभारी होता है। "एडम" ऑप्टिमाइज़र एक लोकप्रिय डीप-लर्निंग ऑप्टिमाइज़ेशन तकनीक है।
हम प्रशिक्षण डेटा पर मॉडल के प्रदर्शन का आकलन करने के लिए हानि फ़ंक्शन का उपयोग करते हैं। क्योंकि लक्ष्य लेबल एक-हॉट एन्कोडेड वैक्टर के बजाय छवि के वर्ग को प्रतिबिंबित करने वाले पूर्णांक हैं, "विरल श्रेणीबद्ध क्रॉसेंट्रॉपी" हानि फ़ंक्शन अनुकूल है।
अंत में, हम इस मामले में "सटीकता" मॉडल का आकलन करने के लिए मेट्रिक्स को परिभाषित करते हैं।
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
मॉडल प्रशिक्षण
हम मॉडल को प्रशिक्षित करने के लिए "फिट" फ़ंक्शन का उपयोग करेंगे।
हम प्रशिक्षण डेटा (एक्स ट्रेन) और संबंधित लेबल (वाई ट्रेन) प्रदान करेंगे, साथ ही 10 के रूप में चलाने के लिए युगों (पुनरावृत्ति) की संख्या निर्धारित करेंगे। प्रशिक्षण प्रक्रिया नुकसान को कम करने के लिए मॉडल वजन को संशोधित करती है (के बीच का अंतर) अनुमानित और वास्तविक लेबल) और प्रशिक्षण डेटा की सटीकता में सुधार।
model.fit(X_train, y_train, epochs=10)
मॉडल मूल्यांकन
अब, हमें परीक्षण डेटा पर प्रशिक्षित मॉडल का आकलन करने की आवश्यकता है। हम मॉडल के प्रदर्शन का आकलन करने के लिए परीक्षण हानि और परीक्षण सटीकता का उपयोग करते हैं। परीक्षण डेटा X परीक्षण और परीक्षण लेबल y परीक्षण पर, हमें "मॉडल.मूल्यांकन फ़ंक्शन" को कॉल करने की आवश्यकता है
फ़ंक्शन परीक्षण सटीकता और परीक्षण हानि को आउटपुट करता है। चर परीक्षण हानि और परीक्षण सटीकता, क्रमशः, इन मूल्यों को समाहित करते हैं। अंत में, हम परीक्षण सटीकता को आउटपुट करने के लिए "प्रिंट" फ़ंक्शन का उपयोग करते हैं।
test_loss, test_accuracy = model.evaluate(X_test, y_test)
print("Test accuracy:", test_accuracy)
कक्षाओं की भविष्यवाणी करना और अनुमानित कक्षाएं प्राप्त करना
प्रशिक्षण मॉडल और परीक्षण डेटा का उपयोग करते हुए, एल्गोरिथम भविष्यवाणियां करता है। जब परीक्षण डेटा को "model.predict" विधि में पारित किया जाता है, तो यह परीक्षण सेट में प्रत्येक चित्र के लिए भविष्यवाणियों की एक सरणी का उत्पादन करता है।
प्रत्येक चित्र के लिए लक्ष्य वर्ग का नाम तब "np.argmax" फ़ंक्शन का उपयोग करके "लक्ष्य नाम" सूची से पुनर्प्राप्त किया जाता है ताकि सूचकांक को सबसे बड़ी अनुमानित संभावना के साथ पहचाना जा सके। इस सूचकांक का उपयोग तब प्रत्येक छवि के लिए अनुमानित वर्ग निर्धारित करने के लिए किया जाता है।
एक सूची समझ का उपयोग करते हुए, "भविष्यवाणियों" सरणी में सभी भविष्यवाणियों को इस पद्धति के अधीन किया जाता है, जिसके परिणामस्वरूप "अनुमानित वर्ग" सूची होती है।
predictions = model.predict(X_test)
predicted_classes = [target_names[np.argmax(prediction)] for prediction in predictions]
भविष्यवाणियों की कल्पना करना
अब हम देख सकते हैं कि हमारा मॉडल कैसा दिखता है।
यह मूल्यांकन करने के लिए कि मॉडल कितना अच्छा काम कर रहा है, पहले 10 फ़ोटो और उनके पूर्वानुमान दिखाए जाएंगे। यह तस्वीरों को ग्रेस्केल में प्लॉट करेगा और छवि के वास्तविक वर्ग और matplotlib.pyplot मॉड्यूल का उपयोग करके मॉडल द्वारा भविष्यवाणी की गई कक्षा दोनों को प्रदर्शित करेगा।
लूप के लिए "imshow" फ़ंक्शन का उपयोग पहले 10 टेस्ट सेट फ़ोटो में से प्रत्येक को प्लॉट करने के लिए किया जाता है। लक्ष्य नाम [y परीक्षण [i]] और अनुमानित वर्ग [i] का उपयोग क्रमशः छवि की वास्तविक कक्षा और अनुमानित वर्ग को निर्धारित करने के लिए किया जाता है। फिर प्रत्येक प्लॉट के शीर्षक इन वर्गीकरणों द्वारा इंगित किए जाते हैं।
अंत में, प्लॉट को plt.show() विधि का उपयोग करके प्रदर्शित किया जाता है।
for i in range(10):
plt.imshow(X_test[i].reshape(62, 47), cmap='gray')
plt.title(f"True: {target_names[y_test[i]]}, Predicted:{predicted_classes[i]}")
plt.show()
लपेटें
TensorFlow मशीन लर्निंग मॉडल बनाने के लिए एक पूर्ण और लचीला वातावरण प्रदान करता है।
विशिष्ट आवश्यकताओं को पूरा करने के लिए मॉडल को फाइन-ट्यूनिंग करके या मशीन लर्निंग में नए विकास को जोड़कर, मॉडल की सटीकता को और भी बढ़ाया जा सकता है।
TensorFlow और चेहरे की पहचान भविष्य में सुरक्षा प्रणालियों, बायोमेट्रिक प्रमाणीकरण और स्वास्थ्य देखभाल जैसे उद्योगों में तेजी से उपयोग की जाएगी। हम शीघ्र ही आकर्षक नवाचार देखेंगे।
एक जवाब लिखें