李宏毅的机器学习作业4
李宏毅的机器学习作业4
- 作业任务
- 数据处理
-
- one-hot
- word-embedding
- word2vec
- 模型构建
-
- 模型原理
- 训练
- 参考
作业所需数据 akti
作业参考答案
作业任务
本次作业是一个文本情感分析，训练文件中的句子被标记为“1”或“0”，分别对应句子的情感色彩是“负面”与“正面”。
我们的任务就是训练出一个模型，从而能对"testing_data.txt"中的句子判断是0还是1。
数据处理
与图像不同，文本在深度学习中的输入方法不是唯一的,因为文本语言是非结构化的，而要将其输入到神经网络中，我们就需要赋予其一定的结构，其中最朴素的思想便是将每一个词作为特征，而基于这种思想有两种方法。
one-hot
第一种称为“独热编码”one-hot，其思想是把出现过的词构建一个词典，每一个词转编成一个一维向量，向量的长度与词典中词的个数一致。每个词在向量中位置不同，它的对应向量就是对应位置为“1”，其余为“0”。例如“我爱人工智能”这一句，一共三个词“我”，“爱”，“人工智能”，如果这三个词组成词典，其对应的独热编码分别就是：
”我“：[1,0,0]
”爱“：[0,1,0]
人工智能"：[0,0,1]
而每句话用独热表示就是把出现的词的对应编码加起来，例如”我爱我“，就是[2,1,0]。
one-hot的思想很简单，实现起来也不难，但是有很多问题，当涉及到的单词很多时，词典会变得超大，动辄几千上万维，而每个样本的特征向量也会变得极其稀疏，对于神经网络来说，这样的数据很不适合用来训练。此外独热编码会忽略词的含义，相同的含义的词语被当作两个词，如”我“和”俺“。
word-embedding
word-embedding，中文叫词向量，也叫词嵌入。实质就是将单词编码成低维实数向量。(专业的说法是将单词映射到一个低维空间，就像一个嵌入的过程，因此叫word-embedding)。词向量的维度一般会控制在几百维以内。词向量能够反映出各个词之间的关系紧密程度，当两个词的关系较紧密，它们的词向量在向量空间上就会很小的夹角。
词向量除了在语义上相近会被编码到邻近的区域，还应该支持简单的语义运算，将语义运算映射为向量运算。比如：
“中国”+“首都”=“北京”；
“王子”-“公主”=“男”-“女“；
word2vec
在本此作业中，要将给定的文本转换成词向量，转换的方法便是使用word2vec。
word2vec又叫word to vector是一个将单词转换成向量形式的工具。其本身是一个简单神经网络，作用是根据输入的上下文来预测的空缺的句子。在训练的过程中，会得到训练的“副产品”——我们的词向量。
参考答案使用了gensim库中的word2vec模型，使用模型直接训练，我们所需要的“词向量”便直接存储在模型中。
下面是对代码的说明
从给定的txt文件中读取数据，把特征与标签取出，存入x和y
def load_training_data(path='training_label.txt'):
# 把training時需要的data讀進來
# 如果是'training_label.txt'，需要讀取label，如果是'training_nolabel.txt'，不需要讀取label
if 'training_label' in path:
with open(path, 'r') as f:
lines = f.readlines()
lines = [line.strip('\n').split(' ') for line in lines]
x = [line[2:] for line in lines]
y = [line[0] for line in lines]
return x, y
else:
with open(path, 'r') as f:
lines = f.readlines()
x = [line.strip('\n').split(' ') for line in lines]
return x
def load_testing_data(path='testing_data'):
# 把testing時需要的data讀進來
with open(path, 'r') as f:
lines = f.readlines()
X = ["".join(line.strip('\n').split(",")[1:]).strip() for line in lines[1:]]
X = [sen.split(' ') for sen in X]
return X
将x输入到word2vec训练，为得到词向量准备。
import os
import numpy as np
import pandas as pd
import argparse
from gensim.models import word2vec
def train_word2vec(x):
# 訓練word to vector 的 word embedding
model = word2vec.Word2Vec(x, size=250, window=5, min_count=5, workers=12, iter=10, sg=1)
return model
if __name__ == "__main__":
print("loading training data ...")
train_x, y = load_training_data('training_label.txt')
train_x_no_label = load_training_data('training_nolabel.txt')
print("loading testing data ...")
test_x = load_testing_data('testing_data.txt')
model = train_word2vec(train_x + train_x_no_label + test_x)
print("saving model ...")
# model.save(os.path.join(path_prefix, 'model/w2v_all.model'))
model.save(os.path.join(path_prefix, 'w2v_all.model'))
从训练好的word2vec模型中提取出词向量
from torch import nn
from gensim.models import Word2Vec
class Preprocess():
def __init__(self, sentences, sen_len, w2v_path="./w2v.model"):
self.w2v_path = w2v_path
self.sentences = sentences
self.sen_len = sen_len
self.idx2word = []
self.word2idx = {}
self.embedding_matrix = []
def get_w2v_model(self):
# 把之前訓練好的word to vec 模型讀進來
self.embedding = Word2Vec.load(self.w2v_path)
self.embedding_dim = self.embedding.vector_size
def add_embedding(self, word):
# 把word加進embedding，並賦予他一個隨機生成的representation vector
# word只會是""或""
vector = torch.empty(1, self.embedding_dim)
torch.nn.init.uniform_(vector)
self.word2idx[word] = len(self.word2idx)
self.idx2word.append(word)
self.embedding_matrix = torch.cat([self.embedding_matrix, vector], 0)
def make_embedding(self, load=True):
print("Get embedding ...")
# 取得訓練好的 Word2vec word embedding
if load:
print("loading word to vec model ...")
self.get_w2v_model()
else:
raise NotImplementedError
# 製作一個 word2idx 的 dictionary
# 製作一個 idx2word 的 list
# 製作一個 word2vector 的 list
for i, word in enumerate(self.embedding.wv.vocab):
print('get words #{}'.format(i+1), end='\r')
#e.g. self.word2index['魯'] = 1
#e.g. self.index2word[1] = '魯'
#e.g. self.vectors[1] = '魯' vector
self.word2idx[word] = len(self.word2idx)
self.idx2word.append(word)
self.embedding_matrix.append(self.embedding[word])
print('')
self.embedding_matrix = torch.tensor(self.embedding_matrix)
# 將""跟""加進embedding裡面
self.add_embedding("" )
self.add_embedding("" )
print("total words: {}".format(len(self.embedding_matrix)))
return self.embedding_matrix
def pad_sequence(self, sentence):
# 將每個句子變成一樣的長度
if len(sentence) > self.sen_len:
sentence = sentence[:self.sen_len]
else:
pad_len = self.sen_len - len(sentence)
for _ in range(pad_len):
sentence.append(self.word2idx["" ])
assert len(sentence) == self.sen_len
return sentence
def sentence_word2idx(self):
# 把句子裡面的字轉成相對應的index
sentence_list = []
for i, sen in enumerate(self.sentences):
print('sentence count #{}'.format(i+1), end='\r')
sentence_idx = []
for word in sen:
if (word in self.word2idx.keys()):
sentence_idx.append(self.word2idx[word])
else:
sentence_idx.append(self.word2idx["" ])
# 將每個句子變成一樣的長度
sentence_idx = self.pad_sequence(sentence_idx)
sentence_list.append(sentence_idx)
return torch.LongTensor(sentence_list)
def labels_to_tensor(self, y):
# 把labels轉成tensor
y = [int(label) for label in y]
return torch.LongTensor(y)
模型构建
数据处理好，接下来就是筹备模型，我们先了解一下 使用的模型LSTM。
模型原理
上图是一个最基本的RNN结构，与一般的CNN相比，它通过不停的将信息循环操作，保证信息持续存在，这样我们就能够学习联系“上下文”，从而训练语音或文本。但这样的网络面对一些“长句子”时，由于它们的语境的信息相聚较远，很难学习。为了解决这个问题，LSTM应运而生。
上图便是LSTM的抽象化结构图，各符号含义如下
上端的线贯穿整个LSTM的核心细胞，保证信息不变的流过整个RNNs。
下端的三个 σ \sigma σ 与“x”(点乘)的组合表示三个“门”,从左到右依次为遗忘门、输入门、输出门。
遗忘门：决定细胞状态 C t − 1 C_{t-1} Ct−1需要丢弃哪些信息。
输入门：决定细胞状态需要更新哪些信息,配合tanh生成的候选细胞 C t ~ \tilde{C_{t}} Ct~,得到新细胞 C t {C_{t}} Ct。
输出门：决定细胞输出特征的判定条件。
以上就是LSTM的基本结构。
参考答案直接调用了使用pytorch内置的nn.LSTM()。
class LSTM_Net(nn.Module):
def __init__(self, embedding, embedding_dim, hidden_dim, num_layers, dropout=0.5, fix_embedding=True):
super(LSTM_Net, self).__init__()
# 製作 embedding layer
self.embedding = torch.nn.Embedding(embedding.size(0),embedding.size(1))
self.embedding.weight = torch.nn.Parameter(embedding)
# 是否將 embedding fix住，如果fix_embedding為False，在訓練過程中，embedding也會跟著被訓練
self.embedding.weight.requires_grad = False if fix_embedding else True
self.embedding_dim = embedding.size(1)
self.hidden_dim = hidden_dim
self.num_layers = num_layers
self.dropout = dropout
self.lstm = nn.LSTM(embedding_dim, hidden_dim, num_layers=num_layers, batch_first=True)
self.classifier = nn.Sequential( nn.Dropout(dropout),
nn.Linear(hidden_dim, 1),
nn.Sigmoid() )
def forward(self, inputs):
inputs = self.embedding(inputs)
x, _ = self.lstm(inputs, None)
# x 的 dimension (batch, seq_len, hidden_size)
# 取用 LSTM 最後一層的 hidden state
x = x[:, -1, :]
x = self.classifier(x)
return x
训练
训练过程如下：
def training(batch_size, n_epoch, lr, model_dir, train, valid, model, device):
total = sum(p.numel() for p in model.parameters())
trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)
print('\nstart training, parameter total:{}, trainable:{}\n'.format(total, trainable))
model.train() # 將model的模式設為train，這樣optimizer就可以更新model的參數
criterion = nn.BCELoss() # 定義損失函數，這裡我們使用binary cross entropy loss
t_batch = len(train)
v_batch = len(valid)
optimizer = optim.Adam(model.parameters(), lr=lr) # 將模型的參數給optimizer，並給予適當的learning rate
total_loss, total_acc, best_acc = 0, 0, 0
for epoch in range(n_epoch):
total_loss, total_acc = 0, 0
# 這段做training
for i, (inputs, labels) in enumerate(train):
inputs = inputs.to(device, dtype=torch.long) # device為"cuda"，將inputs轉成torch.cuda.LongTensor
labels = labels.to(device, dtype=torch.float) # device為"cuda"，將labels轉成torch.cuda.FloatTensor，因為等等要餵進criterion，所以型態要是float
optimizer.zero_grad() # 由於loss.backward()的gradient會累加，所以每次餵完一個batch後需要歸零
outputs = model(inputs) # 將input餵給模型
outputs = outputs.squeeze() # 去掉最外面的dimension，好讓outputs可以餵進criterion()
loss = criterion(outputs, labels) # 計算此時模型的training loss
loss.backward() # 算loss的gradient
optimizer.step() # 更新訓練模型的參數
correct = evaluation(outputs, labels) # 計算此時模型的training accuracy
total_acc += (correct / batch_size)
total_loss += loss.item()
print('[ Epoch{}: {}/{} ] loss:{:.3f} acc:{:.3f} '.format(
epoch+1, i+1, t_batch, loss.item(), correct*100/batch_size), end='\r')
print('\nTrain | Loss:{:.5f} Acc: {:.3f}'.format(total_loss/t_batch, total_acc/t_batch*100))
# 這段做validation
model.eval() # 將model的模式設為eval，這樣model的參數就會固定住
with torch.no_grad():
total_loss, total_acc = 0, 0
for i, (inputs, labels) in enumerate(valid):
inputs = inputs.to(device, dtype=torch.long) # device為"cuda"，將inputs轉成torch.cuda.LongTensor
labels = labels.to(device, dtype=torch.float) # device為"cuda"，將labels轉成torch.cuda.FloatTensor，因為等等要餵進criterion，所以型態要是float
outputs = model(inputs) # 將input餵給模型
outputs = outputs.squeeze() # 去掉最外面的dimension，好讓outputs可以餵進criterion()
loss = criterion(outputs, labels) # 計算此時模型的validation loss
correct = evaluation(outputs, labels) # 計算此時模型的validation accuracy
total_acc += (correct / batch_size)
total_loss += loss.item()
print("Valid | Loss:{:.5f} Acc: {:.3f} ".format(total_loss/v_batch, total_acc/v_batch*100))
if total_acc > best_acc:
# 如果validation的結果優於之前所有的結果，就把當下的模型存下來以備之後做預測時使用
best_acc = total_acc
#torch.save(model, "{}/val_acc_{:.3f}.model".format(model_dir,total_acc/v_batch*100))
torch.save(model, "{}/ckpt.model".format(model_dir))
print('saving model with acc {:.3f}'.format(total_acc/v_batch*100))
print('-----------------------------------------------')
model.train() # 將model的模式設為train，這樣optimizer就可以更新model的參數（因為剛剛轉成eval模式）
代码看似比之前繁杂，但还是按照迭代的思路，所以不复杂，注释已经很详细了。
参考
https://www.jianshu.com/p/95d5c461924c
https://www.jianshu.com/p/471d9bfbd72f