tensorflow里的word2vec_basic代码解析

1、前提是手动已经下载好text8.zip数据，使用def read_data(filename)这个函数去读取zip里面的数据，调用了f = zipfile.ZipFile(filename, 'r' ,zipfile.ZIP_DEFLATED)这个函数，在得到文件描述符f后，调用data = tf.compat.as_str(f.read(f.namelist()[0])).split()函数，得到data，data包含17005207个单词，最后返回data。

2、建立一个50000大小的词典：使用def build_dataset(words)这个函数实现，1中的data即该函数中的words输入，在该函数中调用了count.extend(collections.Counter(words).most_common(vocabulary_size - 1))，这个语句的作用是统计words里17005270个单词每个单词出现的次数，显然words里的这些单词是有很多重复的，这就是需要这个第二步建立词典的意义了，并且统计完不同的单词每个单词的次数后选出出现频数最多的49999个词。其实这个语句还不能保证49999个单词不重复，因此后续语句

dictionary = dict()
  for word, _ in count:
    dictionary[word] = len(dictionary)

创建了dictionary，它确保了单词是唯一的，并且不能保证它的大小与count（长度是50000个单词）的大小相同，但是代码运行中发现dictionary的大小还是50000

接着：

data = list()
  unk_count = 0
  for word in words:
    if word in dictionary:
      index = dictionary[word]
    else:
      index = 0  # dictionary['UNK']
      unk_count += 1
    data.append(index)

在17005270个单词里取单词，查看取出的单词是不是在那大小为50000的字典里，如果在的话就把这个单词在字典里对应的值放到list类型的data中，如果不在的话，就默认值为0，并且把这个单词看成是unk，并统计unk单词的个数。由于data是list类型的，因此data的里的数据相同的数据会重复出现，那么data的长度就等于words的长度即17005270。

  count[0][1] = unk_count
  reverse_dictionary = dict(zip(dictionary.values(), dictionary.keys()))
  return data, count, dictionary, reverse_dictionary

接着更新count，更新unk单词的个数，将dictionary的键值调换。

最后返回data count dictionary reverse_dictionary

我感觉这个第二步，到最后就是把words里的17005270个单词都用dictionary里的数字来表示了，而数字就是单词的编码

3、调用函数：batch, labels = generate_batch(batch_size=8, num_skips=2, skip_window=1)。这一步是用来为skip-gram模型生成train batch数据的。
其中语句batch = np.ndarray(shape=(batch_size), dtype=np.int32)，是用来创建batch，并且这个batch是1行batch_size列，里面是随机数，类型是int32。

而语句labels = np.ndarray(shape=(batch_size, 1), dtype=np.int32)，是用来创建于batch对应的label，并且label是batch_size行1列，里面也是int32类型的随机数。

  span = 2 * skip_window + 1  # [ skip_window target skip_window ]
  buffer = collections.deque(maxlen=span)

接着span在本例中为3，因为skip_window为1.而buffer是一个队列，大小为span，这个buffer是最重要的要处理的数据的存储方式。

for _ in range(span):
    buffer.append(data[data_index])
    data_index = (data_index + 1) % len(data)

上面这个for就是对buffer进行初始化赋值，而data_index就是个全局变量用来记录已经从words里拿了多少数据（单词），在本例中span=3，所以每次从words里拿3个单词。

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)

上面这个for循环有点麻烦，其中batch_size // num_skips是整除的意思，在本例中它等于4

而target=skip_window的意思就是比如说单词序列  a b c d e f g，这里skip_windows=1，因为 a b c首先要放到buffer（队列）里，而target=skip_windows=1指向的是单词 b，而我们要做的预测就是根据b 预测a和c。

而内层的for循环以及 while语句就是利用了一个小技巧，随机的取单词b的前面和后面一个单词，放到label里面，那么batch里的内容就成了 b b，而label里的内容就成了a c或者c a（因为是随机取的）。

接着buffer.append(data[data_index])    data_index = (data_index + 1) % len(data)这两个语句就是从data（17005270大小）数据集里取一个新的单词放到buffer里，而buffer队列的队首的元素就被踢出队列。那么buffer队列里的数据就变成了 b c d。

自此，我觉得大概理解了batch具体是什么了，比如b a就是一个batch  b c 就是一个batch 而c b又是一个batch，自然也理解了batch_size等于8具体是什么意思。

最后，返回train batch即 batch和label

4、创建skip-gram model

  train_inputs = tf.placeholder(tf.int32, shape=[batch_size])  train_labels = tf.placeholder(tf.int32, shape=[batch_size, 1])

这个trian_inputs就是一个要把batch数据送到graph里的占位符，而train_labels就是要把label放到graph里的占位符。

    embeddings = tf.Variable(tf.random_uniform([vocabulary_size, embedding_size], -1.0, 1.0))
    embed = tf.nn.embedding_lookup(embeddings, train_inputs)

上面代码第一句，vocabulary_size大小为17005270，而embedding_size大小为128，那么embeddings这个占位符，所需要的数据就是vocabulary_size * embedding_size大小，且值在-1.0到1.0之间的矩阵。

第二句就是从embeddings结果里取出train_input所指示的单词对应位置的值，把结果存成矩阵embed。

# 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]))

上面两个语句，是创建NCE  loss需要的权重和偏置。而truncated_normal创建一个服从截断正态分布的tensor作为权重。

# 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(nce_weights, nce_biases, embed, train_labels,
                     num_sampled, vocabulary_size))

上面语句是计算先计算NCE 的loss，然后取平均

# Construct the SGD optimizer using a learning rate of 1.0.
  optimizer = tf.train.GradientDescentOptimizer(1.0).minimize(loss)

上面这句是使用梯度下降算法以1.0的学习率优化loss函数。