|
|
|
|
|
import torch |
|
|
import torch.nn as nn |
|
|
import torch.nn.functional as F |
|
|
import numpy as np |
|
|
|
|
|
|
|
|
class Config(object): |
|
|
"""配置参数""" |
|
|
def __init__(self, dataset_path, embedding='random'): |
|
|
self.model_name = 'TextCNN' |
|
|
self.train_path = dataset_path + '/train.txt' |
|
|
self.dev_path = dataset_path + '/dev.txt' |
|
|
self.test_path = dataset_path + '/test.txt' |
|
|
self.class_list = [x.strip() for x in open( |
|
|
dataset_path + '/class.txt', encoding='utf-8').readlines()] |
|
|
self.vocab_path = dataset_path + '/vocab.pkl' |
|
|
|
|
|
|
|
|
if embedding != 'random': |
|
|
self.embedding_pretrained = torch.tensor( |
|
|
np.load(dataset_path + '/' + embedding)["embeddings"].astype('float32')) |
|
|
else: |
|
|
self.embedding_pretrained = None |
|
|
|
|
|
self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') |
|
|
|
|
|
|
|
|
self.dropout = 0.5 |
|
|
self.require_improvement = 1000 |
|
|
self.num_classes = len(self.class_list) |
|
|
self.n_vocab = 0 |
|
|
self.num_epochs = 20 |
|
|
self.batch_size = 128 |
|
|
self.pad_size = 32 |
|
|
self.learning_rate = 1e-3 |
|
|
self.embed = self.embedding_pretrained.size(1) if self.embedding_pretrained is not None else 300 |
|
|
self.filter_sizes = (2, 3, 4) |
|
|
self.num_filters = 256 |
|
|
|
|
|
|
|
|
class TextCNN(nn.Module): |
|
|
"""TextCNN模型""" |
|
|
def __init__(self, config): |
|
|
super(TextCNN, self).__init__() |
|
|
if config.embedding_pretrained is not None: |
|
|
self.embedding = nn.Embedding.from_pretrained(config.embedding_pretrained, freeze=False) |
|
|
else: |
|
|
self.embedding = nn.Embedding(config.n_vocab, config.embed, padding_idx=config.n_vocab - 1) |
|
|
|
|
|
self.convs = nn.ModuleList( |
|
|
[nn.Conv2d(1, config.num_filters, (k, config.embed)) for k in config.filter_sizes]) |
|
|
self.dropout = nn.Dropout(config.dropout) |
|
|
self.fc = nn.Linear(config.num_filters * len(config.filter_sizes), config.num_classes) |
|
|
|
|
|
def conv_and_pool(self, x, conv): |
|
|
x = F.relu(conv(x)).squeeze(3) |
|
|
x = F.max_pool1d(x, x.size(2)).squeeze(2) |
|
|
return x |
|
|
|
|
|
def forward(self, x): |
|
|
out = self.embedding(x[0]) |
|
|
out = out.unsqueeze(1) |
|
|
out = torch.cat([self.conv_and_pool(out, conv) for conv in self.convs], 1) |
|
|
features = self.dropout(out) |
|
|
out = self.fc(features) |
|
|
return out, features |
|
|
|
|
|
def feature(self, x): |
|
|
""" |
|
|
提取中间层特征向量，用于可视化 |
|
|
返回dropout层的输出（最终层前面的那一层） |
|
|
""" |
|
|
with torch.no_grad(): |
|
|
out = self.embedding(x[0]) |
|
|
out = out.unsqueeze(1) |
|
|
out = torch.cat([self.conv_and_pool(out, conv) for conv in self.convs], 1) |
|
|
features = self.dropout(out) |
|
|
return features.cpu().numpy() |
|
|
|
|
|
def get_prediction(self, x): |
|
|
""" |
|
|
获取模型最终层的输出向量（logits） |
|
|
返回未经softmax的原始输出 |
|
|
""" |
|
|
with torch.no_grad(): |
|
|
out = self.embedding(x[0]) |
|
|
out = out.unsqueeze(1) |
|
|
out = torch.cat([self.conv_and_pool(out, conv) for conv in self.convs], 1) |
|
|
features = self.dropout(out) |
|
|
predictions = self.fc(features) |
|
|
return predictions.cpu().numpy() |
|
|
|
|
|
def prediction(self, features_vector): |
|
|
""" |
|
|
根据中间特征向量预测结果 |
|
|
features_vector: 与feature函数输出形状一致的向量 |
|
|
返回预测类别 |
|
|
""" |
|
|
with torch.no_grad(): |
|
|
if isinstance(features_vector, np.ndarray): |
|
|
features_vector = torch.tensor(features_vector, dtype=torch.float32).to(self.fc.weight.device) |
|
|
|
|
|
|
|
|
if len(features_vector.shape) == 1: |
|
|
features_vector = features_vector.unsqueeze(0) |
|
|
|
|
|
predictions = self.fc(features_vector) |
|
|
predicted_classes = torch.argmax(predictions, dim=1) |
|
|
return predicted_classes.cpu().numpy() |
|
|
|
