तंत्रिका नेटवर्क में एक एम्बेडिंग परत क्या है?

Question

कई तंत्रिका नेटवर्क पुस्तकालयों में, 'एम्बेडिंग लेयर्स' होते हैं, जैसे कि केर या लासगैन में ।

मुझे यकीन नहीं है कि मैं प्रलेखन पढ़ने के बावजूद, इसके कार्य को समझता हूं। उदाहरण के लिए, केरस प्रलेखन में यह कहा गया है:

धनात्मक पूर्णांक (इंडेक्स) को निश्चित आकार के denses vectors में बदल दें, जैसे। [[४], [२०]] -> [[०.२५, ०.१], [०.६, ०.२]]

क्या कोई जानकार बता सकता है कि यह क्या करता है, और आप इसका इस्तेमाल कब करेंगे?

---

EDIT: प्रलेखन में चिपकाने के संबंध में, प्रलेखन से चिपकाने के लिए बहुत कुछ नहीं है, इसलिए मेरा सवाल है। मुझे समझ में नहीं आता है कि यह रूपांतरण होता है, न ही इसका उपयोग क्यों किया जाना चाहिए।

वैसे भी, यह कैसे में समझाया गया है:

एम्बेडिंग

keras। , उदा। [[४], [२०]] -> [[०.२५, ०.१], [०.६, ०.२]]

इनपुट आकार: आकृति के साथ 2 डी टेंसर: (nb_samples, क्रम_प्रवाह)। आउटपुट का आकार: आकृति के साथ 3 डी टेंसर: (nb_samples, क्रम_प्रवाह, output_dim)। तर्क:

input_dim: int> = 0. शब्दावली का आकार, यानी। इनपुट डेटा में होने वाला 1 + अधिकतम पूर्णांक सूचकांक। output_dim: int> = 0. सघन एम्बेडिंग का आयाम

और यहाँ यह कैसे यह Lasagne में समझाया गया है:

शब्द एम्बेडिंग के लिए एक परत। इनपुट एक पूर्णांक प्रकार Tensor चर होना चाहिए।

पैरामीटर: इनकमिंग: एक लेयर इंस्टेंस या टुपल

इस परत में खिला परत, या अपेक्षित इनपुट आकार।

input_size: int

विभिन्न एम्बेडिंग की संख्या। अंतिम एम्बेडिंग में index input_size - 1 होगा।

output_size: int

प्रत्येक एम्बेडिंग का आकार।

डब्ल्यू: थीनो साझा चर, अभिव्यक्ति, सुन्न सरणी या सुगम

एम्बेडिंग मैट्रिक्स के लिए प्रारंभिक मूल्य, अभिव्यक्ति या इनिशलाइज़र। यह आकार के साथ एक मैट्रिक्स होना चाहिए (input_size, output_size)। अधिक जानकारी के लिए lasagne.utils.create_param () देखें।

उदाहरण

>>> from lasagne.layers import EmbeddingLayer, InputLayer, get_output
>>> import theano
>>> x = T.imatrix()
>>> l_in = InputLayer((3, ))
>>> W = np.arange(3*5).reshape((3, 5)).astype('float32')
>>> l1 = EmbeddingLayer(l_in, input_size=3, output_size=5, W=W)
>>> output = get_output(l1, x)
>>> f = theano.function([x], output)
>>> x_test = np.array([[0, 2], [1, 2]]).astype('int32')
>>> f(x_test) array([[[  0.,   1.,   2.,   3.,   4.],
                      [ 10.,  11.,  12.,  13.,  14.]],
                     [[  5.,   6.,   7.,   8.,   9.],
                      [ 10.,  11.,  12.,  13.,  14.]]], dtype=float32)

Comments

कृपया अपने प्रश्न को समझने और उत्तर देने के लिए जो भी संदर्भ आवश्यक है, उसमें पेस्ट करें। लोग आपके लिए आपके प्रश्न का उत्तर देने के लिए कहीं और नहीं जाना चाहते हैं और प्रलेखन पढ़ना चाहते हैं।

— गंग

मैंने आपके द्वारा पूछे गए बदलाव किए हैं

— फ्रांसेस्को

मैं उसी संदेह के साथ था और इसके बारे में बात करने वाले कुछ दस्तावेज मिले। यहाँ कुछ दिलचस्प हैं: cs.cmu.edu/afs/cs/academy/class/15782-f06/slides/… fromthebottomoftheheap.net/2011/01/21/… / Apparbate यह इनपुट किए गए समय श्रृंखला में देरी लागू करता है और इस पर विचार करता है। नए वैक्टर के रूप में देरी।

— abutremutante

इस वीडियो को देखो: youtube.com/watch?v=bvZnphPgz74 । लगभग 30 मिनट वह एम्बेडिंग के बारे में बात करता है।

— पीटर

Answer 1

Word2Vec से संबंध

==========================================

एक साधारण तस्वीर में Word2Vec:

अधिक गहराई से व्याख्या:

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

Lasagne कोड का उपयोग कर स्पष्टीकरण

लेस्सन कोड स्निपेट को तोड़ें:

x = T.imatrix()

x पूर्णांक का एक मैट्रिक्स है। ठीक है, कोई समस्या नहीं है। शब्दावली में प्रत्येक शब्द एक पूर्णांक या 1-हॉट स्पार्स एन्कोडिंग का प्रतिनिधित्व कर सकता है। तो अगर x 2x2 है, तो हमारे पास दो डेटा पॉइंट्स हैं, जिनमें से प्रत्येक में 2-ग्राम हैं।

l_in = InputLayer((3, ))

$w_0, w_1, w_2$

W = np.arange(3*5).reshape((3, 5)).astype('float32')

यह हमारा शब्द एम्बेडिंग मैट्रिक्स है। यह 0 से 14 प्रविष्टियों के साथ 5 कॉलम मैट्रिक्स द्वारा एक 3 पंक्ति है।

$w_0 = (1,0,0)$$w_1 = (0, 1, 0)$$w_2 = (0, 0, 1)$$W$$w_0 \rightarrow w_0W = [0, 1, 2, 3, 4].$$w_1 \rightarrow w_1W = [5, 6, 7, 8, 9]$

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

l1 = EmbeddingLayer(l_in, input_size=3, output_size=5, W=W)

एम्बेडिंग परत

 output = get_output(l1, x)

एम्बेडिंग के लिए प्रतीकात्मक थीनो अभिव्यक्ति।

f = theano.function([x], output)

थीनो फ़ंक्शन जो एम्बेडिंग की गणना करता है।

x_test = np.array([[0, 2], [1, 2]]).astype('int32')

$(w_0, w_2)$$(w_1, w_2)$

$(w_0, w_2)$$W$

f(x_test) 

रिटर्न:

          array([[[  0.,   1.,   2.,   3.,   4.],
                  [ 10.,  11.,  12.,  13.,  14.]],
                 [[  5.,   6.,   7.,   8.,   9.],
                  [ 10.,  11.,  12.,  13.,  14.]]], dtype=float32)

आपको यह समझाने के लिए कि 3 वास्तव में शब्दावली आकार का प्रतिनिधित्व करता है, एक मैट्रिक्स इनपुट करने का प्रयास करें x_test = [[5, 0], [1, 2]]। आप देखेंगे कि यह एक मैट्रिक्स गलत मिलान त्रुटि उठाता है।

Comments

यह उत्तर अच्छा है। मेरे पास इस सवाल का एक विस्तार है कि किस तरह से एम्बेडेड लेयर इमडब सेंटीमेंट सैंपल (या किसी अन्य डेटासेट) को वेक्टर में बदल देती है। ये शब्दों का संग्रह हैं।

— कूबड़

Answer 2

में https://stackoverflow.com/questions/45649520/explain-with-example-how-embedding-layers-in-keras-works/ मैं 2 वाक्य का उपयोग कर एक उदाहरण तैयार करने के लिए कोशिश की, keras के texts_to_sequences

'This is a text' --> [0 0 1 2 3 4]

और एम्बेडिंग परत। कैसे 'केर' एंबेडिंग 'परत के आधार पर काम करता है? एम्बेडिंग परत पहले यादृच्छिक पर वेक्टर एम्बेडिंग को इनिशियलाइज़ करती है और फिर नेटवर्क ऑप्टिमाइज़र का उपयोग करके इसे उसी तरह अपडेट करती है जैसे कि केरस में किसी अन्य नेटवर्क लेयर के लिए करती है।

[0 0 1 2 3 4] --> 
[-0.01494285, -0.007915  ,  0.01764857],
[-0.01494285, -0.007915  ,  0.01764857],
[-0.03019481, -0.02910612,  0.03518577],
[-0.0046863 ,  0.04763055, -0.02629668],
[ 0.02297204,  0.02146662,  0.03114786],
[ 0.01634104,  0.02296363, -0.02348827]

ऊपर (अधिकतम) 6 शब्दों और 3 के output_dim के वाक्य के लिए कुछ प्रारंभिक एम्बेडिंग वेक्टर होगा।