tensorflow word2vec उदाहरण में वजन और पूर्वाग्रह का उद्देश्य क्या है?

Question

मैं समझने की कोशिश कर रहा हूं कि कैसे word2vec example काम करता है और वास्तव में समझ नहीं आता है कि वजन और पूर्वाग्रहों का उद्देश्य nse_loss फ़ंक्शन में पारित किया गया है। फ़ंक्शन में दो परिवर्तनीय इनपुट होते हैं: वजन (प्लस पूर्वाग्रह) और एम्बेडिंग।

# Look up embeddings for inputs. 
embeddings = tf.Variable(
    tf.random_uniform([vocabulary_size, embedding_size], -1.0, 1.0)) 
embed = tf.nn.embedding_lookup(embeddings, train_inputs) 

# Construct the variables for the NCE loss 
nce_weights = tf.Variable(
    tf.truncated_normal([vocabulary_size, embedding_size], 
         stddev=1.0/math.sqrt(embedding_size))) 
nce_biases = tf.Variable(tf.zeros([vocabulary_size])) 

दोनों यादृच्छिक रूप से प्रारंभ किए गए हैं और (जहां तक ​​मैं समझता हूं) दोनों सीखने के दौरान अपडेट के अधीन हैं।

# Compute the average NCE loss for the batch. 
loss = tf.reduce_mean(
    tf.nn.nce_loss(nce_weights, nce_biases, embed, train_labels, 
       num_sampled, vocabulary_size)) 

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

# Compute the cosine similarity between minibatch examples and all embeddings. 
norm = tf.sqrt(tf.reduce_sum(tf.square(embeddings), 1, keep_dims=True)) 
normalized_embeddings = embeddings/norm 
valid_embeddings = tf.nn.embedding_lookup(
    normalized_embeddings, valid_dataset) 
similarity = tf.matmul(
    valid_embeddings, normalized_embeddings, transpose_b=True) 

तो मॉडल के दूसरे घटक के बारे में क्या? क्यों वजन और पूर्वाग्रहों को नजरअंदाज किया जा रहा है?

धन्यवाद।

Answer 1

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

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

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

अद्यतन s0urcer ने बेहतर समझाया है कि वेक्टर प्रतिनिधित्व कैसे बनाया जाता है।

इनपुट परत और नेटवर्क की आउटपुट परत शब्दों का प्रतिनिधित्व करती है। इसका मतलब यह है कि यदि मूल्य वहां नहीं है और 1 शब्द है तो मूल्य 0 है। पहली स्थिति एक शब्द है, दूसरा दूसरा, आदि। आपके पास शब्दों के रूप में इनपुट/आउटपुट न्यूरॉन्स के रूप में है।

मध्यम परत संदर्भ है, या आप शब्द का वेक्टर प्रतिनिधित्व करते हैं।

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

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

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

Answer 2

तौल और पूर्वाग्रहों यहाँ अपडेट किया जाता है:

_, loss_val = session.run([optimizer, loss], feed_dict=feed_dict)

अनुकूलक निम्नलिखित है - ढाल की गणना करता है और फिर अद्यतन कदम नहीं करता है।

समानता एक अलग गणना में एक अलग गणना में कहा जाता है और परिणामों को प्रमाणित करने के लिए उपयोग किया जाता है। कोड की निम्न अनुभाग में क्या होता है कौन सा:

if step % 10000 == 0: sim = similarity.eval()

एम्बेडिंग के सत्यापन समानता एम्बेडिंग पर निर्भर करता है।

Answer 3

स्किप-ग्राम का विचार उनके संदर्भों से शब्दों की तुलना कर रहा है। इसलिए हम शब्दों को बराबर मानते हैं यदि वे बराबर संदर्भ में दिखाई देते हैं। एनएन की पहली परत शब्दों वेक्टर एन्कोडिंग का प्रतिनिधित्व करती है (मूल रूप से जिसे एम्बेडिंग कहा जाता है)। दूसरी परत संदर्भ का प्रतिनिधित्व करती है। हर बार जब हम पहली परत की केवल एक पंक्ति (Ri) लेते हैं (क्योंकि इनपुट वेक्टर हमेशा 0, ..., 0, 1, 0, ..., 0) जैसा दिखता है और इसे दूसरी परत के सभी कॉलम से गुणा करता है (सीजे, जे = 1. शब्दों की संख्या) और वह उत्पाद एनएन का उत्पादन होगा। हम न्यूरल नेटवर्क को प्रशिक्षित करते हैं ताकि अधिकतम आउटपुट घटकों Ri * Cj हो, यदि शब्द I और j निकट (उसी संदर्भ में) दिखाई देते हैं। प्रशिक्षण के प्रत्येक चक्र के दौरान हम केवल एक Ri को ट्यून करते हैं (फिर से इनपुट वेक्टर चुने जाने के तरीके के कारण) और सभी सीजे, जे = 1..w। जब प्रशिक्षण समाप्त होता है तो हम दूसरी परत के मैट्रिक्स को टॉस करते हैं क्योंकि यह संदर्भ का प्रतिनिधित्व करता है। हम केवल पहली परत के मैट्रिक्स का उपयोग करते हैं जो शब्दों के वेक्टर एन्कोडिंग का प्रतिनिधित्व करता है।