实战链接：
https://github.com/ZeweiChu/PyTorch-Course/blob/master/notebooks/4.sentiment.ipynb
⭐️情感分类常用模型DAN。
Word Averaging模型 ，把每个单词都通过Embedding层投射成word embedding vector，然后把一句话中的所有word vector做个平均，就是整个句子的vector表示了。接下来把这个sentence vector传入一个Linear层，通过前向神经网络以及CrossEntropy就可以学习得到一句话的情感态度：正面（Positive）和 负面（Negative）。
如果能将句中单词转换为句向量，则可以更好的表达句子的语义💡。比如将句子带入双向RNN模型（或堆叠RNN）。取出最后一层的隐层向量，可以作为到每个句子的向量。单向RNN的最后一层更多的是距离较近的层的信息，因此双向RNN取出两端的参数求平均是一种更合理的方法。
⭐️下面通过电影评论进行文本分类的实战练习（sentiment）。
- 定义模型（搭建模型的前向传播过程）
- 初始化模型（embedding层设置为预训练的词向量）
- 训练/验证模型
torchText中的一个重要概念是Field。Field决定了你的数据会被怎样处理。在我们的情感分类任务中，我们所需要接触到的数据有文本字符串和两种情感，"pos"或者"neg"。
import torch
from torchtext import data
SEED = 1234
torch.manual_seed(SEED) #为CPU设置随机种子
torch.cuda.manual_seed(SEED)#为GPU设置随机种子
#在程序刚开始加这条语句可以提升一点训练速度，没什么额外开销。
torch.backends.cudnn.deterministic = True
#用来定义字段的处理方法（文本字段，标签字段）
TEXT = data.Field(tokenize='spacy')#torchtext.data.Field :
LABEL = data.LabelField(dtype=torch.float)
#首先，我们要创建两个Field 对象：这两个对象包含了我们打算如何预处理文本数据的信息。
#spaCy:英语分词器,类似于NLTK库，如果没有传递tokenize参数，则默认只是在空格上拆分字符串。
#LabelField是Field类的一个特殊子集，专门用于处理标签。
下面的代码会自动下载IMDb数据集，然后分成train/test两个torchtext.datasets类别。数据被前面的Fields处理。IMDb数据集一共有50000电影评论，每个评论都被标注为正面的或负面的。
from torchtext import datasets
train_data, test_data = datasets.IMDB.splits(TEXT, LABEL)
⭐️查看每个数据split有多少条数据。
print(f'Number of training examples: {len(train_data)}')
print(f'Number of testing examples: {len(test_data)}')
⭐️查看一个example。
print(vars(train_data.examples[0]))
{'text': ['Brilliant', 'adaptation', 'of', 'the', 'novel', 'that', 'made', 'famous', 'the', 'relatives', 'of', 'Chilean'...'.'],'label': 'pos'}
其中"label"告诉我们当前评论的标签。
⭐️再将train数据集划分为train和test。
import random
train_data, valid_data = train_data.split(random_state=random.seed(SEED))
默认的数据分割是 70、30，如果我们声明split_ratio💡，可以改变split之间的比例，split_ratio=0.8表示80%的数据是训练集，20%是验证集。我们还声明random_state这个参数，确保我们每次分割的数据集都是一样的。
当我们把句子传进模型的时候，我们是按照一个个batch穿进去的，也就是说，我们一次传入了好几个句子，而且每个batch中的句子必须是相同的长度。为了确保句子的长度相同，TorchText会把短的句子pad到和最长的句子等长。
⭐️下一步我们需要创建vocabulary。vocabulary就是把每个单词一一映射到一个数字。我们使用最常见的25k个单词来构建我们的单词表，用max_size这个参数可以做到这一点。所有其他的单词都用<unk>来表示。
TEXT.build_vocab(train_data, max_size=25000, vectors="glove.6B.100d",
unk_init=torch.Tensor.normal_)
LABEL.build_vocab(train_data)
词典中应当有25002个单词，且有两个label。可以通过TEXT.vocab和TEXT.label查询。我们可以直接用stoi(stringtoint) 或者itos(inttostring) 来查看我们的单词表。前面的文章中有多次应用。
print(TEXT.vocab.itos[:10])
['<unk>', '<pad>', 'the', ',', '.', 'a', 'and', 'of', 'to', 'is']
print(LABEL.vocab.stoi)
defaultdict(<function _default_unk_index at 0x7fbec39a79d8>, {'neg': 0, 'pos': 1})
⭐️最后一步数据的准备是创建iterators。每个itartion都会返回一个batch的examples。我们会使用BucketIterator。BucketIterator会把长度差不多的句子放到同一个batch中，确保每个batch中不出现太多的padding。这里因为pad比较少，所以把<pad>也当做了模型的输入进行训练。如果我们有GPU，还可以指定每个iteration返回的tensor都在GPU上。
BATCH_SIZE = 64
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
train_iterator, valid_iterator, test_iterator = data.BucketIterator.splits(
(train_data, valid_data, test_data),
batch_size=BATCH_SIZE,
device=device)
3个iterator中各有两个部分：词（.text）和标签（.label）。其中text全部转换为数字了。
⭐️接下来使用Word Averaging模型进行训练。使用<u style="text-decoration: none; border-bottom-width: 1px; border-bottom-style: dashed; border-bottom-color: grey;">[avg_pool2d](https://link.zhihu.com/?target=https%3A//pytorch.org/docs/stable/nn.html%3Fhighlight%3Davg_pool2d%23torch.nn.functional.avg_pool2d)</u>来做average pooling。我们的目标是把sentence length那个维度平均成1，然后保留embedding这个维度avg_pool2d的kernel size是 (embedded.shape[1], 1)，所以句子长度的那个维度会被压扁。
import torch.nn as nn
import torch.nn.functional as F
class WordAVGModel(nn.Module):
def __init__(self, vocab_size, embedding_dim, output_dim, pad_idx):
super().__init__()
self.embedding = nn.Embedding(vocab_size, embedding_dim, padding_idx=pad_idx)
self.fc = nn.Linear(embedding_dim, output_dim)
def forward(self, text):
embedded = self.embedding(text) # [sent_len, batch _size, emb_size]
embedded = embedded.permute(1, 0, 2) # [batch size, sent len, emb dim]
pooled = F.avg_pool2d(embedded, (embedded.shape[1], 1)).squeeze(1) # [batch size, embedding_dim]
return self.fc(pooled)
.squeeze(1)将1维的向量删掉。接下来定义一些参数。
INPUT_DIM = len(TEXT.vocab) #词个数
EMBEDDING_DIM = 100 #词嵌入维度
OUTPUT_DIM = 1 #输出维度
PAD_IDX = TEXT.vocab.stoi[TEXT.pad_token] #pad索引
model = WordAVGModel(INPUT_DIM, EMBEDDING_DIM, OUTPUT_DIM, PAD_IDX)
⭐️定义一个函数，用来监控模型的参数数量。当参数.requires_grad==True的时候说明这些参数是可以被训练的。
def count_parameters(model):
return sum(p.numel() for p in model.parameters() if p.requires_grad)
print(f'The model has {count_parameters(model):,} trainable parameters')
⭐️下面使用预训练过的embedding来替换随机初始化。
pretrained_embeddings = TEXT.vocab.vectors
model.embedding.weight.data.copy_(pretrained_embeddings)
注意一下，.copy_()这种带着下划线的函数，均代表替换（inplace）。
⭐️将未知和pad的embedding设置为0。
UNK_IDX = TEXT.vocab.stoi[TEXT.unk_token]
model.embedding.weight.data[UNK_IDX] = torch.zeros(EMBEDDING_DIM)
model.embedding.weight.data[PAD_IDX] = torch.zeros(EMBEDDING_DIM)
下面开始训练模型。首先定义模型和损失函数。BCEWithLogitsLoss其实就是针对二分类的CrossEntropy，通常在二分类任务中效果更好。他的输出没有经过sigmoid转换，所以需要做一个标准化。
import torch.optim as optim
optimizer = optim.Adam(model.parameters())
criterion = nn.BCEWithLogitsLoss()
model = model.to(device)
criterion = criterion.to(device)
⭐️定义一个函数用于计算准确率。
def binary_accuracy(preds, y):
"""
Returns accuracy per batch, i.e. if you get 8/10 right, this returns 0.8, NOT 8
"""
#round predictions to the closest integer
rounded_preds = torch.round(torch.sigmoid(preds))
correct = (rounded_preds == y).float() #convert into float for division
acc = correct.sum()/len(correct)
return acc
⭐️定义一个训练函数。
def train(model, iterator, optimizer, criterion):
epoch_loss = 0
epoch_acc = 0
total_len = 0
model.train() #model.train()代表了训练模式
#这步一定要加，是为了区分model训练和测试的模式的。
#有时候训练时会用到dropout、归一化等方法，但是测试的时候不能用dropout等方法。
for batch in iterator: #iterator为train_iterator
optimizer.zero_grad() #加这步防止梯度叠加
predictions = model(batch.text).squeeze(1)
#batch.text 就是上面forward函数的参数text
#压缩维度，不然跟batch.label维度对不上
loss = criterion(predictions, batch.label)
acc = binary_accuracy(predictions, batch.label)
loss.backward() #反向传播
optimizer.step() #梯度下降
epoch_loss += loss.item() * len(batch.label)
#loss.item()已经本身除以了len(batch.label)
#所以得再乘一次，得到一个batch的损失，累加得到所有样本损失。
epoch_acc += acc.item() * len(batch.label)
#（acc.item()：一个batch的正确率） *batch数 = 正确数
#train_iterator所有batch的正确数累加。
total_len += len(batch.label)
#计算train_iterator所有样本的数量，不出意外应该是17500
return epoch_loss / total_len, epoch_acc / total_len
#epoch_loss / total_len ：train_iterator所有batch的损失
#epoch_acc / total_len ：train_iterator所有batch的正确率
⭐️再定义一个评估函数。和训练函数高度重合。区别是要吧model.train()改为model.val()，然后不需要反向传播的过程，并在最后重新调整为model.train()。另外中间步骤可以不保存梯度。
def evaluate(model, iterator, criterion):
epoch_loss = 0
epoch_acc = 0
model.eval()
with torch.no_grad():
for batch in iterator:
predictions = model(batch.text).squeeze(1)
loss = criterion(predictions, batch.label)
acc = binary_accuracy(predictions, batch.label)
epoch_loss += loss.item()
epoch_acc += acc.item()
return epoch_loss / len(iterator), epoch_acc / len(iterator)
接下来开始训练并打印模型的表现。内容和之前的文章中几乎一致。
N_EPOCHS = 10
best_valid_loss = float('inf') #无穷大
for epoch in range(N_EPOCHS):
start_time = time.time()
train_loss, train_acc = train(model, train_iterator, optimizer, criterion)
valid_loss, valid_acc = evaluate(model, valid_iterator, criterion)
end_time = time.time()
epoch_mins, epoch_secs = epoch_time(start_time, end_time)
if valid_loss < best_valid_loss: #只要模型效果变好，就存模型
best_valid_loss = valid_loss
torch.save(model.state_dict(), 'wordavg-model.pt')
print(f'Epoch: {epoch+1:02} | Epoch Time: {epoch_mins}m {epoch_secs}s')
print(f'\tTrain Loss: {train_loss:.3f} | Train Acc: {train_acc*100:.2f}%')
print(f'\t Val. Loss: {valid_loss:.3f} | Val. Acc: {valid_acc*100:.2f}%')
⭐️接下来用保存的模型参数预测数据。
model.load_state_dict(torch.load("wordavg-model.pt"))
import spacy #分词工具，跟NLTK类似
nlp = spacy.load('en')
def predict_sentiment(sentence):
tokenized = [tok.text for tok in nlp.tokenizer(sentence)]#分词
indexed = [TEXT.vocab.stoi[t] for t in tokenized]
#sentence的索引
tensor = torch.LongTensor(indexed).to(device) #seq_len
tensor = tensor.unsqueeze(1) #seq_len * batch_size（1）
prediction = torch.sigmoid(model(tensor))
#tensor与text一样的tensor
return prediction.item()
⭐️使用自定义的语句做个实验。
predict_sentiment("I love This film badly ")
注意：
train之前需要model.train()
对于model、data都需要进行to(device)
关于criterion传入参数，第一个参数是模型输出output，是向量，而第二个参数label是groundtruth，是一个标量
当我们需要将模型中变量提取出来参与计算时，需要.item()
网友评论