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:
- 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?
- 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. - Irgendwelche Erkenntnisse, warum Gensim ist besser? Ist mein Modell auch anders, wie Sie es implementieren?
- 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
Du musst angemeldet sein, um einen Kommentar abzugeben.
Alte Frage, aber eine Antwort wäre hilfreich für zukünftige Besucher. So, hier sind einige meiner Gedanken.
Gibt es einige Probleme in der
tensorflow
Umsetzung:window
1-Seite Größe, sowindow=5
wäre5*2+1
=11
Worte.batch_size
wäre die Anzahl der Dokumente. Sotrain_word_dataset
Form wärebatch_size * context_window
währendtrain_doc_dataset
undtrain_labels
Formen wärebatch_size
.sampled_softmax_loss
ist nichtnegative_sampling_loss
. Es sind zwei verschiedene Annäherungen ansoftmax_loss
.Also für die OP ' s aufgelistet, Fragen:
doc2vec
imtensorflow
funktioniert und korrekt auf seine eigene Weise, aber es ist anders als diegensim
Umsetzung und das Papier.window
1-Seite Größe wie oben gesagt. Wenn das Dokument kleiner als Kontext der Größe, dann die kleineren würde verwendet werden.gensim
Umsetzung schneller. Zuerstgensim
wurde stark optimiert, alle Operationen schneller sind als naive python-Operationen, insbesondere die Daten-I/O. Zweitens, einige preprocessing-Schritte wiemin_count
Filterung ingensim
verringern würde, die dataset-Größe. Noch wichtiger ist,gensim
verwendetnegative_sampling_loss
die ist viel schneller alssampled_softmax_loss
ich denke, das ist der Hauptgrund.Es ist wahr, dass es viele Lösungen in diesem nicht-konvexen Optimierungsproblem, so würde das Modell nur ein lokales optimum. Interessant ist, dass in neuronalen Netzen, die meisten lokalen optima "gut genug" sind. Es wurde beobachtet, dass stochastic gradient descent zu finden, scheint eine bessere lokale optima als größere batch gradient descent, das ist zwar immer noch ein Rätsel in der aktuellen Forschung.
InformationsquelleAutor der Antwort THN