तंत्रिका अंकगणितीय तर्क इकाइयों (NALU) के लिए सरल गाइड: स्पष्टीकरण, अंतर्ज्ञान और कोड

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

इस पोस्ट में मैं एनएलयू, इसकी वास्तुकला, इसके घटकों और पारंपरिक तंत्रिका नेटवर्क पर महत्व के बारे में बताऊंगा। इस पोस्ट के पीछे प्राथमिक उद्देश्य NALU (अवधारणाओं और कोड दोनों के साथ) की सरल और सहज व्याख्या प्रदान करना है, जिसे शोधकर्ताओं, इंजीनियरों और छात्रों द्वारा समझा जा सकता है जिन्हें तंत्रिका नेटवर्क और गहन सीखने का सीमित ज्ञान है।

नोट: मैं पाठकों को इस विषय की अधिक विस्तृत समझ के लिए मूल पेपर पढ़ने की दृढ़ता से सलाह देता हूं। पेपर को यहां से डाउनलोड किया जा सकता है।

न्यूरल नेटवर्क कहां विफल होते हैं?

यह चित्र इस मध्यम पद से लिया गया है

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

हालांकि, कागज के लेखकों के अनुसार, उनके पास बहुत बुनियादी क्षमता की कमी है जो मानव के लिए या यहां तक ​​कि मधुमक्खियों के लिए तुच्छ लगता है! यह संख्या को देखने और हेरफेर करने की क्षमता है, और एक संख्यात्मक रूप से संख्यात्मक पैटर्न से संख्यात्मक संबंध को एक्सट्रपलेशन करने के लिए। कागज में, यह दिखाया गया है कि मानक तंत्रिका नेटवर्क यहां तक ​​कि एक पहचान फ़ंक्शन (एक फ़ंक्शन जिसका इनपुट और आउटपुट समान है; f (x) = x) जो कि सबसे सीधा संख्यात्मक संबंध है, सीखने के लिए भी संघर्ष करता है। नीचे दी गई छवि इस तरह के एक पहचान समारोह को जानने के लिए प्रशिक्षित विभिन्न एनएन के माध्य वर्ग त्रुटि (एमएसई) को दर्शाती है।

छवि एक मानक तंत्रिका नेटवर्क के लिए MSE को दिखाती है जिसमें छिपी हुई परतों में विभिन्न सक्रियण कार्यों (गैर-रैखिकता) का उपयोग करके सटीक एक ही आर्किटेक्चर प्रशिक्षित किया जाता है

वे असफल क्यों होते हैं?

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

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

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

समाधान: तंत्रिका संचयक (एनएसी)

तंत्रिका संचयकर्ता (NAC) NALU मॉडल के लिए आधार बनाता है। एनएसी एक सरल लेकिन प्रभावी तंत्रिका नेटवर्क मॉडल (इकाई) है जो अतिरिक्त और घटाव सीखने की क्षमता का समर्थन करता है - जो रैखिक कार्यों को प्रभावी ढंग से सीखने के लिए एक वांछनीय संपत्ति है।

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

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

व्याख्या करने के लिए कि बिना पूर्वाग्रह वाले तंत्रिका नेटवर्क की परतें और वजन -1, 0 या 1 होने के कारण रैखिक एक्सट्रपलेशन सीख सकते हैं।

जैसा कि एनएन परतों के ऊपर दिखाया गया है, नेटवर्क वज़न को सीमित करने के लिए जोड़, घटाव (y = X1 + x2 और y = X1-x2) जैसे साधारण अंकगणितीय कार्यों को एक्सट्रपलेशन करना सीख सकता है।

नोट: जैसा कि ऊपर दिए गए नेटवर्क आरेखों में दिखाया गया है, एनएसी में कोई पूर्वाग्रह पैरामीटर (बी) नहीं है और छिपी परत इकाइयों के आउटपुट पर कोई गैर-रैखिकता लागू नहीं है।

चूंकि एनएसी में वजन मापदंडों पर कसना मानक तंत्रिका नेटवर्क द्वारा सीखना कठिन है, इसलिए लेखकों ने मानक (अप्रतिबंधित) मापदंडों W_hat और M_hat का उपयोग करके ऐसे प्रतिबंधित पैरामीटर मूल्यों को सीखने के लिए बहुत उपयोगी सूत्र का वर्णन किया है। ये पैरामीटर किसी भी मानक एनएन वजन मापदंडों की तरह हैं जिन्हें यादृच्छिक रूप से आरंभ किया जा सकता है और प्रशिक्षण प्रक्रिया के दौरान सीखा जा सकता है। W_hat और M_hat के संदर्भ में W को प्राप्त करने का सूत्र नीचे दिया गया है:

फॉर्मूला दो मैट्रिसेस के बीच तत्व-वार उत्पाद को दर्शाता है

नेटवर्क में वजन मापदंडों की गणना करने के लिए उपरोक्त समीकरण का उपयोग करना, गारंटी देता है कि ऐसे मापदंडों का मूल्य [-1,1] की सीमा में होगा, जिसका झुकाव -1, 0 और 1. की ओर है, साथ ही, यह समीकरण एक अलग समीकरण है (जिसका व्युत्पत्ति वजन मापदंडों के संबंध में गणना की जा सकती है)। इसलिए, एनएसी के लिए ग्रेडिएंट डिसेंट और बैक प्रोपगेशन का उपयोग करके डब्ल्यू सीखना आसान होगा। नीचे एक एनएसी इकाई का वास्तु चित्र है।

सरल (रैखिक) संख्यात्मक कार्यों को सीखने के लिए एनएसी वास्तुकला

Tensorflow का उपयोग करके अजगर में NAC कार्यान्वयन

जैसा कि कोई कल्पना कर सकता है, एनएसी एक सरल एनएन मॉडल है जिसमें कुछ कम मोड़ हैं। नीचे मैंने Tensorflow और Numpy लाइब्रेरी का उपयोग करके अजगर में एक एकल NAC परत का सरल कार्यान्वयन दिखाया है।

आयात एनपीपी के रूप में सुन्न
tf के रूप में आयात स्पर्शरेखा
# जोड़ / घटाव के लिए एक तंत्रिका संचायक (NAC) को परिभाषित करें -> जोड़ / घटाव संचालन को सीखने के लिए उपयोगी है

def nac_simple_single_layer (x_in, out_units):
    '' '
    गुण:
        x_in -> इनपुट टेंसर
        out_units -> आउटपुट इकाइयों की संख्या

    वापसी:
       y_out -> उल्लिखित आकृति का आउटपुट टेंसर
       W -> परत का भार मैट्रिक्स
    '' '
# इनपुट सुविधाओं की संख्या (संख्या) प्राप्त करें
    in_features = x_in.shape [1]

    # W_hat और M_hat को परिभाषित करें

    W_hat = tf.get_variable (आकृति = [in_features, out_units],
    initializer = tf.initializers.random_uniform (न्यूनतम = -2, अधिकतम = 2),
    ट्रेन करने योग्य = सत्य, नाम = "W_hat")

    M_hat = tf.get_variable (आकार = [in_shape, out_units],
    initializer = tf.initializers.random_uniform (न्यूनतम = -2, अधिकतम = 2),
    trainable = true, name = "M_hat")

    # सूत्र का उपयोग करके डब्ल्यू प्राप्त करें
    W = tf.nn.tanh (W_hat) * tf.nn.sigmoid (M_hat)

    y_out = tf.matmul (x_in, W)

    वापसी y_out, डब्ल्यू

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

इसके अलावा और घटाव से आगे बढ़ना: जटिल संख्यात्मक कार्यों के लिए एनएसी

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

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

एनएसी आर्किटेक्चर अधिक जटिल संख्यात्मक फ़ंक्शन सीखने के लिए

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

ऊपर दिखाए गए जटिल एनएसी का आउटपुट समीकरण। एप्सिलॉन यहां प्रशिक्षण के दौरान लॉग (0) की स्थिति से बचने के लिए एक बहुत छोटा मूल्य है

इसलिए, W_hat और M_hat के संदर्भ में प्रतिबंधित भार W के सूत्र सहित सरल NAC और जटिल NAC के अंतर्निहित तंत्र के संदर्भ में सब कुछ समान है। अंतर केवल इतना है कि जटिल एनएसी परत के इनपुट और आउटपुट पर लॉग स्पेस लागू करता है।

जटिल एनएसी का पायथन कार्यान्वयन:

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

# लॉग स्पेस में एक जटिल एनएसी को परिभाषित करें -> गुणा, विभाजन और शक्ति जैसे अधिक जटिल अंकगणितीय कार्यों के लिए

def nac_complex_single_layer (x_in, out_units, epsilon = 0.00 %01):

    '' '
    : परम x_in: इनपुट सुविधा वेक्टर
    : param out_units: सेल की आउटपुट इकाइयों की संख्या
    : परम एप्सिलॉन: आउटपुट परिणाम में लॉग (0) से बचने के लिए छोटा मूल्य
    : रिटर्न m: आउटपुट टेंसर
    : वापसी डब्ल्यू: संबद्ध वजन मैट्रिक्स
    
    '' '

    in_features = x_in.shape [1]

    W_hat = tf.get_variable (आकृति = [in_shape, out_units],
    initializer = tf.initializers.random_uniform (न्यूनतम = -2, अधिकतम = 2),
    ट्रेन करने योग्य = सत्य, नाम = "W_hat")

    M_hat = tf.get_variable (आकृति = [in_features, out_units],
    initializer = tf.initializers.random_uniform (न्यूनतम = -2, अधिकतम = 2),
    trainable = true, name = "M_hat")
    #Get अप्रतिबंधित पैरामीटर मैट्रिक्स W
    W = tf.nn.tanh (W_hat) * tf.nn.sigmoid (M_hat)

    # जटिल कार्यों को सीखने के लिए लॉग स्पेस में इनपुट इनपुट सुविधा
    x_modified = tf.log (tf.abs (x_in) + epsilon)

    m = tf.exp (tf.matmul (x_modified, W))

    वापसी एम, डब्ल्यू

एक बार फिर, पूर्ण कार्य संहिता के लिए कृपया इस पोस्ट के अंत में मेरे GitHub रेपो का उल्लेख करें।

यह सब एक साथ रखना: तंत्रिका अंकगणितीय तर्क इकाइयाँ (NALU)

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

एनएलयू का एनोटेट आरेख

जैसा कि ऊपर की छवि में दिखाया गया है, NALU में दोनों NAC (पर्पल सेल) एक सीखे हुए सिग्मोइड गेट कंट्रोल (नारंगी सेल) द्वारा प्रक्षेपित (संयुक्त) होते हैं, जैसे कि NAC के आउटपुट को सक्रिय किया जा सकता है या न्यूमेरिक फ़ंक्शन के आधार पर गेट द्वारा निष्क्रिय किया जा सकता है। के लिए नेटवर्क को प्रशिक्षित करने की कोशिश कर रहे हैं।

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

सरल एनएसी: ए = डब्ल्यू एक्स
कॉम्प्लेक्स NAC: m = exp (W log (! X | + e))
जहां, W = tanh (W_hat) * sigmoid (M_hat)
गेट सेल: g = sigmoid (GX) # जहां G मानक ट्रेन योग्य पैरामीटर मैट्रिक्स है
# और आखिर में NALU का आउटपुट
NALU: y = g * a (1-g) * m # जहां * तत्व वार उत्पाद है

एनएलयू के उपरोक्त सूत्र में, हम कह सकते हैं कि यदि गेट आउटपुट जी = 0 है तो नेटवर्क केवल जटिल कार्यों को सीखेगा, लेकिन सरल नहीं। इसके विपरीत, अगर g = 1 है तो नेटवर्क केवल एडिटिव फंक्शंस सीखेगा न कि कॉम्प्लेक्स वाले। इसलिए, कुल मिलाकर NALU गुणा, जोड़, घटाव, विभाजन और शक्ति कार्यों से मिलकर किसी भी संख्यात्मक कार्य को इस तरह सीख सकता है कि प्रशिक्षण के दौरान देखी गई संख्याओं की सीमा के बाहर संख्याओं के लिए अच्छी तरह से एक्सट्रपलेशन करता है।

NALU का पायथन कार्यान्वयन:

एनएलयू के कार्यान्वयन में, हम पिछले कोड स्निपेट्स में परिभाषित सरल और जटिल एनएसी दोनों का उपयोग करेंगे।

डीईएल नालू (x_in, out_units, epsilon = 0.000001, get_weights = गलत):
    '' '
    : परम x_in: इनपुट सुविधा वेक्टर
    : param out_units: सेल की आउटपुट इकाइयों की संख्या
    : परम एप्सिलॉन: आउटपुट परिणाम में लॉग (0) से बचने के लिए छोटा मूल्य
    : param get_weights: सच है अगर मॉडल का वजन प्राप्त करना चाहते हैं
                        बदले में
    : वापसी: आउटपुट टेंसर
    : वापसी: गेट वजन मैट्रिक्स
    : वापसी: NAC1 (सरल एनएसी) वजन मैट्रिक्स
    : वापसी: NAC2 (जटिल एनएसी) वजन मैट्रिक्स
    '' '

    in_features = x_in.shape [1]

    # सरल एनएसी से आउटपुट टेंसर प्राप्त करें
    a, W_simple = nac_simple_single_layer (x_in, out_units)

    # जटिल एनएसी से आउटपुट टेंसर प्राप्त करें
    m, W_complex = nac_complex_single_layer (x_in, out_units, epsilon = epsilon)

    # गेट सिग्नल परत
    जी = tf.get_variable (आकार = [in_features, out_units])
    initializer = tf.random_normal_initializer (stddev = 1.0),
    trainable = true, name = "Gate_weights")

    g = tf.nn.sigmoid (tf.matmul (x_in, G))

    y_out = g * a + (1 - g) * m

    अगर (get_weights):
        वापसी y_out, G, W_simple, W_complex
    अन्य:
        वापसी y_out

फिर से, उपरोक्त कोड में, मैंने गेट मापदंडों जी के लिए यादृच्छिक सामान्य आरंभीकरण का उपयोग किया लेकिन कोई भी अनुशंसित वजन आरंभीकरण तकनीक का उपयोग कर सकता है।

इबेलिव एनएलयू एआई और विशेष रूप से तंत्रिका नेटवर्क में एक आधुनिक सफलता है जो बहुत आशाजनक लगता है। वे कई अनुप्रयोगों के लिए दरवाजे खोल सकते हैं जो मानक एनएन से निपटना मुश्किल लगते हैं।

लेखकों ने सरल अंकगणितीय फ़ंक्शन लर्निंग कार्यों से पेपर में तंत्रिका नेटवर्क अनुप्रयोगों के विभिन्न क्षेत्र में NALU को लागू करने के लिए विभिन्न प्रयोगों और परिणामों को दिखाया है ताकि नेटवर्क प्रोग्रामों का मूल्यांकन करने के लिए नेटवर्क सीखने के लिए MNIST छवियों की श्रृंखला में हस्तलिखित अंकों की संख्या की गणना की जा सके!

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

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

नीचे मेरे GitHub रिपॉजिटरी का लिंक दिया गया है जो इस पोस्ट में दिखाए गए कोड स्निपेट्स के पूर्ण कार्यान्वयन को दर्शाता है।

https://github.com/faizan2786/nalu_implementation

नेटवर्क को ट्यून करने के लिए विभिन्न हाइपरप्रामेटरों का उपयोग करके मेरे मॉडल का परीक्षण करने के लिए विभिन्न कार्यों को आज़माने के लिए आपका स्वागत है।

मुझे पता है अगर आप नीचे टिप्पणी में इस पोस्ट पर कोई प्रश्न या विचार है और मैं उन्हें संबोधित करने के लिए अपनी पूरी कोशिश करेंगे।

PS: यह किसी भी विषय पर मेरा पहला ब्लॉग पोस्ट है। तो, किसी भी सिफारिश, सुझाव और भविष्य दोनों को सलाह देता है, मेरे लेखन के बारे में तकनीकी और गैर तकनीकी स्वागत है।