ஒரு database-ல் சேமிப்பதற்கு ஏற்ற வகையில் தரவுகளைக் கொண்ட அமைப்பிற்கு ‘Structured data’ என்று பெயர். இதுவரை நாம் பார்த்த அனைத்தும் ஒரு முறையான வடிவமைப்பைக் கொண்ட தரவுகளை நெட்வொர்குக்கு கொடுத்து எவ்வாறு பயிற்சி அளிப்பது என்று பார்த்தோம். இனிவரும் பகுதிகளில் ஒழுங்கற்ற தரவுகளுக்கான மாடல்களை எவ்வாறு உருவாக்குவது என்று பார்க்கலாம்.
அட்டவணை வடிவத்தில் அமையும் தரவுகள் ‘structured data’ என்றால், இவ்வடிவில் சேமிக்க இயலாத படங்கள், காணொளிகள் , உரை தரவுகள், குரல் கோப்புகள் (images, videos, text data, voice data) ஆகியவை ‘unstructured data’ ஆகும். CNN, RNN போன்றவை இத்தகைய வேலைகளுக்காகப் பயன்படுகின்றன. இவைகளைப் பற்றியெல்லாம் இனிவரும் பகுதிகளில் பார்க்கலாம்.
அதிக படங்களைக் கொண்டு பயிற்சி பெற்று புதிதாக வருகின்ற ஒரு படம் “என்ன படம்?” என கணிக்கும் வேலையை CNN சிறப்பாக செய்கிறது. பொதுவாக படங்களை வகைப்படுத்தி அடையாளம் (Image classification & identification) காணுவதற்கான ஒரு சிறப்பு வகை வடிவமைப்பில் இந்த CNN உருவாக்கப்பட்டுள்ளது. இவற்றில் பயன்படுத்தப்படும் சிறப்பு வகைப் பதங்களான Convolution, Pooling, Striding, Padding, Flattened array, FC (fully connected network) போன்றவை என்னென்ன வகைகளில் இந்த செயலுக்கு உதவுகின்றன? அவற்றையெல்லாம் எந்தெந்த இடங்களில் பயன்படுத்த வேண்டும்? போன்றவை பற்றியெல்லாம் இப்பகுதியில் காணலாம். இதன் கட்டமைப்பு பின்வருமாறு இருக்கும். இதில் உள்ள ஒவ்வொரு படியையும் விளக்கமாகக் கீழே காணலாம்.
படி1 – Input Matrix: முதலில் ஒரு படத்தை கணினி புரிந்து கொள்வதற்கு ஏற்ற வகையில் எவ்வாறு அமைக்க வேண்டும் என்பது நமக்குத் தெரிந்திருக்க வேண்டும். கணினியைப் பொருத்த வரை ஒரு படம் என்பது பல்வேறு பிக்சல்களால் உருவானது. இந்தப் பல்வேறு நிறப் பிக்சல்களைக் கொண்ட படத்தை
பல்வேறு எண்களைக் கொண்ட ஒரு அணியாக மாற்றி பின்னர்தான் CNN-க்கு உரிய பல்வேறு வேலைகளைத் துவங்க வேண்டும். RGB என்பது முதன்மை வண்ணங்கள். இவை ஒவ்வொன்றும் தன்னுடைய shades-ன் தீவிரத்தைப் பொறுத்து 0-255 வரை அமைந்த எண்களால் குறிக்கப்படும். இதுவே colour codes என்றழைக்கப்படுகிறது. இத்தகைய எண்களின் கலப்பே பல்வேறு நிறப் பிக்சல்களால் ஆன படத்தை ஒரு அணியாக மாற்ற உதவும்.
நியூரல் நெட்வொர்கைப் பொறுத்தவரை இத்தகைய ஒவ்வொரு பிக்சல் மதிப்பும் ‘என்ன படம்?’ என்பதைக் கணிக்க உதவும் features-ஆக அமையும்.
எனவே இத்தகைய features-ன் எண்ணிக்கையைக் குறைத்து நெட்வொர்குக்கு அனுப்ப CNN பல்வேறு வழிவகைகளைக் கையாள்கிறது. அவைகளைப் பற்றி
இப்பகுதியில் காணலாம். முதலில் அமையும் அணி Input Matrix என்றழைக்கப்படுகிறது. இதற்கு அடுத்த படியாக ‘Convolution’ என்ற ஒன்று நடைபெற்று
features-ன் எண்ணிக்கையைக் குறைக்கிறது.
படி2 – Convolution: இப்படியில் நம்முடைய படத்தின் பரிமாணம் குறைக்கப்படுகிறது. ‘பரிமாணத்தைக் குறைத்தல்’ என்றால் படத்தை எவ்விதத்திலும் வெட்டி எடுக்காமல் வெறும் பெரிய அளவு படத்தை சிறிய அளவில் மாற்றுவதைக் குறிக்கும். இதன் மூலம் படத்தின் தீவிரம் குறைந்தாலும், படத்திற்கு எவ்வித இழப்பும் ஏற்படாது. இது பின்வரும் முறையில் நிகழ்கிறது.
முதலில் 2*2 அல்லது 3*3 போன்ற சிறிய வடிவமைப்பைக் கொண்ட ஒரு அணி வரையறுக்கப்படுகிறது. இதுவே பெரிய படத்தின் பரிமாணத்தைக் குறைக்க உதவும் ஒரு வடிகட்டி(filters) / அளவுறுக்கள்(parameters) ஆகும். இது நியூரல் நெட்வொர்கில் நாம் பயன்படுத்தும் weights-க்குச் சமமானது.
• Scharr filter, Sobel filter போன்றவற்றை இத்தகைய வேலைகளுக்காகப் பயன்படுத்தலாம். Scharr filter என்பது சிறு சிறு பகுதிகளாகப் பிரிக்கப்படும் படத்தின் ஒவ்வொரு பகுதி முனைகளுக்கும் முக்கியத்துவம் கொடுத்து வடிகட்டி எடுக்கும். இதுவே ‘Edge Detection’ என்று அழைக்கப்படுகிறது.
• Sobel filter என்பது ஒரு படத்தின் மையப் பகுதியிலுள்ள பிக்சல்களுக்கு அதிக முக்கியத்துவம் கொடுத்து அதனடிப்படையில் வடிகட்டும். இத்தகைய வடிகட்டியின் மதிப்புகள் பின்வருமாறு.
• மேலும் இந்த வடிகட்டும் நிகழ்வானது கிடைமட்டவாக்கில் நிகழ வேண்டுமா அல்லது செங்குத்துவாக்கில் நிகழ வேண்டுமா என்பதைப் பொறுத்து இவற்றில் அமையும் சுழியம் மதிப்புகள் இடம்மாறுகின்றன.
• இவைகளல்லாமல் நாமே கூட நமக்கேற்றவாறு மதிப்புகளைக் கொண்ட ஒரு வடிகட்டியை உருவாக்கிப் பயன்படுத்தலாம். இதுவே நம்முடைய மாடல் பயன்படுத்துகின்ற parameters ஆகும். எனவே back propagation முறைப்படி இது தனக்கான சரியான மதிப்பினைக் கற்றுக் கொண்டுவிடும்.
இதுபோன்ற ஒரு வடிகட்டியின் அளவில் பொருந்தும் படி நம்முடைய உள்ளீட்டு அணியானது முழுவதும் சிறு சிறு பகுதிகளாகப் பிரிக்கப்படுகிறது.
கீழ்க்கண்ட எடுத்துக்காட்டில் 3,5,2,1…. எனத் துவங்கும் உள்ளீட்டு அணியும், 1,0,1 எனும் மதிப்பினைப் பெற்றுத் துவங்கும் 3*3 filter அணியும் வரையறுக்கப்பட்டுள்ளது. இது தன்னுடைய அளவில் பொருந்தும் படியாக உள்ளீட்டு அணியின் இடது மூலையில் தொடங்கி படம் முழுவதையும் சிறு சிறு பகுதிகளாகப் பிரிக்கப்படுகிறது. முதலில் படத்தின் இடது மூலையிலிருந்து 3,5,2 எனும் மதிப்பினைப் பெற்றுத் துவங்கும் 3*3 அணியை எடுக்கிறது.
பின்னர் இச்சிறிய அணி மற்றும் வடிகட்டி அணி எனும் இவ்விரண்டு அணிகளின் பெருக்கல் நடைபெற்று புதிய அணியை உருவாக்குகிறது. இந்தப் புதிய அணியில் உள்ள மதிப்புகள் அனைத்தும் கூட்டப்பட்டு 30 எனும் சிறிய எண் வடிவில் குறிக்கப்படுகிறது. இதுவே “Convolved output” என்றழைக்கப்படும் அணியில் இடம்பெறும் முதல் மதிப்பாகும்.
இவ்வாறு “Convolved output” -ன் அடுத்தடுத்த மதிப்பினை உருவாக்கப் போகும் அணி முதல் அணியிலிருந்து எவ்வளவு இடைவெளி விட்டு தேர்ந்தெடுக்க வேண்டும் என்பதையே stride எனும் parameter குறிக்கிறது. மேற்கண்ட எடுத்துக்காட்டில் stride (S=1) எனும்போது முதல் அணியிலிருந்து ஒரு இடைவெளி விட்டு 5,2,1 எனும் மதிப்பைக் கொண்ட அடுத்த அணி தேர்ந்தெடுக்கப்படுகிறது. அதுவே stride=2 எனும்போது முதல் அணியிலிருந்து இரண்டு இடைவெளி விட்டு 2,1,2 எனும் மதிப்பினைக் கொண்ட அணி அடுத்த அணியாகத் தேர்ந்தெடுக்கப்படுவதைக் காணலாம். பின்னர் தேர்ந்தெடுக்கப்பட்ட இத்தகைய அணிகளுடன் பெருக்கல், கூட்டல் ஆகியவை நடைபெற்று “Convolved output” -ன் அடுத்தடுத்த மதிப்புகள் உருவாக்கப்படுகின்றன. இவ்வாறாக stride மதிப்பினைப் பொறுத்து convolution நடைபெறுகிறது. ஒரு n*n அணியை f*f வடிகட்டி மூலம் வடிகட்டும்போது உருவாகும் குறைந்த பரிமாணத்தைக் கொண்ட அணியானது [ (n-f ) / s ] + 1எனும் வாய்ப்பாட்டின் படி அமையும். மேற்கண்ட எடுத்துக்காட்டில் 9*9 அணியை 3*3 வடிகட்டி மூலம் வடிகட்டும்போது கிடைக்கும் convolved output-ன் மதிப்பு,
• stride=1 எனில் 7*7 எனவும் i.e [ (9-3) / 1 ] + 1,
• stride=2 எனில் 4*4 எனவும் i.e [ (9-3) / 2 ] + 1, மேற்கண்ட படி அமைந்திருப்பதைக் காணலாம்.
இதற்கு அடுத்த படியாக ‘Pooling’ என்பதைப் பற்றிக் காணலாம்.
படி3 – Pooling:
ஒரு படத்தின் பரிமாணத்தைக் குறைப்பது ‘convolution’ என்றால், அப்படத்தின் அளவைக் குறைப்பது ‘Pooling’ எனப்படும். அதாவது குறைக்கப்பட்ட பரிமாணம் கொண்ட ஒரு படத்தின் மீது மீண்டும் ஒரு வடிகட்டியை செயல்படுத்தி, அதனை சிறு சிறு பகுதிகளாகப் பிரிக்கிறது. பின்னர் ஒவ்வொரு பகுதியிலிருந்தும் ஒருசில பிக்சல்களை மட்டும் தேர்ந்தெடுப்பதன் மூலம் அப்படத்தின் அளவு குறைக்கப்படுகிறது. இம்முறையில் பிக்சல்களைத் தேர்ந்தெடுக்க பல்வேறு வழிவகைகளை Pooling கையாள்கிறது. ஒரு வடிகட்டி மூலம் படமானது பல்வேறு பகுதிகளாகப் பிரிக்கப்பட்ட பின்னர், ஒவ்வொரு பகுதியிலும் உள்ள பிக்சல்களில் பெரியதை தேர்வு செய்வது, சிறியதை தேர்வு செய்வது, அவைகளின் சராசரி மதிப்பினைத் தேர்வு செய்வது முறையே Max pooling, Min pooling, Avg pooling என்று அழைக்கப்படுகின்றன. மேற்கண்ட எடுத்துக்காட்டில் 2*2 வடிகட்டி அணி பயன்படுத்தப்பட்டுள்ளது. எனவேதான் 2*2 அமைப்பில் ‘convolved output’ -ஆனது சிறு சிறு பகுதிகளாகத் தேர்வு செய்யப்படுகிறது.
முதலில் ‘convolved output’ -ன் இடது மூலையிலிருந்து 30,14,17,26 எனும் பிக்சல் மதிப்புகளைக் கொண்ட சிறுபகுதி தேர்ந்தெடுக்கப்படுகிறது. பின்னர் இதில் ‘Max Pooling’ பயன்படுத்தப்பட்டு இவைகளில் பெரிய மதிப்பான 30 என்பது தேர்ந்தெடுக்கப்படுகிறது. இவ்வாறு அடுத்தடுத்த பகுதியிலிருந்தும் ‘Max pooling’ மூலம் மதிப்புகள் தேர்ந்தெடுக்கப்படுவதால் படத்தின் அளவு குறைக்கப்படுகிறது.
விருப்ப படி – Padding:
இதை கட்டாயமாக்க வேண்டிய அவசியமில்லை. நீங்கள் விருப்பப்பட்டால் இதைப் பயன்படுத்திக் கொள்ளலாம். Padding என்பது படத்தின் நான்கு மூலைகளிலும் சுழியம் நிறைந்த வரிசைகளை உருவாக்கி படத்திற்கு எல்லை போன்ற ஒரு வடிவமைப்பைக் கொடுக்கும். இதுவே Zero padding என்று அழைக்கப்படுகிறது. ஏனெனில் மேற்கூறிய முறைகளில் அளவுகள் குறைக்கப்படும்போது, படத்தின் நான்கு மூலைகளிலும் உள்ள பிக்சல் மதிப்புகள் நீக்கப்படலாம். இதனால் அத்தகைய முனைகளிலிருந்து நமக்குக் கிடைக்க வேண்டிய சில முக்கியத் தகவல்கள் கிடைக்காமல் போவதற்கான வாய்ப்புகள் உள்ளன. இதனைத் தவிர்ப்பதற்காக வந்ததே Padding ஆகும்.. இதன் மூலம் மூலைகளிலுள்ள பிக்சல் மதிப்புகள் நீக்கப்பட்டாலும், படத்தின் எல்லையிலுள்ள சுழிய மதிப்புகள் நீக்கப்படுமே தவிர படத்திற்கு எந்தவித இழப்பும் ஏற்படாது..
மேற்கண்ட எடுத்துக்காட்டில் 9*9 அணியை 3*3 வடிகட்டி மூலம் வடிகட்டும்போது, கிடைக்கும் convolved output-ன் மதிப்பு 7*7 எனப் பார்த்தோம். இதுவே படத்தின் நான்கு மூலைகளிலும் இரண்டு வரிசைகளில் சுழிய மதிப்புகளை அளித்தால் 9*9 அணியானது 11*11 என மாற்றப்பட்டு கிடைக்கும் convolved output-ன் மதிப்பும் 9*9 i.e [ (11-3) / 1 ] + 1 என்றே அமையும். எனவே zero padding பயன்படுத்தும்போது, 9*9 அணியானது convolution-க்குப் பிறகும் 9*9 அணியை உருவாக்குவதால் இது “same padding” என்ற பெயரில் அழைக்கப்படுகிறது. இவைகள் எதையும் பயன்படுத்தாமல் சுழிய மதிப்புகள் எதுவும் வழங்காமல், ஒரு படத்தை அப்படியே பயன்படுத்துவதே “valid padding” என்ற பெயரில் அழைக்கப்படுகிறது.
கடைசி படி:
மேற்கூறிய convolution மற்றும் pooling திரும்பத் திரும்ப நடைபெற்று ஒரு படத்தின் அளவு சுருக்கப்படுகிறது. பின்னர் சுருக்கப்பட்ட படத்திலுள்ள பிக்சல் மதிப்புகளே அப்படத்தை அடையாளம் காணுவதற்கான features -ஆக அமையும். இதுவே ‘Flattened array of input values’ என்று அழைக்கப்படுகிறது. இம்மதிப்புகளே FC எனப்படும் ‘Fully connected network’-க்குள் செலுத்தப்பட்டு கடைசி லேயரில் என்ன படம் என்பது வகைப்படுத்தப்படுகிறது.
கீழ்க்கண்ட எடுத்துக்காட்டில் ஒரு படமானது முதலில் எவ்வாறு உள்ளது. Padding மூலம் படத்திற்கு எல்லைகள் எவ்வாறு அமைக்கப்படுகிறது. Convolution-க்குப் பின்னர் படம் எவ்வாறு மாறுகிறது. கடைசியாக Pooling மூலம் படம் எவ்வாறு சுருங்குகிறது என்பது காட்டப்பட்டுள்ளது. மற்ற நெட்வொர்க் போன்று CNN-ஐ ஆதியிலிருந்து உருவாக்கிக் காட்டுவது என்பது ஒரு ஆராய்ச்சிக் கட்டுரையை நிகழ்த்திக் காட்டுவதற்கு சமமாகும். எனவேதான் இந்த அளவிலேயே எடுத்துக்காட்டை நிறுத்திக் கொண்டேன். பொதுவாக ஏற்கெனவே உருவாக்கப்பட்ட CNN மாடல்களை எடுத்து நமக்கேற்றவாறு அதற்கு மாற்றிப் பயிற்சி அளித்துப் பயன்படுத்திக் கொள்வதே சிறப்பாக அமையும்.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| import numpy as np | |
| import matplotlib.pyplot as plt | |
| import matplotlib.image as mpimg | |
| def zero_pad(X, pad): | |
| X_padded = np.pad(array = X, pad_width = ((0,0),(pad,pad), (pad,pad),(0,0)), mode = 'constant', constant_values = 0) | |
| return X_padded | |
| def conv_single_step(X_slice, W, b): | |
| conv = np.multiply(X_slice, W) | |
| Z = np.sum(conv) | |
| Z = np.add(Z, b) | |
| return Z | |
| def conv_forward(X, W, b, hparams): | |
| stride = hparams["stride"] | |
| pad = hparams["pad"] | |
| m, h_prev, w_prev, c_prev = X.shape | |
| f, f, c_prev, n_c = W.shape | |
| n_h = int((h_prev – f + 2*pad)/stride) + 1 | |
| n_w = int((w_prev – f + 2*pad)/stride) + 1 | |
| Z = np.zeros((m, n_h, n_w, n_c)) | |
| A_prev_pad = zero_pad(X, pad) | |
| for i in range(m): | |
| for h in range(n_h): | |
| for w in range(n_w): | |
| for c in range(n_c): | |
| w_start = w * stride | |
| w_end = w_start + f | |
| h_start = h * stride | |
| h_end = h_start + f | |
| Z[i,h,w,c] = conv_single_step(A_prev_pad[i, h_start:h_end, w_start:w_end, :], W[:,:,:,c], b[:,:,:,c]) | |
| return Z | |
| def max_pool(input, hparams): | |
| m, h_prev, w_prev, c_prev = input.shape | |
| f = hparams["f"] | |
| stride = hparams["stride"] | |
| h_out = int(((h_prev – f)/stride) + 1) | |
| w_out = int(((w_prev -f)/stride) + 1) | |
| output = np.zeros((m, h_out, w_out, c_prev)) | |
| for i in range(m): | |
| for c in range(c_prev): | |
| for h in range(h_out): | |
| for w in range(w_out): | |
| w_start = w * stride | |
| w_end = w_start + f | |
| h_start = h * stride | |
| h_end = h_start + f | |
| output[i, h, w, c] = np.max(input[i,h_start:h_end, w_start:w_end, c]) | |
| assert output.shape == (m, h_out, w_out, c_prev) | |
| return output | |
| img = mpimg.imread('./cake.JPG') | |
| print (img.shape) | |
| X = img.reshape(1,142,252,3) | |
| fig = plt.figure(figsize=(15,10)) | |
| ax1 = fig.add_subplot(2,2,1) | |
| print("Shape of Image: ", X.shape) | |
| ax1.imshow(X[0,:,:,:]) | |
| ax1.title.set_text('Original Image') | |
| ax2 = fig.add_subplot(2,2,2) | |
| X = zero_pad(X, 10) | |
| print("After padding: ", X.shape) | |
| ax2.imshow(X[0,:,:,:], cmap = "gray") | |
| ax2.title.set_text('After padding') | |
| ax3 = fig.add_subplot(2,2,3) | |
| W = np.array([[-1,-1,-1],[-1,8,-1],[-1,-1,-1]]).reshape((3,3,1,1)) | |
| b = np.zeros((1,1,1,1)) | |
| hparams = {"pad" : 0, "stride": 1} | |
| X = conv_forward(X, W, b, hparams) | |
| print("After convolution: ", X.shape) | |
| ax3.imshow(X[0,:,:,0], cmap='gray',vmin=0, vmax=1) | |
| ax3.title.set_text('After convolution') | |
| ax4 = fig.add_subplot(2,2,4) | |
| hparams = {"stride" : 1, "f" : 2} | |
| X = max_pool(X, hparams) | |
| print("After pooling :", X.shape) | |
| ax4.imshow(X[0,:,:,0], cmap = "gray") | |
| ax4.title.set_text('After pooling') | |
| plt.show() |
(142, 252, 3)
Shape of Image: (1, 142, 252, 3)
After padding: (1, 162, 272, 3)
After convolution: (1, 160, 270, 1)
After pooling : (1, 159, 269, 1)
ஒரு படத்தைக் கொடுத்து அதில் உள்ளது நாயா? பூனையா? என கணிக்கச் சொல்லுவது ‘object classification’ என்றால், ஒரு படத்தில் உள்ள ஒவ்வொரு பொருளும் என்னென்ன என கணிக்கச் சொல்லுவது ‘object identification’ ஆகும். இத்தகைய வேலைகளைச் செய்வதற்கென ஏற்கெனவே பயிற்சி பெற்ற AlexNet, ResNet, VGG19, InceptionResNet, GoogLeNet, DenseNet, NASNet போன்ற மாடல்கள் சந்தையில் உள்ளன. இவற்றில் ஏதாவதொன்றைத் தேர்ந்தெடுத்து நமது தரவுகளுக்கேற்ப பயிற்சி அளித்து பயன்படுத்திக் கொள்ளலாம்.
ImageNet என்பது வலைத்தளத்திலிருந்து எடுக்கப்பட்ட பல்வேறு படங்களைக் கொண்ட ஒரு database ஆகும். இது ஒவ்வொரு வருடமும் ILSVRC (ImageNet Large Scale Visual Recognition Challenge) என்ற நிகழ்வினை நடத்துகிறது. இந்தச் சவாலில் மேற்கூறிய மாடல்கள் அனைத்தும் பங்கு பெறுகின்றன. இவைகளின் துல்லியத் தன்மையை உறுதிபடுத்த இதுபோன்ற சவால்கள் ஒவ்வொரு வருடமும் நிகழ்த்தப்படுகின்றன. எனவே இத்தகைய மாடல்களில் ஏதாவதொன்றை எடுத்து நமக்கு வேண்டிய படத்தைக் கொடுத்து கணிக்கச் சொன்னால், அதன் கணிப்பு பொதுவாக சரியாகத்தான் இருக்கும்.
Computer Vision
நமது கணினிக்கு ஒரு படத்தைப் பார்த்து அதிலுள்ள விஷயங்கள் என்னென்ன என அடையாளப்படுத்தக் கற்றுக் கொடுப்பதே computer vision என்று அழைக்கப்படும். இத்தகைய object detection-க்கான வேலையைச் செய்வதே YOLO எனும் algorithm ஆகும். You Only Look Once என்பதே YOLO என்று அழைக்கப்படுகிறது. இது ஒரு படத்தை எடுத்துக்கொண்டு, அதை சிறு சிறு துண்டுகளாக grid-வடிவில் பிரிக்கிறது. பின்னர் ஒவ்வொரு grid-ன் மீதும் Image classification மற்றும் Localization என்பது நடைபெறுகிறது. பின்னர் ஒவ்வொரு object-க்குமான bounding boxes-ஐ கணித்து, அது ஒவ்வொரு class-க்குள்ளும் அமைவதற்கான நிகழ்தகவையும் கணிக்கிறது. ஒரே object பல இடங்களில் மீண்டும் மீண்டும் கணிக்கப்படுவதைத் தவிர்ப்பதற்கு bounding boxes-ஐ இன்னும் துல்லியமாக அமைக்க உதவுவதே Intersection Over Union மற்றும் Non-max supression போன்ற விஷயங்கள் ஆகும்.
Face Recognition என்பது தற்போது எங்கும் பரவலாகப் பயன்படுத்தப்பட்டு வருகின்ற ஒரு விஷயம் ஆகும். ஒவ்வொருவரின் கைப்பேசியிலும் கூட இதற்கான app உள்ளது. இந்த வேலையைச் செய்வதற்கு YOLO உதவுகிறது. இதனை face verification மற்றும் face recognition என இரண்டாகப் பிரித்துப் புரிந்து கொள்ளலாம். நமது கைபேசியில் உள்ளது போல ஒருவருடைய முகத்தைக் காண்பித்து அது இன்னாரது முகமா இல்லையா எனக் கூறுவது face verification ஆகும் (binary classification – one to one mapping).
Face recognition என்பது ஒருவருடைய முகத்தைக் கொடுத்து அதனை db-ல் உள்ள பல்வேறு முகங்களுடன் ஒப்பிட்டு எந்த முகத்துடன் பொருந்துகிறது எனக் கண்டுபிடிப்பது face recognition ஆகும். ConvNet என்பது இந்த வேலையைச் செய்தாலும், இது ஒவ்வொருவருடைய முகத்துக்குமான ஒரு மாதிரிப் படத்தை எடுத்துக்கொண்டு சேமிக்கிறது. இதுவே ‘One short learning’ என்று அழைக்கப்படும். இம்முறையில் சேமிக்கும்போது, ஏற்கெனவே சேமிக்கப்பட்டுள்ள நபரின் முகமே மற்றொரு முறை வந்தால் கூட அதில் சற்று மாறுபட்ட features காணப்படின் அதனை மற்றொரு நபராக சேமிக்கிறது. எனவே “இவர் தான் அவர் ” என சரியாக கணிக்கவும் தவறுகிறது. இதனைத் தவிர்ப்பதற்காக வந்ததே Siamese Network ஆகும்.
Siamese Network என்பது similarity function-ஐப் பயன்படுத்தி இத்தகைய வேலையைச் செய்கிறது. இது உள்ளீடாக வருகின்ற படத்திற்கும் db-ல் சேமிக்கப்பட்டுள்ள படத்திற்குமான வேறுபாட்டை முதலில் கணிக்கிறது. பின்னர் இந்த வேறுபாடு எந்த அளவு வரை அமையலாம் என்பதற்கான threshold-ஐ அமைக்கிறது. இது வெளிப்படுத்துகின்ற வேறுபாடு threshold-க்கும் குறைவாக இருப்பின் “முகம் பொருந்துகிறது” எனவும், அதிகமாக இருப்பின் “முகம் பொருந்தவில்லை” எனவும் கணிக்கிறது. இத்தகைய முறையில் ஒருவருடைய முகம் கணிக்கப்படும்போது ஏற்படுகின்ற இழப்பைக் கண்டறிய உதவுவதே triplet loss function ஆகும். Anchor img என்பது கொடுக்கப்பட்டுள்ள படம் ஆகும். positive ,negative images என்பது கொடுக்கப்பட்டுள்ள படத்துடன் பொருந்துகின்ற மற்றும் பொருந்தாத படங்கள் ஆகும். இது anchor image, positive image, negative image என்று 3 படத்தை ஒப்பிட்டு இழப்பைக் கணக்கிடுகிறது. எனவேதான் triplet loss என்ற பெயரில் அழைக்கப்படுகிறது.