基于GPT2实现考公申论文章生成
近几年来，考公的人数越来越多，而申论作为考公非常重要的一部分，也是另很多人头痛的一部分。很多人在考试之前都会背一些优秀范文或句段，以便在考试时派上用场。这里我用GPT2预训练很多篇申论范文，使之能在某个话题的提示下自动申成一片范文或句段。话不多说，直接上代码。
数据预处理
这里我找了500篇申论范文，不是很多，当然也可以多找点，最好是各类话题都有，越多越好。
造字典
将所有文章中的字，符号提取出来，去重后存入一个txt文档中
代码实现
import os
DIR_PATH = r"novels"
VOCAB_FILE = r"Vocab.txt"
words = set()
x=0
for i, filename in enumerate(os.listdir(DIR_PATH)):
x=x+1
f_path = os.path.join(DIR_PATH, filename)
print(f_path)
with open(f_path, "r+", encoding="utf-8") as f:
w = f.read(1)
while w:
if w == '\n' or w == '\r' or w == ' ':
# words.add('[SEP]')
pass
else:
words.add(w)
w = f.read(1)
print(x)
with open(VOCAB_FILE, "w+", encoding="utf-8") as f:
f.write("[START] [SEQ] [UNK] [PAD] [END] ")
f.write(" ".join(words))
f.flush()
对文章进行编码
利用字典对文章进行编码，如字典中第12个字是“我”，则在原文中的“我”就用数字11代替，然后保存每篇文章的编码。
代码实现：
import os
SRC_DIR = r"novels"
DST_DIR = r"encoded_novels"
VOCAB_FILE = "Vocab.txt"
if not os.path.exists(DST_DIR):
os.makedirs(DST_DIR)
with open(VOCAB_FILE, "r+", encoding="utf-8") as f:
tokens = f.read().split()
count = 0
for i, filename in enumerate(os.listdir(SRC_DIR)):
f_path = os.path.join(SRC_DIR, filename)
print(f_path)
with open(f_path, "r+", encoding="utf-8") as f:
dst = ["0"]
w = f.read(1)
while w:
if w == '\n' or w == '\r' or w == '\t' or ord(w) == 12288:
dst.append("1")
elif w == ' ':
dst.append("3")
else:
try:
dst.append(str(tokens.index(w)))
except:
dst.append("2")
w = f.read(1)
count+=1
with open(os.path.join(DST_DIR, "{}.txt".format(count)), "w+", encoding="utf-8") as df:
df.write(" ".join(dst))
print(count)
网络模型
我搭建的是带多头注意力的GPT模型，由于电脑GPU显存不大，所以头数设的12，模块数设的6，字的维数为768，最多可生成500字
# config文件
block_num = 6
head_num = 12
embed_dim = 768
vocab_num = 3012
pos_num =500
multi=4
stride=1
device = "cuda:0"
import torch
from torch import nn
import config as cfg
class Attention(nn.Module):
def __init__(self, isMask=True):
super().__init__()
self.dk = (cfg.embed_dim // cfg.head_num) ** 0.5
self.isMask = isMask
self.c_attn = nn.Linear(cfg.embed_dim, cfg.embed_dim * 3)
self.attn_drop = nn.Dropout(0.1)
self.resi_drop = nn.Dropout(0.1)
self.c_proj = nn.Linear(cfg.embed_dim, cfg.embed_dim)
if self.isMask:
# self.register_buffer("mask", torch.tril(torch.ones(cfg.pos_num, cfg.pos_num)))
self.mask = torch.tril(torch.ones(cfg.pos_num, cfg.pos_num)).cuda()
def forward(self, x):
x = self.c_attn(x) # x形状(N,S,V)，N代表多少个句子，S代表多少个词，V代表每个词的维度
x = x.reshape(*x.shape[:-1], cfg.head_num, -1) # (N,S,V)——>(N,S,12,768/12*3)
x = x.transpose(-2, -3) # (N,S,12,768/12*3)——>(N,12,,S,768/12*3)
q, k, v = x.chunk(3, dim=-1)
w = (q @ k.transpose(-1, -2)) / self.dk # (N,12,S,64)@(N,12,64,S)=(N,12,S,S)
# if self.isMask:
# mask=(self.mask if self.isMask else 1)
mask=torch.tril(torch.ones(w.size(-2), w.size(-1))).cuda()
w = w * mask - (1 - mask) * 1e5
w = torch.softmax(w, dim=-1)
w = self.attn_drop(w)
a = w @ v # (N,12,S,S)@(N,12,S,64)-->(N,12,S,64)
a = a.transpose(-2, -3) # (N,12,S,64)-->(N,S,12,64)
a = a.reshape(*a.shape[:-2], cfg.embed_dim) # (N,S,12,64)-->(N,S,768)
h = self.c_proj(a)
h = self.resi_drop(h)
return h
class Block(nn.Module):
def __init__(self, isMask=True):
super().__init__()
self.layer_normal_1 = nn.LayerNorm(cfg.embed_dim)
self.attention = Attention(isMask)
self.layer_normal_2 = nn.LayerNorm(cfg.embed_dim)
self.proj = nn.Sequential(
nn.Linear(cfg.embed_dim, cfg.multi * cfg.embed_dim),
nn.LeakyReLU(),
nn.Linear(cfg.multi * cfg.embed_dim, cfg.embed_dim),
)
self.dropout = nn.Dropout(0.1)
def forward(self, x):
h = self.layer_normal_1(x)
a = self.attention(h)
a = a + x # 加一个残差
a = self.layer_normal_2(a)
h = self.proj(a)
h = self.dropout(h)
y = h + a # 加一个残差
return y
class GPT2(nn.Module):
def __init__(self):
super().__init__()
self.vocab_embed = nn.Embedding(cfg.vocab_num, cfg.embed_dim) # 定义一个字典
self.pos_embed = nn.Embedding(cfg.pos_num, cfg.embed_dim) # 定义一个位置编码
# self.type_embed = nn.Embedding(cfg.type_num, cfg.embed_dim) # 定义一个类型编码
self.blocks = []
for _ in range(cfg.block_num):
self.blocks.append(Block())
self.drop = nn.Dropout(0.1)
self.sequential = nn.Sequential(*self.blocks)
self.output_layer = nn.Linear(cfg.embed_dim, cfg.vocab_num, bias=False)
def forward(self, x, p):
e = self.vocab_embed(x) # 对输入进行词向量编码
p = self.pos_embed(p) # 对输入进行位置编码
# t = self.type_embed(t) # 对输入进行类型编码
h = self.drop(e + p)
h = self.sequential(h)
return self.output_layer(h)
网络训练
生成训练数据
import torch, os
from torch.utils.data import Dataset
import config as cfg
class MyDataset(Dataset):
def __init__(self, dir):
self.dataset = []
for filename in os.listdir(dir):
with open(os.path.join(dir, filename), "r+") as f:
ws = [int(x) for x in f.readline().split()]
ws_len = len(ws)
start = 0
while ws_len - start > cfg.pos_num + 1:
self.dataset.append(ws[start:start + cfg.pos_num + 1])
start += cfg.stride
else:
if ws_len > cfg.pos_num + 1:
self.dataset.append(ws[ws_len - cfg.pos_num - 1:])
def __len__(self):
return len(self.dataset)
def __getitem__(self, index):
data = torch.tensor(self.dataset[index])
return data[0:-1], data[1:]
训练
from module import *
from dataset import *
import torch, os
from torch import optim
from torch.utils.data import DataLoader
from torch.nn import functional as F
# def weight_init(m):
# if isinstance(m, nn.Linear):
# nn.init.xavier_normal_(m.weight)
# if m.bias is not None:
# nn.init.constant_(m.bias, 0)
save_path=r"网络参数"
class Trainer:
def __init__(self):
self.net = GPT2()
self.weight_file = os.path.join(save_path, "gpt2_k.pt")
if os.path.exists(self.weight_file):
self.net.load_state_dict(torch.load(self.weight_file))
# else:
# self.net.apply(weight_init)
self.net.to(torch.device(cfg.device))
self.opt = optim.Adam(self.net.parameters(), lr=0.0001)
def train(self):
myDataset = MyDataset(r"encoded_novels")
print(len(myDataset))
dataloader = DataLoader(myDataset, batch_size=4, shuffle=True)
epoch=0
while True:
epoch=epoch+1
sum_loss = 0
for i, (x, y) in enumerate(dataloader):
x, y = x.to(torch.device(cfg.device)), y.to(torch.device(cfg.device))
p = torch.arange(0, x.shape[1])[None, :].repeat(x.shape[0], 1).to(torch.device(cfg.device))
# print(p)
_y = self.net(x, p).reshape(-1, cfg.vocab_num)
y = y.reshape(-1)
loss = F.cross_entropy(_y, y)
self.opt.zero_grad()
loss.backward()
self.opt.step()
print(loss.cpu().detach().item())
sum_loss += loss.cpu().detach().item()
if i % 1000 == 0 and i > 0:
torch.save(self.net.state_dict(), self.weight_file)
print("第{0}轮训练完毕".format(epoch))
print("轮的平均损失为{0}".format(sum_loss / len(dataloader)))
torch.save(self.net.state_dict(), self.weight_file)
print("参数保存成功")
测试
from module import *
def transer(x): # 索引到字的换算
VOCAB_FILE = "Vocab.txt"
with open(VOCAB_FILE, "r+", encoding="utf-8") as f:
tokens = f.read().split()
y=x[0]
for i in y:
print(tokens[i], end=" ")
def Transfer(str): # 字到索引的换算
VOCAB_FILE = "Vocab.txt"
with open(VOCAB_FILE, "r+", encoding="utf-8") as f:
tokens = f.read().split()
idx=tokens.index(str)
return idx
if __name__ == '__main__':
gpt = GPT2()
gpt.to(torch.device(cfg.device))
gpt.eval()
gpt.load_state_dict(torch.load(r"网络参数\gpt2_k.pt"))
os = []
x = torch.tensor([[Transfer("依"),Transfer("法"),Transfer("治"),Transfer("国")]]).cuda() # 给定一个开始词
p = torch.tensor([[0,1,2,3]]).cuda() # 给定一个起始位置
l=x.size()[1]
for i in range(400):
y = gpt(x, p)
y = y[:, -1:]
v, y = torch.topk(y, 8, dim=-1)
v, y = v.reshape(-1, 8), y.reshape(-1, 8)
v = torch.multinomial(torch.softmax(v, dim=-1), 1)
y = torch.gather(y, -1, v)
x = torch.cat([x, y], dim=1)
p = torch.tensor([range(i + l + 1)]).cuda()
print(transer(x))
比如，输入“人工智能”，则会生成如下片段：
人 工 智 能 ， 网 上 购 物 ， 物 联 网 ， 各 种 新 兴 技 术 层 出 不 穷 ， 各 种 创 新 思 想 不 断 迸 发 ， 国 家 政 策 环 境 需 求 都 为 创 新 提 供 了 丰 富 的 土 壤 ， 这 也 是 最 坏 的 时 代 ， 自 主 品 牌 创 新 能 力 薄 弱 ， 山 寨 产 品 盛 行 ， 核 心 技 术 被 外 方 意 志 很 大 程 度 上 削 减 了 我 国 的 竞 争 力 ， 究 其 原 因 ， 一 方 面 是 企 业 缺 乏 竞 争 意 识 ， 创 新 意 识 目 光 短 浅 所 致 ， 而 另 一 方 面 在 于 人 才 的 流 失 ， 由 于 学 术 界 浮 躁 的 氛 围 ， 以 及 体 制 的 不 完 善 等 ， 许 多 科 研 人 员 面 临 工 资 低 ， 没 有 项 目 的 窘 境 ， 为 了 改 善 环 境 ， 降 低 生 存 压 力 ， 转 而 流 向 其 他 的 领 域 ， 因 此 想 要 中 国 品 牌 走 出 国 门 ， 提 升 竞 争 力 ， 创 新 是 关 键 。 打 造 中 国 品 牌 提 升 国 家 竞 争 力 ， 融 入 民 族 精 神 是 重 点 。 中 国 品 牌 之 所 以 被 称 为 中 国 品 牌 ， 关 键 在 于 其 拥 有 独 特 的 魅 力 ， 不 同 于 其 他 国 家 ， 必 须 有 中 国 的 特 色 ， 必 须 有 中 国 的 文 化 ， 与 文 化 紧 密 结 合 ， 故 宫 博 物 院 的 文 创 产 品 ， 就 是 将 这 一 融 合 发 挥 到 极 致 的 典 范 ， 将 文 物 蕴 含 的 文 化 内 容 融 入 到 产 品 设 计 当 中 ， 设 计 出 具 有 中 国 特 色 的 独 一 无 二 的 文 创 产 品 ， 不 仅 能 够 吸 引 大 量 的 游 客 ， 更 传 承 了 中 国 文 化 之 道 ， 不 仅 打 造 了 品 牌 ， 更 将 这 一 品 牌 销 往 国 外 ， 可 见 ， 打 造 中 国 品 牌 ， 还 必 须 要 将 中 国 文 化 结 合 其 中 ， 方 能 够 让 中 国 品 牌 脱 颖 而 出 ， 与 众 不 同 ， 方 能 体 现 中 国 竞 争 力 。