सौंदर्य को देखने के लिए फोन कैसे सिखाएं

हाल ही में, मैंने गणित और लोगों की सुंदरता के बारे में एक पुस्तक पढ़ी और सोचा कि एक दशक पहले क्या विचार था कि मानव सुंदरता क्या थी, इसे कैसे समझा जाए। तर्क जिसके बारे में गणित के दृष्टिकोण से सुंदर माना जाता है, इस तथ्य के लिए नीचे आया कि यह सममित होना चाहिए। इसके अलावा, पुनर्जागरण के बाद से, चेहरे पर कुछ बिंदुओं पर दूरी के बीच संबंधों का उपयोग करके सुंदर चेहरे का वर्णन करने का प्रयास किया गया है, उदाहरण के लिए, उस सुंदर चेहरे के सुनहरे अनुपात के करीब किसी तरह का संबंध है। अंक के स्थान के बारे में इसी तरह के विचारों को अब चेहरे की पहचान करने के तरीकों में से एक के रूप में उपयोग किया जाता है (चेहरे के स्थान की खोज)। हालांकि, अनुभव से पता चलता है कि यदि आप चेहरे पर विशिष्ट बिंदुओं की स्थिति के लिए सुविधाओं के सेट को सीमित नहीं करते हैं, तो आप कई कार्यों में बेहतर परिणाम प्राप्त कर सकते हैं, जिसमें उम्र, लिंग या यहां तक ​​कि यौन अभिविन्यास निर्धारित करना शामिल है । यहां यह पहले से ही स्पष्ट है कि इस तरह के अध्ययन के परिणामों को प्रकाशित करने की नैतिकता का मुद्दा एक तीव्र हो सकता है।

लोगों की सुंदरता और उसके मूल्यांकन का विषय भी नैतिक रूप से विवादास्पद हो सकता है। एप्लिकेशन विकसित करते समय, मेरे कई दोस्तों ने परीक्षणों के लिए अपनी तस्वीरों का उपयोग करने से इनकार कर दिया, या बस परिणाम जानना नहीं चाहते थे (यह हास्यास्पद है कि ज्यादातर लड़कियों ने परिणाम जानने से इनकार कर दिया)। साथ ही, सौंदर्य मूल्यांकन को स्वचालित करने का लक्ष्य दिलचस्प दार्शनिक प्रश्न उठा सकता है। संस्कृति द्वारा निर्धारित सौंदर्य की अवधारणा किस सीमा तक है? कितना सच है “देखने वाले की आँखों में सुंदरता”? क्या सौंदर्य के उद्देश्य संकेतों को उजागर करना संभव है?

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

भाग 0. पाइपलाइन

यह समझने के लिए कि अगले चरण एक-दूसरे से कैसे संबंधित हैं, मैंने परियोजना का एक चित्र बनाया:



नीला - महत्वपूर्ण पुस्तकालय और बाहरी डेटा। पीला - आवेदन में नियंत्रण।

भाग 1. अजगर

चूँकि सौंदर्य का मूल्यांकन एक नाज़ुक विषय है, इसलिए सार्वजनिक डोमेन में बहुत सारे डेटासेट नहीं होते हैं, जिनमें मूल्यांकन के साथ फ़ोटो होते हैं (मुझे यकीन है कि ऑनलाइन डेटिंग सेवाओं जैसे टिंडर में आंकड़ों का बहुत बड़ा समूह है)। मुझे चीन के विश्वविद्यालयों में से एक में संकलित एक डेटाबेस मिला, जिसमें 5500 तस्वीरें थीं, प्रत्येक का मूल्यांकन 7 मूल्यांकनकर्ताओं ने चीनी छात्रों के बीच किया। 5,500 तस्वीरों में से, 2,000 एशियाई पुरुष (एएम), 2000 एशियाई महिला (एएफ), और 750 यूरोपियोइड पुरुष (सीएम) और महिला (सीएफ) हैं।



आइए पायथन पांडा मॉड्यूल का उपयोग करते हुए डेटा पढ़ें और डेटा पर एक त्वरित नज़र डालें। विभिन्न लिंग और दौड़ के लिए अनुमानित वितरण:

import pandas as pd import matplotlib.pyplot as plt ratingDS=pd.read_excel('../input/faces-scut/scut-fbp5500_v2/SCUT-FBP5500_v2/All_Ratings.xlsx') Answer=ratingDS.groupby('Filename').mean()['Rating'] ratingDS['race']=ratingDS['Filename'].apply(lambda x:x[:2]) fig, ax = plt.subplots(2, 2, sharex='col') for i, race in enumerate(['CF','CM','AF','AM']): sbp=ax[i%2,i//2] ratingDS[ratingDS['race']==race].groupby('Filename')['Rating'].mean().hist(alpha=0.5, bins=20,label=race,grid=False,rwidth=0.9,ax=sbp) sbp.set_title(race) 

यह देखा जा सकता है कि, सामान्य तौर पर, पुरुषों को महिलाओं की तुलना में कम सुंदर माना जाता है, वितरण बिमोडल है - वहाँ हैं। जिन्हें सुंदर और "औसत" माना जाता है। लगभग कोई कम रेटिंग नहीं है, इसलिए डेटा को फिर से असामान्य किया जा सकता है। लेकिन हम उन्हें अभी के लिए छोड़ दें।

आइए अनुमानों में मानक विचलन देखें:

 ratingDS.groupby('Filename')['Rating'].std().mean() 

यह 0.64 है, जिसका अर्थ है कि विभिन्न मूल्यांकनकर्ताओं के आकलन में अंतर 5 में से 1 अंक से कम है, जो सौंदर्य के आकलन में एकमतता को इंगित करता है। यह यथोचित कहा जा सकता है कि "सुंदरता देखने वाले की नजर में नहीं है।" औसत होने पर, आप मॉडल को प्रशिक्षित करने के लिए डेटा का उपयोग मज़बूती से कर सकते हैं और प्रोग्रामेटिक मूल्यांकन की मौलिक असंभवता के बारे में चिंता नहीं कर सकते हैं।

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

 R2=ratingDS.join(ratingDS.groupby('Filename')['Rating'].median(), on='Filename', how='inner',rsuffix =' median') R2['ratingdiff']=(R2['Rating median']-R2['Rating']).astype(int) print(set(R2['ratingdiff'])) R2['ratingdiff'].hist(label='difference of raings',bins=[-3.5,-2.5,-1.5,-0.5,0.5,1.5,2.5,3.5,4.5],grid=False,rwidth=0.5) 

एक दिलचस्प पैटर्न पाया जाता है। जिन लोगों का स्कोर औसत से 1 अंक अधिक है

 len(R2[R2['ratingdiff'].abs()>1])/len(R2) 

.029433333333333332
3% से कम है। यही है, सौंदर्य का आकलन करने के मामलों में हड़ताली एकमत फिर से पुष्टि की जाती है।
आवश्यक औसत रेटिंग के साथ एक तालिका बनाएं

 Answer=ratingDS.groupby('Filename').mean()['Rating'] 

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

1. छवि और उसके स्केलिंग पर एक चेहरा पहचान है।

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

3. डेटाबेस में संग्रहीत लोगों के साथ फ़ीचर वेक्टर की तुलना।

हमारे कार्य के लिए, मैंने 1-2 बिंदुओं के तैयार समाधानों का उपयोग किया। चेहरे का पता लगाने का कार्य आमतौर पर कई तरीकों से हल किया जाता है, इसके अलावा, लगभग किसी भी मोबाइल डिवाइस में फेस डिटेक्टर होते हैं (एंड्रॉइड पर वे मानक GooglePlay सेवाओं के पैकेज का हिस्सा हैं), जिनका उपयोग फ़ोटोग्राफ़ करते समय चेहरों पर ध्यान केंद्रित करने के लिए किया जाता है। सदिश रूप में व्यक्तियों के अनुवाद के लिए, एक गैर-स्पष्ट सूक्ष्म बिंदु है। तथ्य यह है कि संकेत। मान्यता समस्या को हल करने के लिए निकाली गई - एक व्यक्ति की विशेषता है, लेकिन वे सुंदरता के साथ बिल्कुल भी संबंध नहीं रख सकते हैं। अधिक। कन्वेन्शनल न्यूरल नेटवर्क की ख़ासियतों के कारण, ये संकेत मुख्य रूप से स्थानीय हैं, और सामान्य तौर पर यह कई समस्याओं (एकल पिक्सेल हमले) का कारण बन सकता है। फिर भी, मैंने पाया कि परिणाम वेक्टर के आयाम पर अत्यधिक निर्भर हैं, और अगर सौंदर्य को निर्धारित करने के लिए 128 संकेत पर्याप्त नहीं हैं, तो 512 पर्याप्त है। इसके आधार पर, एक पूर्व-प्रशिक्षित रीसेट-आधारित अंतर्दृष्टि नेटवर्क चुना गया था। हम मशीन सीखने के लिए एक रूपरेखा के रूप में केर का उपयोग भी करेंगे।
पूर्व-प्रशिक्षित मॉडल डाउनलोड करने के लिए एक विस्तृत कोड यहां पाया जा सकता है।

 model=LResNet100E_IR() 

Mtcnn फेस डिटेक्टर प्रीप्रोसेसिंग के लिए फेस डिटेक्टर के रूप में इस्तेमाल किया गया था ।

 detector = MtcnnDetector(model_folder=mtcnn_path, ctx=ctx, num_worker=1, accurate_landmark = True, threshold=det_threshold) 

डेटासेट से संरेखित करें, क्रॉप करें और चित्र बनाएं:

 imgpath='../input/faces-scut/scut-fbp5500_v2/SCUT-FBP5500_v2/Images/' #    facevecs=[] for name in tqdm.tqdm(Answer.index): #   img1 = cv2.imread(imgpath+name) # ,     pre1 = np.moveaxis(get_input(detector,img1),0,-1) #  vec = model.predict(np.stack([pre1])) #   facevecs.append(vec) 

हम डेटा को प्रशिक्षण में तोड़कर तैयार करेंगे (उनमें से 90%, हम उन पर अध्ययन करेंगे) और सत्यापन (हम उन पर मॉडल के काम की जांच करेंगे) वैक्टर। हम डेटा को 0-1 की सीमा तक सामान्य करते हैं।

 X=np.stack(facevecs)[:,0,:] Y=(Answer[:])/5 Indicies=np.arange(len(Answer)) X,Y,Indicies=sklearn.utils.shuffle(X,Y,Indicies) Xtrain=X[:int(len(facevecs)*0.9)] Ytrain=Y[:int(len(facevecs)*0.9)] Indtrain=Indicies[:int(len(facevecs)*0.9)] Xval=X[int(len(facevecs)*0.9):] Yval=Y[int(len(facevecs)*0.9):] Indval=Indicies[int(len(facevecs)*0.9):] 

अब चलो मॉडल पर चलते हैं। सुंदरता का वर्णन।

 def Createheadmodel(): inp=keras.layers.Input((512,)) x=keras.layers.Dense(32,activation='elu')(inp) x=keras.layers.Dropout(0.1)(x) out=keras.layers.Dense(1,activation='hard_sigmoid',use_bias=False,kernel_initializer=keras.initializers.Ones())(x) model=keras.models.Model(input=inp,output=out) model.layers[-1].trainable=False model.compile(optimizer=keras.optimizers.Adam(lr=0.0001), loss='mse') return model modelhead=Createheadmodel() 

यह मॉडल 32-न्यूरॉन्स और 512 इनपुट नोड्स के साथ एक एकल-परत पूरी तरह से जुड़ा हुआ तंत्रिका नेटवर्क है - सबसे सरल आर्किटेक्चर में से एक, जो, फिर भी, अच्छी तरह से प्रशिक्षित है:

 hist=modelhead.fit(Xtrain,Ytrain, epochs=4000, batch_size=5000, validation_data=(Xval,Yval) ) 

4950/4950 [===============================] - 0s 3us / चरण - हानि: 0.0069 - val_loss: 0.0071
आइए सीखने के घटता का निर्माण करें

 plt.plot(hist.history['loss'][100:], label='loss') plt.plot(hist.history['val_loss'][100:],label='validation_loss') plt.legend(bbox_to_anchor=(0.95, 0.95), loc='upper right', borderaxespad=0.) 

हम देखते हैं कि हानि (मतलब वर्ग विचलन) सत्यापन डेटा पर 0.0071 है, इसलिए मानक विचलन = 0.084 या 0.42 अंक पांच-बिंदु पैमाने पर है, जो लोगों द्वारा दिए गए अनुमानों में प्रसार (0.6 अंक) से कम है। हमारा मॉडल काम कर रहा है।

यह कल्पना करने के लिए कि मॉडल कैसे काम करता है, आप बिखरने आरेख का उपयोग कर सकते हैं - सत्यापन डेटा से प्रत्येक तस्वीर के लिए, हम एक बिंदु का निर्माण करते हैं, जहां निर्देशांक में से एक औसत चेहरे की रेटिंग से मेल खाता है और दूसरे से औसत अनुमानित रेटिंग:

 Answer2=Answer.to_frame()[:5500] Answer2['ans']=0 Answer2['race']=Answer2.index Answer2['race']=Answer2['race'].apply(lambda x: x[:2]) Answer2['ans']=modelhead.predict(np.stack(facevecs)[:,0,:])*5 xy=np.array(Answer2.iloc[Indval][['ans','Rating']]) plt.scatter(xy[:,1],xy[:,0]) 

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

 import matplotlib.image as mpimg f, axarr = plt.subplots(4,5,figsize=(10, 10)) for i, race in enumerate(['AF','CF', "AM", 'CM']): for rating in range(1,6): #axarr[i,rating-1].axis('off') axarr[i,rating-1].tick_params(# changes apply to the x-axis which='both', # both major and minor ticks are affected bottom=False, # ticks along the bottom edge are off top=False, # ticks along the top edge are off right=False, left=False, labelbottom=False, labelleft=False ) picname=(Answer2[Answer2['race']==race]['ans']-rating).abs().argmin() axarr[i,rating-1].set_xlabel(Answer2.loc[picname]['ans']) axarr[i,rating-1].imshow(mpimg.imread(imgpath+picname)) 

हम देखते हैं कि सुंदरता द्वारा छँटाई के साथ परिणाम उचित लगता है।

अब हम एक पूर्ण मॉडल बनाएंगे जिसमें हम इनपुट के लिए एक चेहरा प्रस्तुत करते हैं, आउटपुट पर हमें 0 से 1 तक की रेटिंग मिलती है और इसे फोन के लिए उपयुक्त टैफलाइट प्रारूप में बदल देते हैं।

 import tensorflow as tf finmodel=Model(input=model.input, output=modelhead(model.output)) finmodel.save('finmodel.h5') converter = tf.lite.TFLiteConverter.from_keras_model_file('finmodel.h5') converter.optimizations = [tf.lite.Optimize.OPTIMIZE_FOR_SIZE] tflite_quant_model = converter.convert() open ("modelquant.tflite" , "wb").write(tflite_quant_model) from IPython.display import FileLink FileLink(r'modelquant.tflite') 

इस मॉडल को आकार में 112 * 112 * 3 के चेहरे की छवि प्राप्त होती है, और आउटपुट पर यह 0 से 1 तक एक ही नंबर देता है, जिसका अर्थ है चेहरे की सुंदरता (हालांकि यह याद रखना चाहिए कि डेटासेट में रेटिंग 0 से 5 तक नहीं, बल्कि 1 से 5 तक भिन्न होती है)।

भाग 2. जावा

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



विकास के दृष्टिकोण से, इसमें निम्नलिखित कार्य महत्वपूर्ण हैं।

1. फ़ाइल मॉडल से न्यूरल नेटवर्क को लोड करने का कार्य। इंटरप्रेटर ऑब्जेक्ट में एसेट फ़ोल्डर में फाइल

 import org.tensorflow.lite.Interpreter; Interpreter interpreter; try { interpreter=new Interpreter(loadModelFile(MainActivity.this)); Log.e("TIME", "Interpreter_started "); } catch (IOException e) { e.printStackTrace(); Log.e("TIME", "Interpreter NOT started "); } private MappedByteBuffer loadModelFile(Activity activity) throws IOException { AssetFileDescriptor fileDescriptor = activity.getAssets().openFd("model.tflite"); FileInputStream inputStream = new FileInputStream(fileDescriptor.getFileDescriptor()); FileChannel fileChannel = inputStream.getChannel(); long startOffset = fileDescriptor.getStartOffset(); long declaredLength = fileDescriptor.getDeclaredLength(); return fileChannel.map(FileChannel.MapMode.READ_ONLY, startOffset, declaredLength); } 

2. फेसटैक्टर मॉड्यूल का उपयोग करके चेहरे का पता लगाना, जो कि गूगल से मानक पुस्तकालय पैकेज का हिस्सा है, एक तंत्रिका नेटवर्क का उपयोग करके और परिणाम प्रदर्शित करता है।

 import com.google.android.gms.vision.face.Face; import com.google.android.gms.vision.face.FaceDetector; private void detectFace(){ //Create a Paint object for drawing with Paint myRectPaint = new Paint(); myRectPaint.setStrokeWidth(5); myRectPaint.setColor(Color.GREEN); myRectPaint.setStyle(Paint.Style.STROKE); Paint fontPaint = new Paint(); fontPaint.setStrokeWidth(3); fontPaint.setTextSize(70); fontPaint.setColor(Color.BLUE); fontPaint.setStyle(Paint.Style.FILL_AND_STROKE); //Create a Canvas object for drawing on tempBitmap = Bitmap.createBitmap(myBitmap.getWidth(), myBitmap.getHeight(), Bitmap.Config.RGB_565); Canvas tempCanvas = new Canvas(tempBitmap); tempCanvas.drawBitmap(myBitmap, 0, 0, null); //Detect the Faces FaceDetector faceDetector = new FaceDetector.Builder(getApplicationContext()).build(); Frame frame = new Frame.Builder().setBitmap(myBitmap).build(); SparseArray<Face> faces = faceDetector.detect(frame); Face face; float[][] labelProbArray = new float[1][1]; imgData.order(ByteOrder.nativeOrder()); //Draw Rectangles on the Faces if (faces.size()>0){ for (int i = 0; i < faces.size(); i++) { face = faces.valueAt(i); isFaceFound=true; float x1 = Math.max(face.getPosition().x,0); float y1 = Math.max(face.getPosition().y,0); float x2 = Math.min(x1 + face.getWidth(),frame.getBitmap().getWidth()); float y2 = Math.min(y1 + face.getHeight(),frame.getBitmap().getHeight()); Bitmap tempbitmap2 = Bitmap.createBitmap(tempBitmap, (int)x1, (int)y1, (int) (x2-x1), (int) (y2-y1)); tempbitmap2 = Bitmap.createScaledBitmap(tempbitmap2, 112, 112, true); convertBitmapToByteBuffer(tempbitmap2); interpreter.run(imgData, labelProbArray); String textToShow = String.format("%.1f", (Answer[0][0]*5-1)/4 * 10); textToShow = textToShow + "/10"; int width= tempCanvas.getWidth(); //int height=tempCanvas.getHeight(); int fontsize=Math.max(width/20,imgView.getWidth()/20); fontPaint.setTextSize(fontsize); tempCanvas.drawText(textToShow, x1, y1-10, fontPaint); tempCanvas.drawRoundRect(new RectF(x1, y1, x2, y2), 2, 2, myRectPaint) } imgView.setImageDrawable(new BitmapDrawable(getResources(),tempBitmap)); } } 

यदि आप अपने फोन पर ग्रेडिंग के साथ खेलना चाहते हैं, तो आप GooglePlay बाजार से एप्लिकेशन डाउनलोड कर सकते हैं।