我想知道如何将自训练的word2vec保存为txt文件，其格式应类似于’word2vec-google-news’或’glove.6b.50d’，这些文件包含词汇和对应的向量。

我将自训练的向量导出到txt文件中，但这些文件中只有向量，没有前置的词汇。

我用于训练自己word2vec的代码如下：

from __future__ import absolute_importfrom __future__ import divisionfrom __future__ import print_functionimport collectionsimport mathimport randomimport numpy as npfrom six.moves import xrangeimport zipfileimport tensorflow as tfimport pandas as pdfilename = ('data/data.zip')# Step 1: Read the data into a list of strings.def read_data(filename):  with zipfile.ZipFile(filename) as f:    data = tf.compat.as_str(f.read(f.namelist()[0])).split()    return datawords = read_data(filename)#print('Data size', len(words))# Step 2: Build the dictionary and replace rare words with UNK token.vocabulary_size = 50000def build_dataset(words):    count = [['UNK', -1]]    count.extend(collections.Counter(words).most_common(vocabulary_size - 1))    #print("count",len(count))    dictionary = dict()    for word, _ in count:        dictionary[word] = len(dictionary)    data = list()    unk_count = 0    for word in words:        if word in dictionary:            index = dictionary[word]        else:            index = 0            unk_count += 1        data.append(index)    count[0][1] = unk_count    reverse_dictionary = dict(zip(dictionary.values(), dictionary.keys()))    return data, count, dictionary, reverse_dictionarydata, count, dictionary, reverse_dictionary = build_dataset(words)#del words  # Hint to reduce memory.#print('Most common words (+UNK)', count[:5])#print('Sample data', data[:10], [reverse_dictionary[i] for i in data[:10]])data_index = 0# Step 3: Function to generate a training batch for the skip-gram model.def generate_batch(batch_size, num_skips, skip_window):    global data_index    assert batch_size % num_skips == 0    assert num_skips <= 2 * skip_window    batch = np.ndarray(shape=(batch_size), dtype=np.int32)    labels = np.ndarray(shape=(batch_size, 1), dtype=np.int32)    span = 2 * skip_window + 1  # [ skip_window target skip_window ]    buffer = collections.deque(maxlen=span)    for _ in range(span):        buffer.append(data[data_index])        data_index = (data_index + 1) % len(data)    for i in range(batch_size // num_skips):        target = skip_window  # target label at the center of the buffer        targets_to_avoid = [skip_window]        for j in range(num_skips):            while target in targets_to_avoid:                target = random.randint(0, span - 1)            targets_to_avoid.append(target)            batch[i * num_skips + j] = buffer[skip_window]            labels[i * num_skips + j, 0] = buffer[target]        buffer.append(data[data_index])        data_index = (data_index + 1) % len(data)    return batch, labelsbatch, labels = generate_batch(batch_size=8, num_skips=2, skip_window=1)#for i in range(8): #print(batch[i], reverse_dictionary[batch[i]],'->', labels[i, 0], reverse_dictionary[labels[i, 0]])# Step 4: Build and train a skip-gram model.batch_size = 128embedding_size = 128skip_window = 2num_skips = 2valid_size = 9valid_window = 100num_sampled = 64    # Number of negative examples to sample.valid_examples = np.random.choice(valid_window, valid_size, replace=False)graph = tf.Graph()with graph.as_default():    # Input data.    train_inputs = tf.placeholder(tf.int32, shape=[batch_size])    train_labels = tf.placeholder(tf.int32, shape=[batch_size, 1])    valid_dataset = tf.constant(valid_examples, dtype=tf.int32)    # Ops and variables pinned to the CPU because of missing GPU implementation    with tf.device('/cpu:0'):        # 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]),dtype=tf.float32)    # Compute the average NCE loss for the batch.    # tf.nce_loss automatically draws a new sample of the negative labels each    # time we evaluate the loss.    loss = tf.reduce_mean(            tf.nn.nce_loss(weights=nce_weights,biases=nce_biases, inputs=embed, labels=train_labels,                 num_sampled=num_sampled, num_classes=vocabulary_size))    # Construct the SGD optimizer using a learning rate of 1.0.    optimizer = tf.train.GradientDescentOptimizer(1.0).minimize(loss)    # 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)    # Add variable initializer.    init = tf.global_variables_initializer()# Step 5: Begin training.num_steps = 20000with tf.Session(graph=graph) as session:    # We must initialize all variables before we use them.    init.run()    #print("Initialized")    average_loss = 0    for step in xrange(num_steps):        batch_inputs, batch_labels = generate_batch(batch_size, num_skips, skip_window)        feed_dict = {train_inputs: batch_inputs, train_labels: batch_labels}        # We perform one update step by evaluating the optimizer op (including it        # in the list of returned values for session.run()        _, loss_val = session.run([optimizer, loss], feed_dict=feed_dict)        average_loss += loss_val        #if step % 2000 == 0:         #   if step > 0:          #      average_loss /= 2000            # The average loss is an estimate of the loss over the last 2000 batches.           # print("Average loss at step ", step, ": ", average_loss)            #average_loss = 0    final_embeddings = normalized_embeddings.eval()np.savetxt('data/w2v.txt', final_embeddings)

回答：