基于pytorch 预训练的词向量用法详解

1. pytorch预训练的词向量是什么？

在自然语言处理中，词向量是一种将单词或短语表示为向量的技术。pytorch预训练的词向量是一种已经训练好的用于向量化自然语言单词的模型。在pytorch中，可以使用预训练的词向量作为神经网络的输入，这样可以提高神经网络的准确性和效率。

有多种预训练的词向量可供选择，其中比较常用的是Google的Word2Vec和Facebook的FastText。

# 加载pytorch的预训练词向量
import torchtext.vocab as vocab
glove = vocab.GloVe(name='6B', dim=100)

2. pytorch预训练的词向量用途

2.1 词向量的可视化

使用预训练的词向量可以进行词向量的可视化。可以使用PCA或t-SNE降低词向量的维数，并在二维或三维空间中显示单词。

# 可视化单词向量
import matplotlib.pyplot as plt
from sklearn.manifold import TSNE
words = ['book', 'computer', 'love', 'hate', 'happy', 'sad', 
         'new', 'old', 'young', 'death', 'life', 'war', 'peace']
vectors = []
for word in words:
    vectors.append(glove.vectors[glove.stoi[word]])
vectors = torch.stack(vectors)
tsne = TSNE(n_components=2, perplexity=30, learning_rate=200)
vectors_tsne = tsne.fit_transform(vectors)
fig, ax = plt.subplots()
ax.scatter(vectors_tsne[:, 0], vectors_tsne[:, 1])
for i, word in enumerate(words):
    ax.annotate(word, xy=(vectors_tsne[i, 0], vectors_tsne[i, 1]))
plt.show()

上述代码将预训练的词向量可视化到二维平面中。结果如下图所示：

2.2 词向量的应用

预训练的词向量还可以用于自然语言处理任务，如文本分类、情感分析、机器翻译等。

以文本分类为例，我们可以使用预训练的词向量作为神经网络的输入。在神经网络的训练过程中，词向量的权重可以被更新，以便更好地适应数据集。

# 使用预训练的词向量作为神经网络的输入
import torch
import torch.nn as nn
class TextCNN(nn.Module):
    def __init__(self, output_dim, dropout):
        super().__init__()
        self.embedding = nn.Embedding.from_pretrained(glove.vectors)
        self.conv_3 = nn.Conv2d(in_channels=1, out_channels=100, kernel_size=(3, 100))
        self.conv_4 = nn.Conv2d(in_channels=1, out_channels=100, kernel_size=(4, 100))
        self.conv_5 = nn.Conv2d(in_channels=1, out_channels=100, kernel_size=(5, 100))
        self.fc = nn.Linear(300, output_dim)
        self.dropout = nn.Dropout(dropout)
    def forward(self, text):
        embedded = self.embedding(text)
        embedded = embedded.unsqueeze(1)
        conved_3 = nn.functional.relu(self.conv_3(embedded).squeeze(3))
        conved_4 = nn.functional.relu(self.conv_4(embedded).squeeze(3))
        conved_5 = nn.functional.relu(self.conv_5(embedded).squeeze(3))
        pooled_3 = nn.functional.max_pool1d(conved_3, conved_3.shape[2]).squeeze(2)
        pooled_4 = nn.functional.max_pool1d(conved_4, conved_4.shape[2]).squeeze(2)
        pooled_5 = nn.functional.max_pool1d(conved_5, conved_5.shape[2]).squeeze(2)
        cat = self.dropout(torch.cat((pooled_3, pooled_4, pooled_5), dim=1))
        return self.fc(cat)

上述代码定义了一个使用预训练词向量的TextCNN模型。该模型用于文本分类任务，输入是一个长为seq_len的单词序列，输出是不同类别的概率分布。

3. 如何使用pytorch预训练的词向量

3.1 加载预训练的词向量

使用pytorch预训练的词向量，需要先加载词汇表（vocabulary）和预训练向量。可以使用torchtext库的vocab模块来加载预训练的词向量。

# 加载预训练词向量
import torchtext.vocab as vocab
glove = vocab.GloVe(name='6B', dim=100)

上述代码加载了预训练的GloVe向量，维度为100。

3.2 获得单词的向量表示

加载预训练的向量后，可以使用索引或单词来获得相应的向量表示。

word_vector = glove.vectors[glove.stoi['apple']]
print(word_vector)

上述代码输出单词"apple"的向量表示。

3.3 用词向量初始化神经网络

可以使用预训练的词向量来初始化神经网络的嵌入层，使得神经网络直接使用预训练的词向量作为输入。

import torch.nn as nn
class Net(nn.Module):
    def __init__(self, vocab_size, embedding_dim, hidden_dim, output_dim):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, embedding_dim)
        self.embedding.weight.data.copy_(glove.vectors)
        self.embedding.weight.requires_grad = False
        self.rnn = nn.LSTM(embedding_dim, hidden_dim, batch_first=True)
        self.fc = nn.Linear(hidden_dim, output_dim)
    def forward(self, text):
        embedded = self.embedding(text)
        output, (hidden, cell) = self.rnn(embedded)
        return self.fc(hidden[-1])

上述代码定义了一个使用预训练词向量的循环神经网络模型。该模型用于语言模型任务，输入是一个单词序列，输出是每个时间步对应的下一个单词的概率分布。

3.4 freeze embeddings vs. fine-tune embeddings

在使用预训练的词向量时，可以选择冻结（freeze）或微调（fine-tune）词向量。冻结词向量意味着使用预训练词向量，但不更新它们的权重。微调词向量则意味着在模型训练期间更新词向量的权重。

import torch.nn as nn
class Net(nn.Module):
    def __init__(self, vocab_size, embedding_dim, hidden_dim, output_dim):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, embedding_dim)
        self.embedding.weight.data.copy_(glove.vectors)
        self.rnn = nn.LSTM(embedding_dim, hidden_dim, batch_first=True)
        self.fc = nn.Linear(hidden_dim, output_dim)
    def forward(self, text):
        embedded = self.embedding(text)
        output, (hidden, cell) = self.rnn(embedded)
        return self.fc(hidden[-1])

上述代码使用预训练的GloVe词向量来初始化神经网络的嵌入层。因为嵌入层的权重是从预训练的词向量中复制而来的，所以可以将权重的requires_grad属性设置为False，以避免优化器更新权重。

如果需要微调词向量，可以将requires_grad属性设置为True，并在反向传播期间更新权重。

import torch.nn as nn
class Net(nn.Module):
    def __init__(self, vocab_size, embedding_dim, hidden_dim, output_dim):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, embedding_dim)
        self.embedding.weight.data.copy_(glove.vectors)
        self.rnn = nn.LSTM(embedding_dim, hidden_dim, batch_first=True)
        self.fc = nn.Linear(hidden_dim, output_dim)
        self.embedding.weight.requires_grad = True
    def forward(self, text):
        embedded = self.embedding(text)
        output, (hidden, cell) = self.rnn(embedded)
        return self.fc(hidden[-1])

上述代码微调了嵌入层的权重。

4. 总结

本文详细介绍了pytorch预训练的词向量的定义、用途、加载、获取单词向量、初始化神经网络嵌入层及微调词向量等相关知识点。可以使用预训练的词向量进行文本可视化和各种自然语言处理任务。在使用预训练的词向量时，需要注意是否需要冻结或微调它们的权重。