भाग 2:मारियाडीबी सर्वर और टेंसरफ्लो के साथ छवि वर्गीकरण - एक ट्यूटोरियल

TensorFlow के लिए डेटा को फ़ॉर्मेट करना

इस ब्लॉग श्रृंखला के भाग 1 ने सरल SQL कथनों का उपयोग करके छवियों के डेटा अन्वेषण को संग्रहीत करने और निष्पादित करने के लिए एक रिलेशनल डेटाबेस का उपयोग करने के लाभों का प्रदर्शन किया। इस ट्यूटोरियल में, भाग 2, भाग एक में उपयोग किए गए डेटा को मारियाडीबी सर्वर डेटाबेस से एक्सेस किया जाएगा और TensorFlow द्वारा आवश्यक डेटा संरचनाओं में परिवर्तित किया जाएगा। नई छवियों को वर्गीकृत करने के लिए मॉडल को लागू करने के परिणाम आगे के विश्लेषण के लिए एक संबंधपरक तालिका में संग्रहीत किए जाएंगे।

यह एक TensorFlow प्रोग्राम का एक त्वरित ट्यूटोरियल है जिसमें विवरण का वर्णन किया गया है जैसे हम जाते हैं। यदि आप बुनियादी अवधारणाओं से परिचित नहीं हैं, तो शुरू करने के लिए एक अच्छी जगह यह TensorFlow ट्यूटोरियल है, "मूल वर्गीकरण:कपड़ों की छवियों को वर्गीकृत करें"। ट्यूटोरियल में कुछ उदाहरण और कोड यहां उपयोग किए गए हैं।

अतिरिक्त पैकेज की आवश्यकता है

छवि वर्गीकरण मॉडल के निर्माण और प्रशिक्षण के लिए कुछ अतिरिक्त पैकेजों की आवश्यकता है:

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

import pickle
import numpy as np
import tensorflow as tf

from tensorflow import keras
print('Tensorflow version: ', tf.__version__)
print('Numpy version: ', np.__version__)
Tensorflow version: 2.0.0
Numpy version: 1.16.2

छवियां पुनर्प्राप्त करें

एक बार पैकेज आयात हो जाने के बाद, अगला कदम डेटाबेस से प्रशिक्षण छवियों को पुनः प्राप्त करना और डेटा को दो numpy में विभाजित करना है। सरणियाँ सबसे पहले, हमें प्रशिक्षण छवियों (train_images) और प्रशिक्षण लेबल (train_labels) सरणियों को प्रारंभ करने की आवश्यकता है। चूंकि हमने पहले ही छवियों को वेक्टरकृत कर दिया है, इसलिए हम नीचे दिए गए SQL कथन के साथ ट्रेन_इमेज सरणी को पॉप्युलेट करने के लिए img_vector विशेषता का उपयोग कर सकते हैं।

# Initialize the numpy arrays
train_images = np.empty((60000,28,28), dtype='uint8')
train_labels = np.empty((60000), dtype='uint8')

# Retrieve the training images from the database
sql="SELECT img_label, img_vector, img_idx \
FROM tf_images INNER JOIN img_use ON img_use = use_id \
WHERE use_name = 'Training'"
cur.execute(sql)
result = cur.fetchall()

# Populate the numpy arrays. row[2] contains the image index
for row in result:
nparray = pickle.loads(row[1])
train_images[row[2]] = nparray
train_labels[row[2]] = row[0]

इसी तरह, परीक्षण के लिए छवियों को डेटाबेस से पुनर्प्राप्त किया जा सकता है। सुन्न इस मामले में उपयोग की जाने वाली सरणियाँ test_images और test_labels हैं। इस मामले में, परीक्षण डेटा 28×28 पिक्सेल रिज़ॉल्यूशन पर 10,000 चित्र है।

# Initialize the numpy arrays
test_images = np.empty((10000,28,28), dtype='uint8')
test_labels = np.empty((10000), dtype='uint8')

# Retrieve the testing images from the database
sql="SELECT img_label, img_vector, img_idx \
FROM tf_images INNER JOIN img_use ON img_use = use_id \
WHERE use_name = 'Testing'"
cur.execute(sql)
result = cur.fetchall()

# Populate the numpy arrays. row[2] contains the image index
for row in result:
nparray = pickle.loads(row[1])
test_images[row[2]] = nparray
test_labels[row[2]] = row[0]

अंत में, प्रत्येक छवि को एक लेबल पर मैप किया जाता है। लेबल नाम श्रेणियों की तालिका में संग्रहीत किए जाते हैं और class_names सरणी में लोड किए जाते हैं:

sql="SELECT class_name FROM categories"
cur.execute(sql)
class_names = cur.fetchall()

डेटा को प्रीप्रोसेस करें

नेटवर्क को प्रशिक्षण देने से पहले डेटा को प्रीप्रोसेस किया जाना चाहिए। यदि आप प्रशिक्षण सेट में पहली छवि का निरीक्षण करते हैं, तो आप देखेंगे कि पिक्सेल मान 0 से 255 की सीमा में आते हैं:

plt.figure()
plt.imshow(train_images[0])
plt.colorbar()
plt.grid(False)
plt.show()

ऊपर:Fashion_mnist डेटासेट से इमेज

तंत्रिका नेटवर्क मॉडल को छवियों को खिलाने से पहले, मानों को 0 से 1 की सीमा तक बढ़ाया जाना चाहिए। ऐसा करने के लिए, मानों को 255 से विभाजित करें। यह महत्वपूर्ण है कि प्रशिक्षण सेट और परीक्षण सेट उसी तरह पूर्व-संसाधित हैं ।

आप matplotlib . का उपयोग कर सकते हैं डेटा को सत्यापित करने के लिए पहली 25 छवियों को प्रदर्शित करने के लिए सही प्रारूप में है और नेटवर्क के निर्माण और प्रशिक्षण के लिए तैयार है:

train_images = train_images / 255.0
test_images = test_images / 255.0

plt.figure(figsize=(10,10))
for i in range(25):
plt.subplot(5,5,i+1)
plt.xticks([])
plt.yticks([])
plt.grid(False)
plt.imshow(train_images[i], cmap=plt.cm.binary)
plt.xlabel(class_names[train_labels[i]])
plt.show()

ऊपर:Fashion_mnist डेटासेट से इमेज

मॉडल बनाना

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

अधिकांश डीप लर्निंग न्यूरल नेटवर्क सरल परतों को एक साथ जोड़कर निर्मित होते हैं।

नेटवर्क में पहली परत छवि प्रारूप को दो-आयामी सरणी (28 गुणा 28 पिक्सेल) से एक-आयामी सरणी (28 * 28 =784 पिक्सेल) में बदल देती है। इस परत में सीखने के लिए कोई पैरामीटर नहीं है; यह केवल डेटा को पुन:स्वरूपित करता है।

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

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

दूसरी (और आखिरी) परत 10-नोड सॉफ्टमैक्स परत है। एक सॉफ्टमैक्स फ़ंक्शन एक वेक्टर को आउटपुट करता है जो संभावित परिणामों की सूची के संभाव्यता वितरण का प्रतिनिधित्व करता है। यह 10 संभाव्यता स्कोर की एक सरणी देता है जो 1 के बराबर होता है। प्रत्येक नोड में एक स्कोर होता है जो इस संभावना को इंगित करता है कि वर्तमान छवि 10 वर्गों में से एक से संबंधित है।

अधिकांश परतों, जैसे tf.keras.layers.Dense, में ऐसे पैरामीटर होते हैं जो प्रशिक्षण के दौरान सीखे जाते हैं।

model = keras.Sequential([
keras.layers.Flatten(input_shape=(28, 28)),
keras.layers.Dense(128, activation='relu'),
keras.layers.Dense(10, activation='softmax')
])

मॉडल को संकलित करना

प्रशिक्षण के लिए तैयार होने से पहले कुछ और सेटिंग्स जोड़ने के लिए मॉडल संकलन चरण का उपयोग किया जाता है। इस मामले में, निम्न सेटिंग्स सक्षम हैं।

1. ऑप्टिमाइज़र—मॉडल को उसके द्वारा देखे जाने वाले डेटा और उसके नुकसान फ़ंक्शन (नीचे देखें) के आधार पर अपडेट करता है।
2. हानि फ़ंक्शन—यह मापता है कि प्रशिक्षण के दौरान मॉडल कितना सटीक है। आप मॉडल को सही दिशा में "चलाने" के लिए इस फ़ंक्शन को छोटा करना चाहते हैं।
3. मैट्रिक्स—प्रशिक्षण और परीक्षण चरणों की निगरानी करें। निम्नलिखित उदाहरण सटीकता का उपयोग करता है, छवियों का अंश जो सही ढंग से वर्गीकृत किया गया है।

model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])

मॉडल को प्रशिक्षण देना

तंत्रिका नेटवर्क मॉडल को प्रशिक्षित करने के लिए निम्नलिखित चरणों की आवश्यकता होती है।

1. मॉडल को प्रशिक्षण डेटा फ़ीड करें।
2. मॉडल छवियों और लेबल को संबद्ध करना सीखता है।
3. एक परीक्षण सेट के बारे में अनुमान लगाएं।
4. सत्यापित करें कि भविष्यवाणियां test_labels सरणी के लेबल से मेल खाती हैं।

प्रशिक्षण शुरू करने के लिए, model.fit मेथड को कॉल करें—तथाकथित क्योंकि यह मॉडल को ट्रेनिंग डेटा के लिए "फिट" करती है:

model.fit(train_images, train_labels, epochs=10)
Train on 60000 samples
Epoch 1/10
60000/60000 [==============================] - 5s 83us/sample - loss: 0.4964 - accuracy: 0.8236
Epoch 2/10
60000/60000 [==============================] - 4s 65us/sample - loss: 0.3735 - accuracy: 0.8642
Epoch 3/10
60000/60000 [==============================] - 3s 55us/sample - loss: 0.3347 - accuracy: 0.8773
Epoch 4/10
60000/60000 [==============================] - 3s 56us/sample - loss: 0.3106 - accuracy: 0.8861
Epoch 5/10
60000/60000 [==============================] - 3s 58us/sample - loss: 0.2921 - accuracy: 0.8924s - loss: 0.2928 - accura - ETA: 0s - loss: 0.2925 - accuracy
Epoch 6/10
60000/60000 [==============================] - 3s 57us/sample - loss: 0.2796 - accuracy: 0.8969s
Epoch 7/10
60000/60000 [==============================] - 4s 70us/sample - loss: 0.2659 - accuracy: 0.9007
Epoch 8/10
60000/60000 [==============================] - 4s 61us/sample - loss: 0.2548 - accuracy: 0.9042
Epoch 9/10
60000/60000 [==============================] - 4s 61us/sample - loss: 0.2449 - accuracy: 0.9084
Epoch 10/10
60000/60000 [==============================] - 5s 76us/sample - loss: 0.2358 - accuracy: 0.9118

प्रत्येक युग के अंत में, तंत्रिका नेटवर्क का मूल्यांकन सत्यापन सेट के विरुद्ध किया जाता है। यही हानि और सटीकता का उल्लेख है।

सटीकता का मूल्यांकन करें और अनुमान लगाएं

मॉडल की समग्र सटीकता का अनुमान लगाने के लिए, सटीकता मान की सभी दस घटनाओं के औसत की गणना करें, इस मामले में 88%।

फिर model.evaluate execute निष्पादित करें पहले से देखे गए डेटा पर प्रशिक्षित तंत्रिका नेटवर्क की भविष्यवाणी सटीकता प्राप्त करने के लिए परीक्षण सेट पर।

test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2)
10000/1 - 0s - loss: 0.2766 - accuracy: 0.8740

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

इस समय, हम अपने प्रशिक्षण डेटा सेट में छवियों के बारे में कुछ अनुमान लगा सकते हैं।

predictions = model.predict(test_images)
predictions[0]
array([1.90860412e-08, 8.05085235e-11, 1.56402713e-08, 1.66699390e-10,
7.86950158e-11, 4.33062996e-06, 2.49049066e-08, 1.20656565e-02,
3.80084719e-09, 9.87929940e-01], dtype=float32)

model.predict . का आउटपुट प्रत्येक वर्ग से संबंधित एक उदाहरण की संभावना के साथ 10 संख्याओं की एक सरणी है। आगे के विश्लेषण और रिपोर्टिंग के लिए मारियाडीबी डेटाबेस में परिणामों को बनाए रखना एक अच्छा विचार है। नीचे एक उदाहरण दिया गया है कि कैसे एक टपल बनाने और फिर उसे prediction_results में डालने के लिए प्रेडिक्शन एरे पर पुनरावृति की जाए। टेबल।

sql = "INSERT INTO prediction_results (
img_idx
, img_use
, T_shirt_Top
, Trouser
, Pullover
, Dress
, Coat
, Sandal
, Shirt
, Sneaker
, Bag
, Ankle_boot
, label)
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s);"
i = 0
for row in predictions:
insert_tuple = (str(i), str(2)
, str(row[0]), str(row[1]), str(row[2]), str(row[3]), str(row[4])
, str(row[5]), str(row[6]), str(row[7]), str(row[8]), str(row[9])
, str(test_labels[i]))
cur.execute(sql, insert_tuple)
conn.commit()
i += 1

एक बार फिर, एक साधारण SQL कथन का उपयोग यह सत्यापित करने के लिए किया जा सकता है कि डेटा लोड हो गया है।

sql = "SELECT T_shirt_Top
, Trouser
, Pullover
, Dress
, Coat
, Sandal
, Shirt
, Sneaker
, Bag
, Ankle_boot
, class_name as 'Test Label'
FROM prediction_results JOIN categories ON label = class_idx WHERE img_idx = 1"
display( pd.read_sql(sql,conn) )

भविष्यवाणियां प्लॉट करना

भविष्यवाणियों को प्रदर्शित करने के लिए कुछ प्लॉटिंग फ़ंक्शन नीचे परिभाषित किए गए हैं (ग्राफ़िंग फ़ंक्शन)।

आइए परीक्षण सेट से एक नई छवि प्राप्त करें और भविष्यवाणी की संभावना के आधार पर तंत्रिका जाल वर्गीकरण प्रदर्शित करें।

sql = "SELECT img_idx, label FROM prediction_results WHERE img_idx = 1"
cur.execute(sql)
result = cur.fetchone()
plt.figure(figsize=(6,3))
plt.subplot(1,2,1)
plot_image(result[0], predictions[result[0]], test_labels, test_images)
plt.subplot(1,2,2)
plot_value_array(result[0], predictions[result[0]], test_labels)
plt.show()

ऊपर:Fashion_mnist डेटासेट से इमेज

इस मामले में, मॉडल छवि को 100% सटीकता के साथ सही ढंग से वर्गीकृत करने में सक्षम था। इसके बाद परीक्षण सेट से पहली 15 छवियों को पुनः प्राप्त करने और उन्हें वर्गीकृत करने के लिए एक क्वेरी निष्पादित करें।

sql = "SELECT img_idx, label FROM prediction_results LIMIT 15"
num_rows = 5
num_cols = 3
plt.figure(figsize=(2*2*num_cols, 2*num_rows))
cur.execute(sql)
result = cur.fetchall()
for row in result:
plt.subplot(num_rows, 2*num_cols, 2*row[0]+1)
plot_image(row[0], predictions[row[0]], test_labels, test_images)
plt.subplot(num_rows, 2*num_cols, 2*row[0]+2)
plot_value_array(row[0], predictions[row[0]], test_labels)
plt.tight_layout()
plt.show()

ऊपर:Fashion_mnist डेटासेट से इमेज

जैसा कि आप देख सकते हैं, ऐसे उदाहरण होंगे जहां मॉडल गलत हो सकता है जैसा कि अंतिम पंक्ति, बाएं कॉलम में दिखाया गया है। इस मामले में, एक स्नीकर को सैंडल (लाल रंग में) के रूप में वर्गीकृत किया गया था।

सारांश में

हालांकि TensorFlow और MariaDB सर्वर के बीच एकीकरण आसान है, इस एकीकरण के लाभ पर्याप्त हैं:

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

MIT लाइसेंस

इस ब्लॉग द्वारा उपयोग किए जाने वाले फैशन एमएनआईएसटी (fashion_mnist) डेटासेट को एमआईटी लाइसेंस, कॉपीराइट © 2017 ज़ालैंडो एसई, https://tech.zalando.com

इस ब्लॉग द्वारा प्राप्त स्रोत कोड को "मूल वर्गीकरण:कपड़ों की छवियों को वर्गीकृत करें" ट्यूटोरियल से अनुकूलित किया गया है, जिसे एमआईटी लाइसेंस, कॉपीराइट (सी) 2017 फ्रांकोइस चॉलेट के तहत लाइसेंस प्राप्त है।

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

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

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

संदर्भ

स्वयं की छवि को MNIST की छवि में बदलें
matplotlib:छवि ट्यूटोरियल
5 तरीके AI ग्राहक अनुभव को बदल रहा है
डिजिटलीकरण व्यवसाय को फिर से खोज रहा है
छवि वर्गीकरण क्या है?
पायथन का परिचय डीप लर्निंग लाइब्रेरी TensorFlow

ग्राफ़िंग फ़ंक्शन

def plot_image(i, predictions_array, true_label, img):
predictions_array, true_label, img = predictions_array, true_label[i], img[i]
plt.grid(False)
plt.xticks([])
plt.yticks([])

plt.imshow(img, cmap=plt.cm.binary)

predicted_label = np.argmax(predictions_array)
if predicted_label == true_label:
color = 'blue'
else:
color = 'red'

plt.xlabel("{} {:2.0f}% ({})".format(class_names[predicted_label],
100*np.max(predictions_array),
class_names[true_label]),
color=color)

def plot_value_array(i, predictions_array, true_label):
predictions_array, true_label = predictions_array, true_label[i]
plt.grid(False)
plt.xticks(range(10))
plt.yticks([])
thisplot = plt.bar(range(10), predictions_array, color="#777777")
plt.ylim([0, 1])
predicted_label = np.argmax(predictions_array)

thisplot[predicted_label].set_color('red')
thisplot[true_label].set_color('blue')