使用torchtext.vocabVectors()将中文词向量用于情感分析任务

在进行情感分析任务时，可以使用torchtext库中的vocab.Vectors()方法来加载预训练的中文词向量。下面是一个使用例子，包括数据准备、数据处理和模型训练的示例代码。由于篇幅限制，只能提供一个大致的示例，但是提供了主要步骤和代码注释，以帮助你更好地理解和实现。

import torch
import torch.nn as nn
import torch.optim as optim
import torchtext
from torchtext import data
from torchtext.vocab import Vectors

# 设置随机种子以保持结果可复现性
SEED = 1234
torch.manual_seed(SEED)
torch.cuda.manual_seed(SEED)

# 定义数据字段
TEXT = data.Field(tokenize='jieba', include_lengths=True)
LABEL = data.LabelField(dtype=torch.float)

# 加载中文预训练词向量
# vec_path 是预训练词向量的路径，注意vec_path中的词向量文件必须是word2vec格式
vecs = Vectors(name='your_pretrained_word_vectors.vec_path', cache='./vector_cache')

# 加载IMDB情感分析数据集
train_data, test_data = data.TabularDataset.splits(
    path='your_data_path',
    train='train.csv',
    test='test.csv',
    format='csv',
    fields=[('Text', TEXT), ('Label', LABEL)]
)

# 构建词汇表
# 这里使用IMDB情感分析数据集的训练集来建立词汇表，并使用预训练词向量进行初始化
TEXT.build_vocab(
    train_data,
    vectors=vecs,
    unk_init=torch.Tensor.normal_
)
LABEL.build_vocab(train_data)

# 初始化模型、优化器和损失函数
class SentimentAnalysisModel(nn.Module):
    def __init__(self, vocab_size, embedding_dim, hidden_dim, output_dim):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, embedding_dim)
        self.rnn = nn.LSTM(embedding_dim, hidden_dim, num_layers=2, bidirectional=True)
        self.fc = nn.Linear(hidden_dim * 2, output_dim)
        
    def forward(self, text, text_lengths):
        embedded = self.embedding(text)
        packed_embedded = nn.utils.rnn.pack_padded_sequence(embedded, text_lengths.to('cpu'))
        packed_output, (hidden, cell) = self.rnn(packed_embedded)
        output, output_lengths = nn.utils.rnn.pad_packed_sequence(packed_output)
        hidden = torch.cat((hidden[-2,:,:], hidden[-1,:,:]), dim=1)
        return self.fc(hidden.squeeze(0))

# 定义超参数
BATCH_SIZE = 64
EMBEDDING_DIM = 300
HIDDEN_DIM = 256
OUTPUT_DIM = 1
N_EPOCHS = 10

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = SentimentAnalysisModel(len(TEXT.vocab), EMBEDDING_DIM, HIDDEN_DIM, OUTPUT_DIM).to(device)
optimizer = optim.Adam(model.parameters())
criterion = nn.BCEWithLogitsLoss().to(device)

# 创建迭代器，用于加载数据
train_iterator, test_iterator = data.BucketIterator.splits(
    (train_data, test_data),
    batch_size=BATCH_SIZE,
    sort_key=lambda x: len(x.Text),
    sort_within_batch=True,
    device=device
)

# 定义训练与评估函数
def train(model, iterator, optimizer, criterion):
    model.train()
    epoch_loss = 0
    epoch_acc = 0
    for batch in iterator:
        optimizer.zero_grad()
        text, text_lengths = batch.Text
        predictions = model(text, text_lengths).squeeze(1)
        loss = criterion(predictions, batch.Label)
        rounded_preds = torch.round(torch.sigmoid(predictions))
        correct = (rounded_preds == batch.Label).float()
        acc = correct.sum() / len(correct)
        loss.backward()
        optimizer.step()
        epoch_loss += loss.item()
        epoch_acc += acc.item()
    return epoch_loss / len(iterator), epoch_acc / len(iterator)
    
def evaluate(model, iterator, criterion):
    model.eval()
    epoch_loss = 0
    epoch_acc = 0
    with torch.no_grad():
        for batch in iterator:
            text, text_lengths = batch.Text
            predictions = model(text, text_lengths).squeeze(1)
            loss = criterion(predictions, batch.Label)
            rounded_preds = torch.round(torch.sigmoid(predictions))
            correct = (rounded_preds == batch.Label).float()
            acc = correct.sum() / len(correct)
            epoch_loss += loss.item()
            epoch_acc += acc.item()
    return epoch_loss / len(iterator), epoch_acc / len(iterator)

# 训练模型
best_valid_loss = float('inf')
for epoch in range(N_EPOCHS):
    train_loss, train_acc = train(model, train_iterator, optimizer, criterion)
    valid_loss, valid_acc = evaluate(model, test_iterator, criterion)
    if valid_loss < best_valid_loss:
        best_valid_loss = valid_loss
        torch.save(model.state_dict(), 'your_model_path')
    
    print(f'Epoch: {epoch+1:02}/{N_EPOCHS}')
    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}%')

在上面的代码示例中，通过将tokenize参数设置为'jieba'来对中文进行分词。你可以使用其他更适合中文的分词库。Vectors()方法用于加载本地预训练的词向量，其中'name'参数为预训练词向量文件的路径，'cache'参数为下载和缓存路径。TabularDataset()方法用于加载CSV格式的训练集和测试集数据。在构建词汇表时，可以将预训练的词向量作为参数传递给build_vocab()方法，并使用预训练词向量进行初始化。之后，我们定义了一个包含嵌入层、LSTM层和全连接层的模型，并使用Adam优化器和BCEWithLogitsLoss损失函数来训练模型。最后，在训练过程中，我们根据验证集上的loss来保存表现 的模型，并输出每个epoch的训练和验证集上的loss和准确率。

请注意，上面的示例仅为了帮助理解和实现，你仍然需要根据自己的数据和模型进行相应的调整。此外，由于篇幅限制，上述示例代码可能还需要进行一些调整和优化，以满足特定的需求。