一、词向量

1，词向量由来

很多情况下，我们希望将单词转换为vector，让计算机跟数字进行打交道
例如：猫这个词，人们希望会通过这个词进行联想，可以得到动物、有毛、宠物、吃鱼等
为了表示这些单词，出现了很多的方法

①词典表示

用一个词典进行表示，把每一个单词都变成对应的一个数字，例如：{"yanyu":1,"Beyond":2,"hjj":3}
这里的1、2、3并没有包含单词本身的语义信息
缺点：一万个单词需要一万个词典来接收，很麻烦

②One-hot表示

跟词典表示方法类似，只不过是把一个词变成了一个向量进行表示而已
yanyu:[0,0,0,0,0,0,0,1]、Beyond:[0,0,0,0,0,0,1,0]、hjj:[0,0,0,0,0,0,1,1]
缺点：工作量大，单词表膨胀

③Bag of Words表示

把所有单词出现的次数进行标识

缺点：单词的顺序没有被考虑，语义信息仍未被考虑

④TF-IDF

罕见的单词权重高一点，常见的单词权重低一些，稍微加了一些单词的语义信息，但仍然很难表示单词的具体语义信息

⑤Bi-gram和N-gram

将多个单词拼在一起作为整体加入单词表

虽然考虑了词的顺序，但词表过于膨胀，并未解决根本的问题

⑥分布式表示(Distributed representation)

"You shall know a word by the company it keeps." ----- J. R. Firth 1957: 11
用一个词附近的其他词来表示该词
若想知道某个单词的具体含义，就看这个单词会跟什么别的单词同时出现，就能知道这个单词的含有，例如：banking跟crises和regulation有关系

⑦Word2Vec：Skip-Gram模型

假设有50000个单词，每个单词都是100维
input embedding输入词向量：需要新建一个50000100的矩阵，进来一个单词，就把这个单词所在的那一行取出来，将其作为输入词向量，也就是公式里面的u(0)
output embedding输出词向量：这里也是一个50000100的矩阵，也就是公式里面的v©

输入w(t)，t表示单词的位置
使用一个一层神经网络预测周围的若干个单词，w(t-1)、w(t-2)、w(t+1)…
用中心词去预测周围的单词
最终的目的只是使用模型中的某些参数


所用到的损失函数完整展开式：

涉及到求和和点积，运算速度很慢，工作量大。

Skip-Gram：负例采样Negative Sampling

制定一个假的任务，用一个中心词去预测周围词，因为这个任务太困难了，所以使用负例采样。
给定一个中心词、一个正确的周围词和若干个错误的周围词(从单词表中随机采样)，希望前面的部分越大越好，后面的部分因为有负号，所以也希望越大越好

P(w|context(w))： 一个正样本，V-1个负样本，对负样本做采样

本来是个超大的分类问题，通过负例采样就变成了一个二分类问题，只关心两个单词之间是不是相邻的，若相邻返回一个高一点的概率；若不相邻，返回一个低一点的概率

Negative Sampling想法提出的论文出处：《Distributed Representations of Words and Phrases and their Compositionality》

⑧应用

Ⅰ词嵌入可视化: 公司 — CEO

Ⅱ词嵌入可视化: 词向

Ⅲ词嵌入可视化: 比较级和最高级

Ⅳ词嵌入可视化: 词类比任务

Ⅴ词嵌入效果评估: 词相似度任务

Ⅵ词嵌入效果评估: 作为特征用于CRF实体识别

2，PyTorch实现

Ⅰ、对数据进行预处理操作

①导包

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data as tud
from torch.nn.parameter import Parameter
import numpy as np
import random
import math
import pandas as pd
import scipy
import sklearn
from collections import Counter #计算某个单词出现的次数
from sklearn.metrics.pairwise import cosine_similarity

②固定随机初始化参数

为了保证实验结果的可复性，把所有的seed都固定下来，每次训练的结果就会一致
模型的随机初始化会对模型有一定的影响，每次跑出来的结果都不一样，为了让模型实验结果尽量保持一致，把seed都变成一个固定的值即可，每次随机初始化的结果都是一样的，结果就可以复现了

USE_CUDA = torch.cuda.is_available()# 为了保证实验结果可以复现，我们经常会把各种random seed固定在某一个值
random.seed(53113)
np.random.seed(53113)
torch.manual_seed(53113)
if USE_CUDA:torch.cuda.manual_seed(53113)

③设定超参数

C=3，定义周围3个单词算周围词
K=100，没出现一个正确的周围词，就会伴随着出现100个非周围词
NUM_EPOCHS=2，训练多少次epoch
MAX_VOCAB_SIZE=30000，最终一共有多少个单词，词汇表有多大，这里训练三万个最常见的单词的词向量
BATCH_SIZE=128，每128个词为一组进行训练
LEARNING_RATE=0.2，学习率设置为0.2

# 设定一些超参数K = 100 # number of negative samples
C = 3 # nearby words threshold
NUM_EPOCHS = 2 # The number of epochs of training
MAX_VOCAB_SIZE = 30000 # the vocabulary size
BATCH_SIZE = 128 # the batch size
LEARNING_RATE = 0.2 # the initial learning rate
EMBEDDING_SIZE = 100

④定义分割单词函数

把一篇文本转化成一个个单词

def word_tokenize(text):return text.split()

⑤训练词向量

训练所需数据集下载
我这里放到了项目所在当前目录下了

with open("./text8.train.txt", "r") as fin:text = fin.read()# 测试一下
text[:500] # 看下训练集都是啥内容，一堆文章里面的东西，没有标点符号
text[:500].split() # 拿到一个个单词

从文本文件中读取所有的文字，通过这些文本创建一个vocabulary
由于单词数量可能太大，只选取最常见的MAX_VOCAB_SIZE个单词
添加一个UNK单词表示所有不常见的单词
text = text.split()，得到一个一个分割之后的单词
vocab = dict(Counter(text).most_common(MAX_VOCAB_SIZE - 1))，其中Counter(text)把text中的单词全部给数一遍，每一个单词究竟出现了多少次，统计最频繁出现的MAX_VOCAB_SIZE - 1这些词给取出来，通过.most_common来实现。减一操作是因为要留取UNK不常用的单词数量位置信息。dict()最后变成字典形式。
vocab[""] = len(text) - np.sum(list(vocab.values()))留一个位置给UNK不常用的单词数量位置信息。vocab.values()表示单词出现的次数，求和之后再减掉就大概是UNK不常用的单词出现的频率

text = text.split()
vocab = dict(Counter(text).most_common(MAX_VOCAB_SIZE-1))
vocab[""] = len(text) - np.sum(list(vocab.values()))
vovab # 查看下在训练数据中所获取的每个单词所出现的次数，就可以构建词汇表

idx_to_word = [word for word in vocab.keys()] ，把这个list中所有单词表中的单词给取下来
word_to_idx = {word:i for i, word in enumerate(idx_to_word)}，出现的次数和单词交换位置

idx_to_word = [word for word in vocab.keys()] 
word_to_idx = {word:i for i, word in enumerate(idx_to_word)}idx_to_word 
"""
['the','of','and',...]
"""
list(word_to_idx.items())
"""
[('the', 0),('of', 1),('and', 2),('one', 3),('in', 4),...]
"""

word_counts = np.array([count for count in vocab.values()], dtype=np.float32)，其中vocab.values()是每个单词的出现次数，最终获得每个单词出现的次数
word_freqs = word_counts / np.sum(word_counts)，每个单词出现的次数除以所有的单词出现的次数，可以得到每个单词出现的频率
word_freqs = word_freqs ** (3./4.)，因为Negative Sampling所在论文中提到了把概率提到原来的3/4次方，效果会更好些。
word_freqs = word_freqs / np.sum(word_freqs) ，因为概率发生了改变，故需要再次计算一下频率，相同的操作即可
VOCAB_SIZE = len(idx_to_word)，需要再次更新一下VOCAB_SIZE ，以防万一训练数据中和预处理之前定义的30000个单词不一致

word_counts = np.array([count for count in vocab.values()], dtype=np.float32)
word_freqs = word_counts / np.sum(word_counts)
word_freqs = word_freqs ** (3./4.)
word_freqs = word_freqs / np.sum(word_freqs) # 用来做 negative sampling
VOCAB_SIZE = len(idx_to_word)
VOCAB_SIZE

Ⅱ、实现Dataloader

把所有text编码成数字，然后用subsampling预处理这些文字。
保存vocabulary，单词count，normalized word frequency
每个iteration sample一个中心词
根据当前的中心词返回context单词
根据中心词sample一些negative单词
返回单词的counts

二、Skip-thought模型