| import jieba
|
| from collections import Counter
|
| import torch
|
| import torch.nn as nn
|
| import torch.optim as optim
|
| import torch.nn.functional as F
|
| from torch.utils.tensorboard import SummaryWriter
|
| class DataProcessor:
|
| def __init__(self, vocab=None, max_len=100):
|
| self.vocab = vocab
|
| self.max_len = max_len
|
|
|
| def tokenize(self, sentence):
|
| return list(jieba.cut(sentence))
|
|
|
| def build_vocab(self, data):
|
| vocab = Counter()
|
| for sentence, label in data:
|
| vocab.update(self.tokenize(sentence))
|
| vocab = {word: idx for idx, (word, _) in enumerate(vocab.most_common(), start=1)}
|
| vocab['<PAD>'] = 0
|
| self.vocab = vocab
|
| return vocab
|
|
|
| def sentence_to_indices(self, sentence):
|
| return [self.vocab.get(word, 0) for word in self.tokenize(sentence)]
|
|
|
| def pad_sequence(self, seq):
|
| if len(seq) < self.max_len:
|
| return seq + [0] * (self.max_len - len(seq))
|
| return seq[:self.max_len]
|
|
|
| def preprocess_data(self, data):
|
| return [(self.pad_sequence(self.sentence_to_indices(sentence)), label) for sentence, label in data]
|
|
|
| def load_data(self, file_path):
|
| data = []
|
| with open(file_path, 'r', encoding='utf-8') as f:
|
| for line in f:
|
| sentence, label = line.strip().split('\t')
|
| data.append((sentence, int(label)))
|
| return data
|
|
|
|
|
| class CNNClassifier(nn.Module):
|
| def __init__(self, vocab_size, embed_size, num_classes):
|
| super(CNNClassifier, self).__init__()
|
| self.embedding = nn.Embedding(vocab_size, embed_size)
|
| self.conv1 = nn.Conv2d(1, 100, (3, embed_size))
|
| self.conv2 = nn.Conv2d(1, 100, (4, embed_size))
|
| self.conv3 = nn.Conv2d(1, 100, (5, embed_size))
|
| self.fc = nn.Linear(300, num_classes)
|
|
|
| def forward(self, x):
|
| x = self.embedding(x).unsqueeze(1)
|
| x1 = F.relu(self.conv1(x)).squeeze(3)
|
| x1 = F.max_pool1d(x1, x1.size(2)).squeeze(2)
|
| x2 = F.tanh(self.conv2(x)).squeeze(3)
|
| x2 = F.max_pool1d(x2, x2.size(2)).squeeze(2)
|
| x3 = F.tanh(self.conv3(x)).squeeze(3)
|
| x3 = F.max_pool1d(x3, x3.size(2)).squeeze(2)
|
| out = torch.cat((x1, x2, x3), 1)
|
| out = self.fc(out)
|
| return out
|
|
|
| def init_train(self, train_data, dev_data, epochs=10, batch_size=64, learning_rate=0.0005, patience=3):
|
| optimizer = optim.Adam(self.parameters(), lr=learning_rate)
|
| criterion = nn.CrossEntropyLoss()
|
|
|
| best_acc = 0
|
| patience_counter = 0
|
| for epoch in range(epochs):
|
| self.train()
|
| total_loss = 0
|
| for i in range(0, len(train_data), batch_size):
|
| batch = train_data[i:i + batch_size]
|
| inputs, labels = zip(*batch)
|
| inputs = torch.LongTensor(inputs)
|
| labels = torch.LongTensor(labels)
|
|
|
| optimizer.zero_grad()
|
| outputs = self(inputs)
|
| loss = criterion(outputs, labels)
|
| loss.backward()
|
| optimizer.step()
|
|
|
| total_loss += loss.item()
|
|
|
| dev_acc = self.evaluate(dev_data)
|
| print(f"Epoch {epoch+1}/{epochs}, Loss: {total_loss:.4f}, Dev Accuracy: {dev_acc:.4f}")
|
|
|
|
|
| if dev_acc > best_acc:
|
| best_acc = dev_acc
|
| patience_counter = 0
|
| else:
|
| patience_counter += 1
|
| if patience_counter >= patience:
|
| print("Early stopping")
|
| break
|
|
|
| def evaluate(self, data):
|
| self.eval()
|
| correct = 0
|
| with torch.no_grad():
|
| for inputs, labels in data:
|
| inputs = torch.LongTensor([inputs])
|
| labels = torch.LongTensor([labels])
|
| outputs = self(inputs)
|
| _, predicted = torch.max(outputs, 1)
|
| correct += (predicted == labels).sum().item()
|
| return correct / len(data)
|
|
|
|
|
| def main():
|
| processor = DataProcessor(max_len=100)
|
|
|
| train_data = processor.load_data('train.txt')
|
| dev_data = processor.load_data('dev.txt')
|
| test_data = processor.load_data('test.txt')
|
|
|
| vocab = processor.build_vocab(train_data)
|
|
|
| train_data = processor.preprocess_data(train_data)
|
| dev_data = processor.preprocess_data(dev_data)
|
| test_data = processor.preprocess_data(test_data)
|
|
|
|
|
| vocab_size = len(vocab)
|
| embed_size = 100
|
| num_classes = 4
|
| model = CNNClassifier(vocab_size, embed_size, num_classes)
|
|
|
| model.init_train(train_data, dev_data, epochs=10, batch_size=64, learning_rate=0.001, patience=3)
|
|
|
| test_acc = model.evaluate(test_data)
|
| print(f"Test Accuracy: {test_acc:.4f}")
|
|
|
|
|
| if __name__ == '__main__':
|
| main()
|
|
|
