细粒度情感分析pytorch

细粒度情感分析（Fine-grained Sentiment Analysis）是指将文本的情感进行更细致的划分，而不仅仅是分为正面、负面和中性三类。PyTorch是一个深度学习框架，可以用于构建和训练情感分析模型。下面是一个基于PyTorch的细粒度情感分析的简单示例代码：

首先，我们需要准备数据集。可以使用一些带有情感标签的文本数据集，如IMDB电影评论数据集。

import torch
import torch.nn as nn
import torch.optim as optim
from torchtext.legacy import data
from torchtext.legacy import datasets

# 定义处理文本的Field对象
TEXT = data.Field(tokenize='spacy', lower=True)
LABEL = data.LabelField(dtype=torch.float)

# 下载和加载IMDB电影评论数据集
train_data, test_data = datasets.IMDB.splits(TEXT, LABEL)

# 构建词汇表
TEXT.build_vocab(train_data, max_size=25000, vectors='glove.6B.100d', unk_init=torch.Tensor.normal_)
LABEL.build_vocab(train_data)

# 创建迭代器
train_iterator, test_iterator = data.BucketIterator.splits((train_data, test_data), batch_size=64)

接下来，我们可以定义一个简单的双向LSTM模型：

class SentimentLSTM(nn.Module):
    def __init__(self, embedding_dim, hidden_dim, output_dim, num_layers, bidirectional, dropout):
        super().__init__()
        self.embedding = nn.Embedding(len(TEXT.vocab), embedding_dim)
        self.lstm = nn.LSTM(embedding_dim, hidden_dim, num_layers=num_layers, bidirectional=bidirectional, dropout=dropout)
        self.fc = nn.Linear(hidden_dim * 2 if bidirectional else hidden_dim, output_dim)
        self.dropout = nn.Dropout(dropout)
        
    def forward(self, text):
        embedded = self.dropout(self.embedding(text))
        output, (hidden, cell) = self.lstm(embedded)
        hidden = self.dropout(torch.cat((hidden[-2,:,:], hidden[-1,:,:]), dim=1))
        return self.fc(hidden.squeeze(0))

然后，我们可以定义训练和评估的函数：

def train(model, iterator, optimizer, criterion):
    model.train()
    
    for batch in iterator:
        optimizer.zero_grad()
        predictions = model(batch.text).squeeze(1)
        loss = criterion(predictions, batch.label)
        loss.backward()
        optimizer.step()

def evaluate(model, iterator, criterion):
    model.eval()
    total_loss = 0
    total_correct = 0
    
    with torch.no_grad():
        for batch in iterator:
            predictions = model(batch.text).squeeze(1)
            loss = criterion(predictions, batch.label)
            total_loss += loss.item()
            predicted_labels = torch.round(torch.sigmoid(predictions))
            total_correct += (predicted_labels == batch.label).sum().item()
    
    return total_loss / len(iterator), total_correct / len(iterator.dataset)

最后，我们可以定义模型的超参数，初始化模型并进行训练和评估：

embedding_dim = 100
hidden_dim = 256
output_dim = 1
num_layers = 2
bidirectional = True
dropout = 0.5

model = SentimentLSTM(embedding_dim, hidden_dim, output_dim, num_layers, bidirectional, dropout)
optimizer = optim.Adam(model.parameters())
criterion = nn.BCEWithLogitsLoss()

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = model.to(device)
criterion = criterion.to(device)

num_epochs = 10

for epoch in range(num_epochs):
    train(model, train_iterator, optimizer, criterion)
    test_loss, test_acc = evaluate(model, test_iterator, criterion)
    print(f'Epoch: {epoch+1}, Test Loss: {test_loss:.4f}, Test Accuracy: {test_acc:.4f}')

这只是一个简单的示例，你可以根据自己的需求对模型进行更进一步的调整和改进。希望对你有帮助！