gensim Doc2Vec vs tensorflow Doc2Vec

Ich versuche zu vergleichen, meine Implementierung von Doc2Vec (via tf) und gensims Umsetzung. Es scheint, wenigstens optisch, dass die gensim diejenigen besser ab.

Lief ich den folgenden code zum trainieren des gensim-Modell und eine darunter, die für tensorflow Modell. Meine Fragen sind wie folgt:

  1. Ist mein tf-Umsetzung von Doc2Vec richtig. Im Grunde soll es sein, die Verkettung der Wort-Vektoren und die Dokument-Vektor, um vorherzusagen, das Wort in der Mitte in einem bestimmten Kontext?
  2. Hat die window=5 parameter im gensim bedeuten, dass ich mit zwei Worten auf beiden Seiten, um vorherzusagen, der in der Mitte? Oder ist es 5 auf beiden Seiten. Sache ist, es gibt durchaus ein paar Dokumente, die kleiner sind als die Länge 10.
  3. Irgendwelche Erkenntnisse, warum Gensim ist besser? Ist mein Modell auch anders, wie Sie es implementieren?
  4. Man bedenkt, dass dies effektiv eine matrix factorisation problem, warum ist das TF-Modell noch immer eine Antwort? Es gibt unendlich viele Lösungen, da Ihr einen Rang defizienten problem. <- Diese Letzte Frage ist einfach nur ein bonus.

Gensim

model = Doc2Vec(dm=1, dm_concat=1, size=100, window=5, negative=10, hs=0, min_count=2, workers=cores)
model.build_vocab(corpus)
epochs = 100
for i in range(epochs):
    model.train(corpus)

TF

batch_size = 512
embedding_size = 100 # Dimension of the embedding vector.
num_sampled = 10 # Number of negative examples to sample.


graph = tf.Graph()

with graph.as_default(), tf.device('/cpu:0'):
    # Input data.
    train_word_dataset = tf.placeholder(tf.int32, shape=[batch_size])
    train_doc_dataset = tf.placeholder(tf.int32, shape=[batch_size/context_window])
    train_labels = tf.placeholder(tf.int32, shape=[batch_size/context_window, 1])

    # The variables   
    word_embeddings =  tf.Variable(tf.random_uniform([vocabulary_size,embedding_size],-1.0,1.0))
    doc_embeddings = tf.Variable(tf.random_uniform([len_docs,embedding_size],-1.0,1.0))
    softmax_weights = tf.Variable(tf.truncated_normal([vocabulary_size, (context_window+1)*embedding_size],
                             stddev=1.0 / np.sqrt(embedding_size)))
    softmax_biases = tf.Variable(tf.zeros([vocabulary_size]))

    ###########################
    # Model.
    ###########################
    # Look up embeddings for inputs and stack words side by side
    embed_words = tf.reshape(tf.nn.embedding_lookup(word_embeddings, train_word_dataset),
                            shape=[int(batch_size/context_window),-1])
    embed_docs = tf.nn.embedding_lookup(doc_embeddings, train_doc_dataset)
    embed = tf.concat(1,[embed_words, embed_docs])
    # Compute the softmax loss, using a sample of the negative labels each time.
    loss = tf.reduce_mean(tf.nn.sampled_softmax_loss(softmax_weights, softmax_biases, embed,
                                   train_labels, num_sampled, vocabulary_size))

    # Optimizer.
    optimizer = tf.train.AdagradOptimizer(1.0).minimize(loss)

Update:

Check-out die jupyter notebook hier (ich habe beide Modelle arbeiten und getestet und hier). Es fühlt sich immer noch wie die gensim-Modell ist besser in dieser ersten Analyse.

InformationsquelleAutor der Frage Sachin_ruk | 2016-10-04

Schreibe einen Kommentar