TextCNN新闻真假分类-pytorch版本
说明
最近在学习文本分类，记录一些使用TextCNN进行新闻真假分类的过程
一、导入数据
import torch
from torch.utils.data import random_split
import pandas as pd
import numpy as np
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
dataset = pd.read_csv('/home/mw/input/news_data58668156/train_news.csv')
dataset.head()
dataset['label'].value_counts()
样本还是相关均衡的
REAL 2548
FAKE 2520
Name: label, dtype: int64
导入线上验证的测试集
test_dataset = pd.read_csv('/home/mw/input/news_data58668156/test_news.csv')
test_dataset.head()
二、处理文本
处理训练文本
import re
def handle_data(data):
# X = data['text']+data['title']
X = data['text']
y = data['label']
tv_data = []
label = []
for i in range(len(X)):
r = '[’!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~\n。！，]+'
temp = X[i].replace('\n', '')
temp = re.sub(r, '', temp)
# temp = temp.split(' ')
# temp = [temp[i].lower() for i in range(len(temp)) if temp[i] != '']
tv_data.append(temp)
# print(tv_data)
if y[i] == 'REAL':
label.append(0)
elif y[i] == 'FAKE':
label.append(1)
return tv_data,label
X_data,label = handle_data(dataset)
处理线上验证文本
def handle_test_data(data):
# X = data['text']+data['title']
X = data['text']
test_data = []
for i in range(len(X)):
r = '[’!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~\n。！，]+'
temp = X[i].replace('\n', '')
temp = re.sub(r, '', temp)
test_data.append(temp)
return test_data
test_text = handle_test_data(test_dataset)
生成字典
word_list = " ".join(X_data+test_text).split()
word_list = list(set(word_list))
word_dict = {w: i for i, w in enumerate(word_list)}
def transform(sentence, max_len=512):
"""
把句子转换为数字序列
:param sentence:
:param max_len: 句子的最大长度
:return:
"""
if len(sentence) > max_len:
# 句子太长时进行截断
sentence = sentence[:max_len]
else:
# 句子长度不够标准长度时，进行填充
sentence = sentence + [0] * (max_len - len(sentence))
# print(sentence)
return sentence
x_input = [np.asarray(transform([word_dict[n] for n in sen.split()])) for sen in X_data]
三、切分数据
from torch.utils.data import TensorDataset
from torch.utils.data import DataLoader
# train_inputs, train_labels = make_data(X_data)
# train_inputs, train_labels = torch.LongTensor(train_inputs), torch.LongTensor(train_labels)
# x_input = [np.asarray([word_dict[n] for n in sen.split()]) for sen in X_data]
train_inputs = torch.LongTensor(x_input)
train_labels = torch.LongTensor([out for out in label])
# 加载训练数据集
dataset = TensorDataset(train_inputs, train_labels)
train_size = int(len(dataset) * 0.8)
val_size = len(dataset) - train_size
train_dataset, val_dataset = random_split(dataset=dataset,lengths=[train_size,val_size],generator=torch.Generator().manual_seed(2022)) #分割验证和训练集
# # 加载测试数据集
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True,drop_last=False)
val_loader = DataLoader(val_dataset, batch_size=64, shuffle=True,drop_last=False)
四、构建、编译模型
class MyModel(nn.Module):
def __init__(self, vocab_size, embedding_dim, num_filter,
filter_sizes, output_dim, dropout=0.5, pad_idx=0):
super().__init__()
self.embedding = nn.Embedding(vocab_size, embedding_dim)
self.convs = nn.ModuleList([
nn.Conv2d(in_channels=1, out_channels=num_filter,
kernel_size=(fs, embedding_dim))
for fs in filter_sizes
])
# in_channels：输入的channel，文字都是1
# out_channels：输出的channel维度
# fs：每次滑动窗口计算用到几个单词,相当于n-gram中的n
# for fs in filter_sizes用好几个卷积模型最后concate起来看效果。
self.fc = nn.Linear(len(filter_sizes) * num_filter, output_dim)
self.dropout = nn.Dropout(dropout)
def forward(self, text):
embedded = self.dropout(self.embedding(text)) # [batch size, sent len, emb dim]
embedded = embedded.unsqueeze(1) # [batch size, 1, sent len, emb dim]
# 升维是为了和nn.Conv2d的输入维度吻合，把channel列升维。
conved = [F.relu(conv(embedded)).squeeze(3) for conv in self.convs]
# conved = [batch size, num_filter, sent len - filter_sizes+1]
# 有几个filter_sizes就有几个conved
pooled = [F.max_pool1d(conv, conv.shape[2]).squeeze(2) for conv in conved] # [batch,num_filter]
cat = self.dropout(torch.cat(pooled, dim=1))
# cat = [batch size, num_filter * len(filter_sizes)]
# 把 len(filter_sizes)个卷积模型concate起来传到全连接层。
return self.fc(cat)
vocab_size = len(word_dict) # 词典数量
dmodel = 128 # embedding层词向量
num_filter = 10 # 卷积核个数
filter_size = [2, 3, 4] # 卷积核的长，取了三种
output_dim = 2 # 种类
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# device = torch.device("cpu")
model = MyModel(vocab_size+1, dmodel, num_filter=num_filter, filter_sizes=filter_size, output_dim=output_dim).to(device)
# 训练循环
def train(dataloader, model, loss_fn, optimizer):
size = len(dataloader.dataset) # 训练集的大小
num_batches = len(dataloader) # 批次数目, (size/batch_size，向上取整)
train_loss, train_acc = 0, 0 # 初始化训练损失和正确率
for X, y in dataloader: # 获取图片及其标签
X, y = X.to(device), y.to(device)
# 计算预测误差
pred = model(X) # 网络输出
loss = loss_fn(pred, y) # 计算网络输出和真实值之间的差距，targets为真实值，计算二者差值即为损失
# 反向传播
optimizer.zero_grad() # grad属性归零
loss.backward() # 反向传播
optimizer.step() # 每一步自动更新
# 记录acc与loss
train_acc += (pred.argmax(1) == y).type(torch.float).sum().item()
train_loss += loss.item()
train_acc /= size
train_loss /= num_batches
return train_acc, train_loss
def test (dataloader, model, loss_fn):
size = len(dataloader.dataset) # 测试集的大小
num_batches = len(dataloader) # 批次数目, (size/batch_size，向上取整)
test_loss, test_acc = 0, 0
# 当不进行训练时，停止梯度更新，节省计算内存消耗
with torch.no_grad():
for texts, target in dataloader:
texts, target = texts.to(device), target.to(device)
# 计算loss
target_pred = model(texts)
loss = loss_fn(target_pred, target)
test_loss += loss.item()
test_acc += (target_pred.argmax(1) == target).type(torch.float).sum().item()
test_acc /= size
test_loss /= num_batches
return test_acc, test_loss
learn_rate = 1e-2 # 初始学习率
lambda1 = lambda epoch: 0.90 ** (epoch // 2)
optimizer = torch.optim.Adam(model.parameters(), lr=learn_rate)
scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda=lambda1)
import copy
loss_fn = nn.CrossEntropyLoss() # 创建损失函数
epochs = 20
train_loss = []
train_acc = []
test_loss = []
test_acc = []
best_acc = 0 # 设置一个最佳准确率，作为最佳模型的判别指标
for epoch in range(epochs):
# 更新学习率（使用自定义学习率时使用）
# adjust_learning_rate(optimizer, epoch, learn_rate)
model.train()
epoch_train_acc, epoch_train_loss = train(train_loader, model, loss_fn, optimizer)
scheduler.step() # 更新学习率（调用官方动态学习率接口时使用）
model.eval()
epoch_test_acc, epoch_test_loss = test(val_loader, model, loss_fn)
# 保存最佳模型到 best_model
if epoch_test_acc > best_acc:
best_acc = epoch_test_acc
best_model = copy.deepcopy(model)
train_acc.append(epoch_train_acc)
train_loss.append(epoch_train_loss)
test_acc.append(epoch_test_acc)
test_loss.append(epoch_test_loss)
# 获取当前的学习率
lr = optimizer.state_dict()['param_groups'][0]['lr']
template = ('Epoch:{:2d}, Train_acc:{:.1f}%, Train_loss:{:.3f}, Test_acc:{:.1f}%, Test_loss:{:.3f}, Lr:{:.2E}')
print(template.format(epoch+1, epoch_train_acc*100, epoch_train_loss,
epoch_test_acc*100, epoch_test_loss, lr))
# 保存最佳模型到文件中
PATH = './best_model.pth' # 保存的参数文件名
torch.save(model.state_dict(), PATH)
print('Done')
Epoch: 1, Train_acc:53.3%, Train_loss:0.879, Test_acc:55.5%, Test_loss:0.667, Lr:1.00E-02
Epoch: 2, Train_acc:55.6%, Train_loss:0.708, Test_acc:67.3%, Test_loss:0.654, Lr:9.00E-03
Epoch: 3, Train_acc:60.0%, Train_loss:0.669, Test_acc:80.6%, Test_loss:0.498, Lr:9.00E-03
Epoch: 4, Train_acc:68.2%, Train_loss:0.587, Test_acc:79.1%, Test_loss:0.412, Lr:8.10E-03
Epoch: 5, Train_acc:74.7%, Train_loss:0.499, Test_acc:85.8%, Test_loss:0.341, Lr:8.10E-03
Epoch: 6, Train_acc:81.0%, Train_loss:0.418, Test_acc:90.4%, Test_loss:0.248, Lr:7.29E-03
Epoch: 7, Train_acc:85.5%, Train_loss:0.323, Test_acc:92.1%, Test_loss:0.200, Lr:7.29E-03
Epoch: 8, Train_acc:88.6%, Train_loss:0.280, Test_acc:91.3%, Test_loss:0.216, Lr:6.56E-03
Epoch: 9, Train_acc:91.3%, Train_loss:0.218, Test_acc:93.3%, Test_loss:0.172, Lr:6.56E-03
Epoch:10, Train_acc:93.6%, Train_loss:0.173, Test_acc:93.4%, Test_loss:0.173, Lr:5.90E-03
Epoch:11, Train_acc:94.6%, Train_loss:0.149, Test_acc:94.0%, Test_loss:0.160, Lr:5.90E-03
Epoch:12, Train_acc:95.0%, Train_loss:0.132, Test_acc:94.0%, Test_loss:0.161, Lr:5.31E-03
Epoch:13, Train_acc:96.4%, Train_loss:0.101, Test_acc:94.3%, Test_loss:0.164, Lr:5.31E-03
Epoch:14, Train_acc:96.6%, Train_loss:0.094, Test_acc:94.5%, Test_loss:0.162, Lr:4.78E-03
Epoch:15, Train_acc:97.4%, Train_loss:0.081, Test_acc:94.1%, Test_loss:0.169, Lr:4.78E-03
Epoch:16, Train_acc:97.9%, Train_loss:0.061, Test_acc:94.4%, Test_loss:0.179, Lr:4.30E-03
Epoch:17, Train_acc:97.4%, Train_loss:0.076, Test_acc:93.8%, Test_loss:0.178, Lr:4.30E-03
Epoch:18, Train_acc:98.0%, Train_loss:0.056, Test_acc:93.6%, Test_loss:0.187, Lr:3.87E-03
Epoch:19, Train_acc:98.0%, Train_loss:0.070, Test_acc:93.6%, Test_loss:0.183, Lr:3.87E-03
Epoch:20, Train_acc:98.6%, Train_loss:0.046, Test_acc:93.5%, Test_loss:0.188, Lr:3.49E-03
Done
五、训练过程可视化
import matplotlib.pyplot as plt
#隐藏警告
import warnings
warnings.filterwarnings("ignore") #忽略警告信息
plt.rcParams['font.sans-serif'] = ['SimHei'] # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False # 用来正常显示负号
plt.rcParams['figure.dpi'] = 100 #分辨率
epochs_range = range(epochs)
plt.figure(figsize=(12, 3))
plt.subplot(1, 2, 1)
plt.plot(epochs_range, train_acc, label='Training Accuracy')
plt.plot(epochs_range, test_acc, label='Test Accuracy')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')
plt.subplot(1, 2, 2)
plt.plot(epochs_range, train_loss, label='Training Loss')
plt.plot(epochs_range, test_loss, label='Test Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.show()
六、预测
PATH = './best_model.pth'
model.load_state_dict(torch.load(PATH, map_location=device))
test_x = [np.asarray(transform([word_dict[n] for n in sen.split()])) for sen in test_text]
test_inputs = torch.LongTensor(test_x).to(device)
res = []
# # 预测
predict = model(test_inputs).data.max(1, keepdim=True)[1]
for i in range(len(predict)):
if predict[i][0] == 0:
res.append('REAL')
else:
res.append('FAKE')
answer=res
answer=[x.upper() for x in answer]
dic={"id":[str(i) for i in range(len(res))],"answer":answer}
df=pd.DataFrame(dic)
df.to_csv('answer6.csv',index=False, encoding='utf-8-sig')
df