कन्वोल्यूशन बनाएं और पूल करें

1. शुरू करने से पहले

इस कोडलैब में आप #39 चरणों के बारे में जानेंगे. साथ ही, आप यह भी जान पाएंगे कि कंप्यूटर विज़न स्थितियों में यह इतना ज़रूरी क्यों है.

पिछले कोडलैब में, आप फ़ैशन आइटम के कंप्यूटर विज़न के लिए एक आसान डीप न्यूरल नेटवर्क (डीएनएन) बनाते थे. यह सीमित था, क्योंकि तस्वीर में सिर्फ़ कपड़ों के आइटम को ही शामिल किया जाना ज़रूरी था.

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

ज़रूरी शर्तें

यह कोडलैब दो पिछली किश्तों में पूरा हुआ काम तैयार करता है, नमस्ते, &kot;नमस्ते, World&quat; मशीन लर्निंग का, और कंप्यूटर विज़न मॉडल बनाएं. आगे बढ़ने से पहले, कृपया उन कोडलैब को पूरा करें.

आप क्या #39;जानेंगे

• कॉन्वोल्यूशन क्या हैं
• फ़ीचर मैप बनाने का तरीका
• पूलिंग क्या है

आप क्या बनाते हैं

• किसी इमेज का फ़ीचर मैप

आपको क्या चाहिए

आप Colab में चल रहे कोडलैब के बाकी कोड के लिए कोड देख सकते हैं.

आपको #39; TensorFlow इंस्टॉल करने के साथ ही, पिछले कोडलैब में इंस्टॉल की गई लाइब्रेरी की भी ज़रूरत होगी.

2. कॉन्वोल्यूशन क्या हैं?

कंवोल्यूशन, ऐसा फ़िल्टर होता है जो किसी इमेज के ऊपर से जाता है, उसे प्रोसेस करता है, और ज़रूरी सुविधाएं निकालता है.

मान लें कि आपने स्नीकर पहने हुए एक व्यक्ति की इमेज खींची है. आप कैसे पता करेंगे कि इमेज में स्नीकर मौजूद है? आपके प्रोग्राम के लिए स्नीकर के तौर पर इमेज को "देखने" के रूप में देने के लिए, आपको #33; ज़रूरी सुविधाएं निकालनी होंगी और ज़रूरी सुविधाओं को धुंधला करना होगा. इसे फ़ीचर मैपिंग कहा जाता है.

सैद्धांतिक तौर पर, सुविधा को मैप करने की प्रोसेस बहुत आसान है. आप हर इमेज में हर पिक्सल स्कैन करेंगे और फिर उसके आस-पास के पिक्सल देखेंगे. आप फ़िल्टर में, उन पिक्सल की वैल्यू को उसके बराबर वाले वज़न से गुणा करते हैं.

उदाहरण के लिए:

इस मामले में, एक 3x3 कॉन्वोल्यूशन मैट्रिक्स या इमेज kernel बताया जाता है.

मौजूदा पिक्सल वैल्यू 192 है. नए मान की गणना करने के लिए, आप आस-पास के मानों को देख सकते हैं, फ़िल्टर में दी गई वैल्यू से गुणा कर सकते हैं, और नई पिक्सल वैल्यू को आखिरी रकम बना सकते हैं.

अब 2D ग्रेस्केल इमेज पर बुनियादी कॉन्फ़िगरेशन बनाकर कन्वर्ज़न के काम करने के तरीके को एक्सप्लोर करने का समय आ गया है.

SciPy की फ़्यूनिक इमेज की मदद से, इसे दिखाया जा सकता है. यह कई कोणों और रेखाओं वाली एक अच्छी पहले से मौजूद तस्वीर है.

3. कोडिंग शुरू करें

कुछ Python लाइब्रेरी और चढ़ाई की जानकारी इंपोर्ट करने से शुरुआत करें:

import cv2
import numpy as np
from scipy import misc
i = misc.ascent()

इसके बाद, इमेज बनाने के लिए Pyplot लाइब्रेरी matplotlib का इस्तेमाल करें, ताकि आप जान सकें कि यह कैसा दिखता है:

import matplotlib.pyplot as plt
plt.grid(False)
plt.gray()
plt.axis('off')
plt.imshow(i)
plt.show()

आप देख सकते हैं कि यह सीढ़ियों की इमेज है. ऐसी कई सुविधाएं हैं जिन्हें आप आज़मा सकते हैं और अलग कर सकते हैं. उदाहरण के लिए, इसमें वर्टिकल वर्टिकल लाइनें होती हैं.

इमेज को NumPy श्रेणी में स्टोर किया जाता है, ताकि हम सिर्फ़ उस कॉपी को कॉपी करके पूरी तरह बदली गई इमेज बना सकें. size_x और size_y वैरिएबल में इमेज के डाइमेंशन होंगे, ताकि आप उन्हें बाद में लूप में चला सकें.

i_transformed = np.copy(i)
size_x = i_transformed.shape[0]
size_y = i_transformed.shape[1]

4. कन्वर्ज़न मैट्रिक्स बनाएं

सबसे पहले, 3x3 श्रेणी के रूप में एक कॉन्फ़िगरेशन मैट्रिक्स (या कर्नेल) बनाएं:

# This filter detects edges nicely
# It creates a filter that only passes through sharp edges and straight lines. 
# Experiment with different values for fun effects.
#filter = [ [0, 1, 0], [1, -4, 1], [0, 1, 0]] 
# A couple more filters to try for fun!
filter = [ [-1, -2, -1], [0, 0, 0], [1, 2, 1]]
#filter = [ [-1, 0, 1], [-2, 0, 2], [-1, 0, 1]]
 # If all the digits in the filter don't add up to 0 or 1, you 
# should probably do a weight to get it to do so
# so, for example, if your weights are 1,1,1 1,2,1 1,1,1
# They add up to 10, so you would set a weight of .1 if you want to normalize them
weight  = 1

अब, आउटपुट पिक्सल का हिसाब लगाएं. इमेज के ऊपर 1-पिक्सल मार्जिन छोड़कर, मौजूदा पिक्सल के हर पड़ोसी को फ़िल्टर में तय की गई वैल्यू से गुणा करें.

इसका मतलब है कि मौजूदा Pixel' के आस-पास के पिक्सल और बाईं ओर दिए गए आइटम को, फ़िल्टर में सबसे ऊपर बाईं ओर मौजूद आइटम से गुणा कर दिया जाएगा. इसके बाद, नतीजे को वेट से गुणा करें और पक्का करें कि नतीजा 0 से 255 की रेंज में हो.

आखिर में, बदली गई इमेज में नई वैल्यू लोड करें:

for x in range(1,size_x-1):
  for y in range(1,size_y-1):
      output_pixel = 0.0
      output_pixel = output_pixel + (i[x - 1, y-1] * filter[0][0])
      output_pixel = output_pixel + (i[x, y-1] * filter[0][1])
      output_pixel = output_pixel + (i[x + 1, y-1] * filter[0][2])
      output_pixel = output_pixel + (i[x-1, y] * filter[1][0])
      output_pixel = output_pixel + (i[x, y] * filter[1][1])
      output_pixel = output_pixel + (i[x+1, y] * filter[1][2])
      output_pixel = output_pixel + (i[x-1, y+1] * filter[2][0])
      output_pixel = output_pixel + (i[x, y+1] * filter[2][1])
      output_pixel = output_pixel + (i[x+1, y+1] * filter[2][2])
      output_pixel = output_pixel * weight
      if(output_pixel<0):
        output_pixel=0
      if(output_pixel>255):
        output_pixel=255
      i_transformed[x, y] = output_pixel

5. नतीजों की जांच करना

अब, इमेज को फ़िल्टर करके उसके ऊपर फ़िल्टर का असर देखें:

# Plot the image. Note the size of the axes -- they are 512 by 512
plt.gray()
plt.grid(False)
plt.imshow(i_transformed)
#plt.axis('off')
plt.show()   

नीचे दिए गए फ़िल्टर वैल्यू और इमेज पर उनके असर के बारे में सोचें.

[-1,0,1,-2,0,2,-1,0,1] का इस्तेमाल करने से आपको वर्टिकल लाइनों का एक बहुत मज़बूत सेट मिलता है:

[-1,-2,-1,0,0,0,1,2,1] का इस्तेमाल करने से आपको हॉरिज़ॉन्टल लाइन मिलती हैं:

अलग-अलग वैल्यू एक्सप्लोर करें! अलग-अलग साइज़ वाले फ़िल्टर भी आज़माएं, जैसे कि 5x5 या 7x7.

6. पूल करने के बारे में समझना

आपने इमेज की ज़रूरी सुविधाओं की पहचान कर ली है? आप इमेज की कैटगरी तय करने के लिए, नतीजे में मिलने वाले फ़ीचर मैप का इस्तेमाल कैसे करेंगे?

कन्वर्ज़न की तरह ही, पूल करने से सुविधाओं का पता लगाने में भी मदद मिलती है. पूल करने की परत, मौजूदा रूप से पहचानी गई सुविधाओं को बनाए रखते हुए, किसी इमेज में जानकारी की कुल मात्रा कम करती हैं.

पूल कई तरह के होते हैं, लेकिन आप सबसे ज़्यादा (ज़्यादा से ज़्यादा) पूल का इस्तेमाल कर सकते हैं.

इमेज को दोहराने के बाद, दाईं ओर, नीचे, और दाईं तरफ़ पिक्सल और उसके आस-पास के पड़ोसियों को ध्यान में रखें. इनमें से सबसे बड़ी संख्या लें (इसलिए ज़्यादा से ज़्यादा पूल करें) और उसे नई इमेज में लोड करें. इस तरह, पुरानी इमेज का साइज़ एक-चौथाई से ज़्यादा होगा.

7. पूल करने के लिए कोड लिखें

नीचे दिए गए कोड में (2, 2) पूलिंग दिखेगी. आउटपुट देखने के लिए इसे चलाएं.

आप देख सकते हैं कि इमेज, ओरिजनल क्वालिटी के एक-चौथाई से ज़्यादा है, लेकिन उसमें सभी सुविधाएं मौजूद हैं.

new_x = int(size_x/2)
new_y = int(size_y/2)
newImage = np.zeros((new_x, new_y))
for x in range(0, size_x, 2):
  for y in range(0, size_y, 2):
    pixels = []
    pixels.append(i_transformed[x, y])
    pixels.append(i_transformed[x+1, y])
    pixels.append(i_transformed[x, y+1])
    pixels.append(i_transformed[x+1, y+1])
    pixels.sort(reverse=True)
    newImage[int(x/2),int(y/2)] = pixels[0]
 
# Plot the image. Note the size of the axes -- now 256 pixels instead of 512
plt.gray()
plt.grid(False)
plt.imshow(newImage)
#plt.axis('off')
plt.show()

उस प्लॉट के अक्षों पर ध्यान दें. यह इमेज अब 256x256 है, जो अपने मूल साइज़ का एक-चौथाई है. साथ ही, इमेज में कम डेटा होने के बावजूद, पहचानी गई सुविधाओं को बेहतर बना दिया गया है.

8. बधाई हो

आपने #39;अपना पहला कंप्यूटर दृष्टि मॉडल बनाया है! अपने कंप्यूटर के विज़न मॉडल को बेहतर बनाने का तरीका जानने के लिए, कंप्यूटर विज़न को बेहतर बनाने के लिए कन्वर्ज़न न्यूरल नेटवर्क (CNN) बनाएं.