python 2.7 - Tensorflow में अज्ञात शब्दों के लिए नए एम्बेडिंग जोड़ने के लिए(प्रशिक्षण और परीक्षण के लिए पूर्व-सेट)




python-2.7 nlp (2)

नीचे दिए गए कोड का उदाहरण आपके embed_tensor फ़ंक्शन जैसे कि शब्दों को निम्नानुसार एम्बेड किए गए हैं:

  • उन शब्दों के लिए जो एक प्रेतगत एम्बेडिंग है, एम्बेडिंग प्रेरक एम्बेडेड के साथ आरंभ किया गया है। ट्रेनिंग योग्य होने पर एम्बेडिंग को प्रशिक्षण के दौरान निर्धारित किया जा सकता है।
  • प्रशिक्षण डेटा में शब्दों के लिए जो एक प्रेतगत एम्बेडिंग नहीं है, एम्बेडिंग को बेतरतीब ढंग से आरंभ किया गया है। ट्रेनिंग योग्य होने पर एम्बेडिंग को प्रशिक्षण के दौरान निर्धारित किया जा सकता है।
  • परीक्षण डेटा में ऐसे शब्दों के लिए जो प्रशिक्षण डेटा में नहीं होते हैं और एक प्रेतगत एम्बेडिंग नहीं है, एक अनियमित प्रारंभिक एम्बेडिंग वेक्टर का उपयोग किया जाता है। इस वेक्टर को प्रशिक्षित नहीं किया जा सकता है।
import tensorflow as tf
import numpy as np

EMB_DIM = 300
def load_pretrained_glove():
    return ["a", "cat", "sat", "on", "the", "mat"], np.random.rand([6, EMB_DIM])

def get_train_vocab():
    return ["a", "dog", "sat", "on", "the", "mat"]

def embed_tensor(string_tensor, trainable=True):
  """
  Convert List of strings into list of indices then into 300d vectors
  """
  # ordered lists of vocab and corresponding (by index) 300d vector
  pretrained_vocab, pretrained_embs = load_pretrained_glove()
  train_vocab = get_train_vocab()
  only_in_train = set(train_vocab) - set(pretrained_vocab)
  vocab = pretrained_vocab + only_in_train

  # Set up tensorflow look up from string word to unique integer
  vocab_lookup = tf.contrib.lookup.index_table_from_tensor(
    mapping=tf.constant(vocab),
    default_value=len(vocab))
  string_tensor = vocab_lookup.lookup(string_tensor)

  # define the word embedding
  pretrained_embs = tf.get_variable(
      name="embs_pretrained",
      initializer=tf.constant_initializer(np.asarray(pretrained_embs), dtype=tf.float32),
      trainable=trainable)
  train_embeddings = tf.get_variable(
      name="embs_only_in_train",
      shape=[len(only_in_train), EMB_DIM],
      initializer=tf.random_uniform_initializer(-0.04, 0.04),
      trainable=trainable)
  unk_embedding = tf.get_variable(
      name="unk_embedding",
      shape=[1, EMB_DIM],
      initializer=tf.random_uniform_initializer(-0.04, 0.04),
      trainable=False)

  embeddings = tf.concat([pretrained_embs, train_embeddings, unk_embedding], axis=0)

  return tf.nn.embedding_lookup(embeddings, string_tensor)

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

मैं एक सामान्य-यादृच्छिक 300 आयाम वेक्टर (तत्वों का प्रकार = tf.float32) जोड़ सकते हैं, जब भी पूर्व-प्रशिक्षित शब्दावली के लिए अज्ञात शब्द का सामना करना पड़ता है, तो मैं उत्सुक हूं। मैं पूर्व-प्रशिक्षित ग्लोइ शब्द एम्बेडिंग का उपयोग कर रहा हूं, लेकिन कुछ मामलों में, मुझे पता है कि मुझे अज्ञात शब्द मिलते हैं, और मैं इस नए पाया अज्ञात शब्द के लिए एक सामान्य-यादृच्छिक शब्द वेक्टर बनाना चाहता हूं।

समस्या यह है कि मेरे वर्तमान सेट अप के साथ, मैं tf.contrib.lookup.index_table_from_tensor का उपयोग करने के लिए ज्ञात शब्दावली पर आधारित शब्दों से कनवर्ट करने के लिए। यह फ़ंक्शन नए टोकन बना सकता है और उन्हें शब्दावली शब्दों में से कुछ पूर्वनिर्धारित संख्या के लिए हैश कर सकता है, लेकिन मेरे embed इस नए अज्ञात हैश मान के लिए एक एम्बेडिंग नहीं होगा। मैं अनिश्चित हूँ अगर मैं बस embed सूची के अंत में एक यादृच्छिक एम्बेडिंग जोड़ सकता हूं।

मैं यह भी एक कुशल तरीके से करना चाहता हूं, इसलिए पूर्व-निर्मित टेन्स्फोर्लो फ़ंक्शन या टेनसर्फ्लो फ़ंक्शंस को शामिल करने वाले विधि संभवतः सबसे कुशल होंगे। मैं पहले से ज्ञात विशेष टोकन जैसे वाक्य टोकन का अंत और रिक्त स्ट्रिंग (सूचकांक 0 पर "") के रूप में अज्ञात अज्ञात है, लेकिन यह विभिन्न विभिन्न अज्ञात शब्दों के लिए सीखने की अपनी शक्ति में सीमित है। मैं वर्तमान में अंतिम एम्बेडिंग चरण के रूप में tf.nn.embedding_lookup () का उपयोग कर रहा हूं।

मैं प्रशिक्षण डेटा में प्रत्येक अज्ञात शब्द के लिए नया यादृच्छिक 300d वैक्टर जोड़ने में सक्षम होना चाहूंगा, और मैं परीक्षण के दौरान संभवतः किसी भी अज्ञात टोकनों के लिए पूर्व-निर्मित यादृच्छिक शब्द वैक्टर जोड़ना चाहूंगा जो संभवतः परीक्षण के दौरान सामना कर रहे हैं। ऐसा करने का सबसे कारगर तरीका क्या है?

def embed_tensor(string_tensor, trainable=True):
    """    
    Convert List of strings into list of indicies then into 300d vectors
    """
    # ordered lists of vocab and corresponding (by index) 300d vector
    vocab, embed = load_pretrained_glove()

    # Set up tensorflow look up from string word to unique integer
    vocab_lookup = tf.contrib.lookup.index_table_from_tensor(
        mapping=tf.constant(vocab),
        default_value = 0)
    string_tensor = vocab_lookup.lookup(string_tensor)

    # define the word embedding 
    embedding_init = tf.Variable(tf.constant(np.asarray(embed),
                                 dtype=tf.float32),
                                 trainable=trainable,
                                 name="embed_init")

    # return the word embedded version of the sentence (300d vectors/word)
    return tf.nn.embedding_lookup(embedding_init, string_tensor)

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

index_table_from_tensor विधि एक num_oov_buckets पैरामीटर स्वीकार करता है जो आपके सभी ओओव शब्दों को पूर्वनिर्धारित संख्या में बाल्टी में बदलता है।

यदि आप इस पैरामीटर को एक निश्चित 'पर्याप्त बड़े' मान पर सेट करते हैं, तो आप इन बाल्ट्स के बीच अपने डेटा को फैलते देखेंगे (प्रत्येक बाल्टी में एक आईडी> अंतिम शब्दावली शब्दावली का आईडी है)।

इसलिए,

  • यदि (प्रत्येक लुकअप पर) आप अपने embedding_init व्हेरिएबल की यादृच्छिक मूल्य के लिए अंतिम पंक्तियों (बाल्टी से संबंधित होती है) को सेट करते हैं
  • यदि आप num_oov_buckets पर्याप्त रूप से बड़े करते हैं तो टकराव को कम किया जाएगा

आप एक ऐसा व्यवहार प्राप्त कर सकते हैं जो कि आप एक बहुत ही कुशल तरीके से पूछ रहे हैं (एक सन्निकटन) है।

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







nlp