शुरुआती के लिए तंत्रिका नेटवर्क चाल

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

इस कार्य में, हमलावर को सर्वर तक पहुंच प्राप्त करनी थी। सफल होने के बाद, उन्होंने अपनी गृह निर्देशिका में निम्न फ़ाइल संरचना देखी:

| Home --| KerasModel.h5 --| Task.txt --| ZeroSource.bmp 

निम्नलिखित जानकारी टास्क फ़ाइल में थी:

 Now it is time for a final boss! http://51.15.100.188:36491/predict You have a mode and an image. To get a ticket, you need to change an image so that it is identified as "1". curl -X POST -F image=@ZeroSource.bmp 'http://51.15.100.188:36491/predict'. (don't forget about normalization (/255) ^_^) 

प्रतिष्ठित टिकट पाने के लिए, हमलावर को ZeroSource.bmp को बदलने के लिए कहा गया था:

ताकि सर्वर पर भेजने के बाद तंत्रिका नेटवर्क इस छवि की व्याख्या करता है 1. यदि आप इस छवि को प्रसंस्करण के बिना भेजने की कोशिश करते हैं, तो तंत्रिका नेटवर्क का परिणाम 0 होगा।

और, ज़ाहिर है, इस कार्य के लिए मुख्य संकेत मॉडल फ़ाइल KerasModel.h5 है (यह फ़ाइल हमलावर को व्हाइटबॉक्स विमान पर हमले को स्थानांतरित करने में मदद करती है, क्योंकि तंत्रिका नेटवर्क और इसके साथ जुड़े सभी डेटा उसके लिए सुलभ हैं)। फ़ाइल नाम में तुरंत एक संकेत होता है - उस फ्रेमवर्क का नाम जिस पर तंत्रिका नेटवर्क लागू किया जाता है।

यह इन परिचयात्मक नोटों के साथ था जो प्रतिभागी ने कार्य को हल करने के बारे में निर्धारित किया था:

• कराल में लिखा गया तंत्रिका नेटवर्क मॉडल।
• कर्ल का उपयोग करके सर्वर पर एक छवि भेजने की क्षमता।
• मूल छवि जिसे बदलने की आवश्यकता थी।

सर्वर साइड पर, चेक यथासंभव सरल था:

1. छवि का सही आकार होना चाहिए - 28x28 पिक्सेल।
2. इस छवि में, मॉडल को 1 लौटना चाहिए।
3. ZeroSource.bmp की प्रारंभिक छवि और सर्वर पर भेजे जाने वाले के बीच का अंतर MSE मीट्रिक (मानक त्रुटि) द्वारा थ्रेसहोल्ड k से कम होना चाहिए।

तो चलिए शुरू करते हैं।

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

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

 import keras import numpy as np from PIL import Image import foolbox 

हम यहाँ क्या देखते हैं?

1. केरस वह ढांचा है जिस पर न्यूरल नेटवर्क लिखा है, जिसे हम धोखा देंगे।
2. NumPy एक पुस्तकालय है जो हमें वैक्टर के साथ कुशलता से काम करने की अनुमति देगा।
3. PIL छवियों के साथ काम करने के लिए एक उपकरण है।
4. FoolBox प्रतिकूल उदाहरण उत्पन्न करने के लिए एक पुस्तकालय है।

सबसे पहले, निश्चित रूप से, हमारे कार्यक्रम की स्मृति में तंत्रिका नेटवर्क मॉडल को लोड करना और मॉडल जानकारी देखना है।

 model = keras.models.load_model("KerasModel.h5") #   model.summary() #     model.input #    ,        

आउटपुट पर, हमें निम्नलिखित मिलते हैं:

 Layer (type) Output Shape Param # ================================================================= conv2d_1 (Conv2D) (None, 26, 26, 32) 320 _________________________________________________________________ conv2d_2 (Conv2D) (None, 26, 26, 64) 18496 _________________________________________________________________ max_pooling2d_1 (MaxPooling2 (None, 13, 13, 64) 0 _________________________________________________________________ dropout_1 (Dropout) (None, 13, 13, 64) 0 _________________________________________________________________ conv2d_3 (Conv2D) (None, 13, 13, 64) 36928 _________________________________________________________________ conv2d_4 (Conv2D) (None, 13, 13, 128) 73856 _________________________________________________________________ max_pooling2d_2 (MaxPooling2 (None, 6, 6, 128) 0 _________________________________________________________________ flatten_1 (Flatten) (None, 4608) 0 _________________________________________________________________ dense_1 (Dense) (None, 256) 1179904 _________________________________________________________________ dense_2 (Dense) (None, 10) 2570 ================================================================= Total params: 1,312,074 Trainable params: 1,312,074 Non-trainable params: 0 _________________________________________________________________ <tf.Tensor 'conv2d_1_input_1:0' shape=(?, 28, 28, 1) dtype=float32> 

मुझे यहां से क्या जानकारी मिल सकती है?

1. इनपुट मॉडल (conv2d_1 लेयर) आयाम की एक वस्तु को स्वीकार करता है? X28x28x1, कहाँ "?" - वस्तुओं की संख्या; यदि छवि एक है, तो आयाम 1x28x28x1 होगा। और छवि एक त्रि-आयामी सरणी है, जहां एक आयाम 1 है। अर्थात, छवि को 0 से 255 तक के मानों की तालिका के रूप में परोसा जाता है।
2. मॉडल (dense_2 परत) के आउटपुट पर, आयाम 10 का एक वेक्टर प्राप्त किया जाता है।

हम छवि को लोड करते हैं और इसे फ्लोट प्रकार में परिवर्तित करने के लिए मत भूलना (आगे तंत्रिका नेटवर्क वास्तविक संख्या के साथ काम करेगा) और इसे सामान्य करें (सभी मूल्यों को 255 से विभाजित करें)। यहां यह स्पष्ट है कि तंत्रिका नेटवर्क के साथ काम करते समय सामान्यीकरण "अनिवार्य" चाल में से एक है, लेकिन हमलावर को यह पता नहीं चल सकता है, इसलिए हमने विशेष रूप से कार्य के विवरण में एक छोटा संकेत जोड़ा है:

 img = Image.open("ZeroSource.bmp") #   img = np.array(img) #     numpy.array img = img.astype('float32') #      float img /= 255 #  

अब हम छवि को लोड किए गए मॉडल में भेज सकते हैं और देख सकते हैं कि यह क्या परिणाम देता है:

 model.predict(img.reshape(1,28,28,1)) #   predict            

आउटपुट निम्नलिखित जानकारी है

 array([[1.0000000e+00, 4.2309660e-19, 3.1170484e-15, 6.2545637e-18, 1.4199094e-16, 6.3990816e-13, 6.9493417e-10, 2.8936278e-12, 8.9440377e-14, 1.6340098e-12]], dtype=float32) 

यह व्याख्या करने योग्य है कि यह वेक्टर क्या है: वास्तव में, यह एक संभावना वितरण है, अर्थात, प्रत्येक संख्या कक्षा 0,1,2 ... 9 की संभावना का प्रतिनिधित्व करती है। वेक्टर में सभी संख्याओं का योग 1 है। इस मामले में, यह देखा जा सकता है कि मॉडल आश्वस्त है कि इनपुट छवि 100% की संभावना के साथ वर्ग 0 का प्रतिनिधित्व करती है।

यदि हम इसे हिस्टोग्राम पर चित्रित करते हैं, तो हमें निम्नलिखित मिलते हैं:

पूर्ण विश्वास।

यदि मॉडल वर्ग को निर्धारित नहीं कर सकता है, तो संभावना वेक्टर एक समान वितरण के लिए होगा, जो बदले में, इसका मतलब होगा कि मॉडल एक ही संभावना के साथ सभी वर्गों के लिए ऑब्जेक्ट को एक साथ असाइन करता है। और हिस्टोग्राम इस तरह दिखेगा:

यह आमतौर पर स्वीकार किया जाता है कि किसी दिए गए वेक्टर में एक मॉडल का वर्ग अधिकतम संख्या के सूचकांक द्वारा निर्धारित किया जाता है। यही है, मॉडल सैद्धांतिक रूप से 10% से अधिक की संभावना के साथ एक वर्ग चुन सकता है। लेकिन यह तर्क डेवलपर्स द्वारा वर्णित निर्णय तर्क के आधार पर भिन्न हो सकते हैं।

अब आइए सबसे दिलचस्प भाग - प्रतिकूल हमलों पर चलते हैं।

सबसे पहले, FoolBox लाइब्रेरी में एक मॉडल के साथ काम करने के लिए, आपको Foolbox संकेतन में मॉडल का अनुवाद करना होगा। आप इसे इस तरह से कर सकते हैं:

 fmodel = foolbox.models.KerasModel(model,bounds=(0,1)) #  bounds ,       ,        255,        0-1. 

उसके बाद, आप विभिन्न हमलों का परीक्षण कर सकते हैं। सबसे लोकप्रिय के साथ शुरू करते हैं - FGSM:

FGSM

 attack = foolbox.attacks.FGSM(fmodel) #    FGSM     adversarial = attack(img.reshape(28,28,1),0) #  ,  adversarial  probs = model.predict(adversarial.reshape(1,28,28,1)) #     print(probs) #    print(np.argmax(probs)) #      

तंत्रिका नेटवर्क का आउटपुट निम्नानुसार होगा

 [4.8592144e-01 2.5432981e-14 5.7048566e-13 1.6787202e-14 1.6875961e-11 1.2974949e-07 5.1407838e-01 3.9819957e-12 1.9827724e-09 5.7383300e-12] 6 

और परिणामी छवि:

तो, अब 50% 0 से अधिक की संभावना के साथ 6. पहले से ही अच्छा माना जाता था। हालांकि, हम अभी भी 1 प्राप्त करना चाहते हैं, और शोर का स्तर बहुत प्रभावशाली नहीं है। छवि वास्तव में देखने योग्य है। इसके बारे में बाद में। इस बीच, चलो हमलों को हवा देने की कोशिश करते हैं। अचानक, हम अभी भी 1 प्राप्त करते हैं।

एल-बीएफजीएस हमला

 attack = foolbox.attacks.LBFGSAttack(fmodel) adversarial = attack(img.reshape(28,28,1),0) probs = model.predict(adversarial.reshape(1,28,28,1)) print(probs) print(np.argmax(probs)) 

निष्कर्ष:

 [4.7782943e-01, 1.9682934e-10, 1.0285517e-06, 3.2558936e-10, 6.5797998e-05, 4.0495447e-06, 2.5545436e-04, 3.4730587e-02, 5.5223148e-07, 4.8711312e-01] 9 

चित्र:

फिर से अब हमने ~ 49% की संभावना के साथ 9 को 9 के रूप में मान्यता दी है। हालांकि, शोर बहुत कम है।

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

इस मॉड्यूल में, आप एक हमले के लिए एक मानदंड का चयन कर सकते हैं, अगर यह उनका समर्थन करता है। विशेष रूप से, हम दो मानदंडों में रुचि रखते हैं:

1. टारगेटक्लास - ऐसा बनाता है कि प्रायिकता वितरण के वेक्टर में, संख्या k वाले तत्व की अधिकतम संभावना है।
2. TargetClassProbability - यह इसलिए बनाता है ताकि प्रायिकता वितरण के वेक्टर में, संख्या k वाले तत्व में कम से कम p की संभावना हो।

आइए कोशिश करते हैं दोनों:

L-BFGS + TargetClass

टारगेटक्लास मानदंड में मुख्य बात कक्षा k की प्रायिकता प्राप्त करना है, किसी भी अन्य वर्ग की संभावना से अधिक। तब नेटवर्क जो अधिकतम संभावना को देखकर निर्णय लेता है, उसे गलत माना जाएगा।

 attack = foolbox.attacks.LBFGSAttack(fmodel,foolbox.criteria.TargetClass(1))#    ,     ,    TargetClass,  ,      ,      adversarial = attack(img.reshape(28,28,1),0) probs = model.predict(adversarial.reshape(1,28,28,1)) print(probs) print(np.argmax(probs)) 

निष्कर्ष:

 [3.2620126e-01 3.2813528e-01 8.5446298e-02 8.1292394e-04 1.1273423e-03 2.4886258e-02 3.3904776e-02 1.9947644e-01 8.2347924e-07 8.5878673e-06] 1 

चित्र:

जैसा कि निष्कर्ष से देखा जा सकता है, अब हमारे तंत्रिका नेटवर्क का दावा है कि यह 32.8% की संभावना के साथ 1 है, जबकि 0 की संभावना यथासंभव इस मूल्य के करीब है और 32.6% है। हमने कर दिखाया! सिद्धांत रूप में, यह कार्य पूरा करने के लिए पहले से ही पर्याप्त है। लेकिन हम आगे बढ़ेंगे और 0.5 से ऊपर 1 की संभावना प्राप्त करने का प्रयास करेंगे।

L-BFGS + TargetClassProbability

अब हम मानदंड TargetClassProbability का उपयोग करते हैं, जो आपको पी से कम नहीं वस्तु में एक वर्ग की संभावना प्राप्त करने की अनुमति देता है। इसके केवल दो पैरामीटर हैं:
1) वस्तु की वर्ग संख्या।
2) प्रतिकूल उदाहरण में इस वर्ग की संभावना।
उसी समय, यदि ऐसी संभावना को प्राप्त करना असंभव है, या ऐसी वस्तु को खोजने का समय बहुत अधिक समय लेता है, तो प्रतिकूल वस्तु कोई भी नहीं के बराबर होगी। , 0.99 की संभावना बनाने के लिए प्रयास करके आप इसे स्वयं सत्यापित कर सकते हैं। तब विधि अच्छी तरह से अभिसरण नहीं हो सकती है।

 attack = foolbox.attacks.LBFGSAttack(fmodel,foolbox.criteria.TargetClassProbability(1,0.5)) adversarial = attack(img.reshape(28,28,1),0) probs = model.predict(adversarial.reshape(1,28,28,1)) print(probs) print(np.argmax(probs)) 

निष्कर्ष:

 [4.2620126e-01 5.0013528e-01 9.5413298e-02 8.1292394e-04 1.1273423e-03 2.4886258e-02 3.3904776e-02 1.9947644e-01 8.2347924e-07 8.5878673e-06] 

हुर्रे! हम एक प्रतिकूल-उदाहरण प्राप्त करने में कामयाब रहे, जिसमें हमारे तंत्रिका नेटवर्क के लिए संभावना 1 50% से ऊपर है! अद्भुत! अब आइए वियोगीकरण करते हैं (छवि को 0-255 प्रारूप में लौटाएं) और इसे सहेजें।

अंतिम स्क्रिप्ट इस प्रकार है:

 import keras from PIL import Image import numpy as np import foolbox from foolbox.criteria import TargetClassProbability import scipy.misc model = keras.models.load_model("KerasModel.h5") img = Image.open("ZeroSource.bmp") img = np.array(img.getdata()) img = img.astype('float32') img = img /255. img = img.reshape(28,28,1) fmodel = foolbox.models.KerasModel(model,bounds=(0,1)) attack = foolbox.attacks.LBFGSAttack(fmodel,criterion=TargetClassProbability(1 ,p=.5)) adversarial = attack(img[:,:,::-1], 0) adversarial = adversarial * 255 adversarial = adversarial.astype('int') scipy.misc.toimage(adversarial.reshape(28,28)).save('AdversarialExampleZero.bmp') 

और अंतिम छवि इस प्रकार है:

।

निष्कर्ष

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

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

आपका ध्यान के लिए धन्यवाद!