सियामी नेटवर्क का उपयोग करते हुए चेहरा पहचानना

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

मान लीजिए हमें लगभग 500 लोगों को रोजगार देने वाले संगठन के लिए एक चेहरा पहचान मॉडल बनाने की आवश्यकता है। यदि हम कन्वेन्शनल न्यूरल नेटवर्क (CNN) पर आधारित स्क्रैच से ऐसा मॉडल बनाते हैं, तो मॉडल को प्रशिक्षित करने और अच्छी पहचान सटीकता प्राप्त करने के लिए, हमें इन 500 लोगों में से प्रत्येक की कई छवियों की आवश्यकता होगी। लेकिन यह स्पष्ट है कि हम इस तरह के डेटासेट को एकत्र नहीं कर सकते हैं, इसलिए यदि आपके पास पर्याप्त डेटा नहीं है तो आपको सीएनएन या किसी अन्य गहन शिक्षण एल्गोरिथ्म पर आधारित मॉडल नहीं बनाना चाहिए। ऐसे मामलों में, आप स्याम देश के नेटवर्क की तरह जटिल एक बार सीखने के एल्गोरिथ्म का उपयोग कर सकते हैं, जिसे कम डेटा पर प्रशिक्षित किया जा सकता है।

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

डाउनलोड करें, अनपैक करें और s1 से s40 तक के फोल्डर देखें:



प्रत्येक फ़ोल्डर में अलग-अलग कोणों से लिए गए एकल व्यक्ति की 10 अलग-अलग तस्वीरें होती हैं। यहाँ s1 फ़ोल्डर की सामग्री है:



और यहाँ s13 फ़ोल्डर में क्या है:



Siamese नेटवर्क को चिह्नों के साथ युग्मित मानों को इनपुट करने की आवश्यकता होती है, तो आइए ऐसे सेट बनाएं। एक ही फ़ोल्डर से दो यादृच्छिक तस्वीरें लें और उन्हें "वास्तविक" जोड़ी के रूप में चिह्नित करें। फिर हम विभिन्न फ़ोल्डरों से दो तस्वीरें लेते हैं और उन्हें "झूठी" जोड़ी के रूप में चिह्नित करते हैं:



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

अब इन सभी चरणों पर अधिक विस्तार से विचार करें।

सबसे पहले, आवश्यक पुस्तकालयों को आयात करें:

import re import numpy as np from PIL import Image from sklearn.model_selection import train_test_split from keras import backend as K from keras.layers import Activation from keras.layers import Input, Lambda, Dense, Dropout, Convolution2D, MaxPooling2D, Flatten from keras.models import Sequential, Model from keras.optimizers import RMSprop 

अब हम इनपुट छवियों को पढ़ने के लिए एक फ़ंक्शन को परिभाषित करते हैं। read_image फ़ंक्शन एक तस्वीर लेता है और एक NumPy सरणी देता है:

 def read_image(filename, byteorder='>'): #first we read the image, as a raw file to the buffer with open(filename, 'rb') as f: buffer = f.read() #using regex, we extract the header, width, height and maxval of the image header, width, height, maxval = re.search( b"(^P5\s(?:\s*#.*[\r\n])*" b"(\d+)\s(?:\s*#.*[\r\n])*" b"(\d+)\s(?:\s*#.*[\r\n])*" b"(\d+)\s(?:\s*#.*[\r\n]\s)*)", buffer).groups() #then we convert the image to numpy array using np.frombuffer which interprets buffer as one dimensional array return np.frombuffer(buffer, dtype='u1' if int(maxval) 

उदाहरण के लिए, इस फ़ोटो को खोलें:

 Image.open("data/orl_faces/s1/1.pgm") 

हम इसे read_image फ़ंक्शन में read_image करते हैं और एक NumPy सरणी प्राप्त करते हैं:

 img = read_image('data/orl_faces/s1/1.pgm') img.shape (112, 92) 

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

सबसे पहले, एक डायरेक्टरी से छवियों ( img1 , img2 ) को पढ़ें, उन्हें x_genuine_pair, array में सेव करें x_genuine_pair, y_genuine को 1 सेट करें। फिर हम अलग-अलग निर्देशिकाओं से छवियां ( img1 , img2 ) img2 , उन्हें x_imposite, जोड़ी में सहेजते हैं x_imposite, और y_imposite को 0 सेट y_imposite ।

X में x_imposite x_genuine_pair और x_imposite , और y_genuine और y_imposite में Y :

 size = 2 total_sample_size = 10000 def get_data(size, total_sample_size): #read the image image = read_image('data/orl_faces/s' + str(1) + '/' + str(1) + '.pgm', 'rw+') #reduce the size image = image[::size, ::size] #get the new size dim1 = image.shape[0] dim2 = image.shape[1] count = 0 #initialize the numpy array with the shape of [total_sample, no_of_pairs, dim1, dim2] x_geuine_pair = np.zeros([total_sample_size, 2, 1, dim1, dim2]) # 2 is for pairs y_genuine = np.zeros([total_sample_size, 1]) for i in range(40): for j in range(int(total_sample_size/40)): ind1 = 0 ind2 = 0 #read images from same directory (genuine pair) while ind1 == ind2: ind1 = np.random.randint(10) ind2 = np.random.randint(10) # read the two images img1 = read_image('data/orl_faces/s' + str(i+1) + '/' + str(ind1 + 1) + '.pgm', 'rw+') img2 = read_image('data/orl_faces/s' + str(i+1) + '/' + str(ind2 + 1) + '.pgm', 'rw+') #reduce the size img1 = img1[::size, ::size] img2 = img2[::size, ::size] #store the images to the initialized numpy array x_geuine_pair[count, 0, 0, :, :] = img1 x_geuine_pair[count, 1, 0, :, :] = img2 #as we are drawing images from the same directory we assign label as 1. (genuine pair) y_genuine[count] = 1 count += 1 count = 0 x_imposite_pair = np.zeros([total_sample_size, 2, 1, dim1, dim2]) y_imposite = np.zeros([total_sample_size, 1]) for i in range(int(total_sample_size/10)): for j in range(10): #read images from different directory (imposite pair) while True: ind1 = np.random.randint(40) ind2 = np.random.randint(40) if ind1 != ind2: break img1 = read_image('data/orl_faces/s' + str(ind1+1) + '/' + str(j + 1) + '.pgm', 'rw+') img2 = read_image('data/orl_faces/s' + str(ind2+1) + '/' + str(j + 1) + '.pgm', 'rw+') img1 = img1[::size, ::size] img2 = img2[::size, ::size] x_imposite_pair[count, 0, 0, :, :] = img1 x_imposite_pair[count, 1, 0, :, :] = img2 #as we are drawing images from the different directory we assign label as 0. (imposite pair) y_imposite[count] = 0 count += 1 #now, concatenate, genuine pairs and imposite pair to get the whole data X = np.concatenate([x_geuine_pair, x_imposite_pair], axis=0)/255 Y = np.concatenate([y_genuine, y_imposite], axis=0) return X, Y 

अब हम डेटा उत्पन्न करेंगे और उनके आकार की जाँच करेंगे। हमारे पास 20,000 तस्वीरें हैं, जिनमें से 10,000 वास्तविक और 10,000 झूठी जोड़े एकत्र की गईं:

 X, Y = get_data(size, total_sample_size) X.shape (20000, 2, 1, 56, 46) Y.shape (20000, 1) 

हम पूरी जानकारी साझा करेंगे: 75% जोड़े प्रशिक्षण में जाएंगे, और 25% परीक्षण के लिए:
x_train, x_test, y_train, y_test = train_test_split(X, Y, test_size=.25)

अब एक Siamese नेटवर्क बनाएं। पहले हम कोर नेटवर्क को परिभाषित करते हैं - यह गुण निकालने के लिए एक जटिल तंत्रिका नेटवर्क होगा। एक फ्लैट परत के बाद अधिकतम पूलिंग के साथ ReLU सक्रियण और एक परत का उपयोग करके दो संकेंद्रित परतें बनाएं:

 def build_base_network(input_shape): seq = Sequential() nb_filter = [6, 12] kernel_size = 3 #convolutional layer 1 seq.add(Convolution2D(nb_filter[0], kernel_size, kernel_size, input_shape=input_shape, border_mode='valid', dim_ordering='th')) seq.add(Activation('relu')) seq.add(MaxPooling2D(pool_size=(2, 2))) seq.add(Dropout(.25)) #convolutional layer 2 seq.add(Convolution2D(nb_filter[1], kernel_size, kernel_size, border_mode='valid', dim_ordering='th')) seq.add(Activation('relu')) seq.add(MaxPooling2D(pool_size=(2, 2), dim_ordering='th')) seq.add(Dropout(.25)) #flatten seq.add(Flatten()) seq.add(Dense(128, activation='relu')) seq.add(Dropout(0.1)) seq.add(Dense(50, activation='relu')) return seq 

फिर हम कोर नेटवर्क की छवियों की एक जोड़ी को हस्तांतरित करेंगे, जो वेक्टर निरूपण, अर्थात संपत्ति वैक्टर को वापस कर देंगे:

 input_dim = x_train.shape[2:] img_a = Input(shape=input_dim) img_b = Input(shape=input_dim) base_network = build_base_network(input_dim) feat_vecs_a = base_network(img_a) feat_vecs_b = base_network(img_b) 

feat_vecs_a और feat_vecs_b छवियों की एक जोड़ी के संपत्ति वैक्टर हैं। आइए उनके बीच की दूरी की गणना करने के लिए उनके ऊर्जा कार्यों को पास करें। और ऊर्जा के कार्य के रूप में, हम यूक्लिडियन दूरी का उपयोग करते हैं:

 def euclidean_distance(vects): x, y = vects return K.sqrt(K.sum(K.square(x - y), axis=1, keepdims=True)) def eucl_dist_output_shape(shapes): shape1, shape2 = shapes return (shape1[0], 1) distance = Lambda(euclidean_distance, output_shape=eucl_dist_output_shape)([feat_vecs_a, feat_vecs_b]) 

हम युगों की संख्या को 13 पर सेट करते हैं, अनुकूलन के लिए RMS संपत्ति लागू करते हैं और मॉडल घोषित करते हैं:

 epochs = 13 rms = RMSprop() model = Model(input=[input_a, input_b], output=distance) 

अब हम लॉस फंक्शन contrastive_loss फंक्शन को परिभाषित करते हैं और मॉडल को संकलित करते हैं:

 def contrastive_loss(y_true, y_pred): margin = 1 return K.mean(y_true * K.square(y_pred) + (1 - y_true) * K.square(K.maximum(margin - y_pred, 0))) model.compile(loss=contrastive_loss, optimizer=rms) 

आइए मॉडल का अध्ययन करें:

 img_1 = x_train[:, 0] img_2 = x_train[:, 1] model.fit([img_1, img_2], y_train, validation_split=.25, batch_size=128, verbose=2, nb_epoch=epochs) 

आप देखते हैं कि एरस पास के रूप में नुकसान कैसे कम होता है:

 Train on 11250 samples, validate on 3750 samples Epoch 1/13 - 60s - loss: 0.2179 - val_loss: 0.2156 Epoch 2/13 - 53s - loss: 0.1520 - val_loss: 0.2102 Epoch 3/13 - 53s - loss: 0.1190 - val_loss: 0.1545 Epoch 4/13 - 55s - loss: 0.0959 - val_loss: 0.1705 Epoch 5/13 - 52s - loss: 0.0801 - val_loss: 0.1181 Epoch 6/13 - 52s - loss: 0.0684 - val_loss: 0.0821 Epoch 7/13 - 52s - loss: 0.0591 - val_loss: 0.0762 Epoch 8/13 - 52s - loss: 0.0526 - val_loss: 0.0655 Epoch 9/13 - 52s - loss: 0.0475 - val_loss: 0.0662 Epoch 10/13 - 52s - loss: 0.0444 - val_loss: 0.0469 Epoch 11/13 - 52s - loss: 0.0408 - val_loss: 0.0478 Epoch 12/13 - 52s - loss: 0.0381 - val_loss: 0.0498 Epoch 13/13 - 54s - loss: 0.0356 - val_loss: 0.0363 

और अब परीक्षण डेटा पर मॉडल का परीक्षण करते हैं:

 pred = model.predict([x_test[:, 0], x_test[:, 1]]) 

सटीकता की गणना करने के लिए एक फ़ंक्शन को परिभाषित करें:

 def compute_accuracy(predictions, labels): return labels[predictions.ravel() 

हम सटीकता की गणना करते हैं:

 compute_accuracy(pred, y_test) 0.9779092702169625 

निष्कर्ष

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

मेरी टिप्पणी

छवियों के साथ काम करते समय वर्तमान में Siamese नेटवर्क का ज्ञान आवश्यक है। छोटे नमूनों, नई डेटा पीढ़ी, वृद्धि विधियों में प्रशिक्षण नेटवर्क के कई दृष्टिकोण हैं। यह विधि अपेक्षाकृत अच्छे परिणाम प्राप्त करने के लिए "सस्ते" की अनुमति देती है, यहाँ तंत्रिका नेटवर्क के लिए "हैलो वर्ल्ड" पर सियामी नेटवर्क का एक और उत्कृष्ट उदाहरण है - डाटासेट MNIST keras.io/examples/mnist_siamese