2.使用RNN做诗歌生成

诗歌生成比分类问题要稍微麻烦一些，而且第一次使用RNN做文本方面的问题，还是有很多概念性的东西~~~

数据下载：

链接：https://pan.baidu.com/s/1uCDup7U5rGuIlIb-lnZgjQ
提取码：f436

data.py——数据处理

 import numpy as np
 import os

 def get_data(conf):
     '''
     生成数据
     :param conf: 配置选项,Config对象
     :return: word2ix: 每个字符对应的索引id,如u'月'->100
     :return: ix2word: 每个字符对应的索引id,如100->u'月'
     :return: data: 每一行是一首诗对应的字的索引id
     '''
     if os.path.exists(conf.pickle_path):

         datas = np.load(conf.pickle_path) #np数据文件
         data = datas['data']
         ix2word = datas['ix2word'].item()
         word2ix = datas['word2ix'].item()
         return data, word2ix, ix2word

config.py——配置文件

 class Config(object):
     """Base configuration class.For custom configurations, create a
     sub-class that inherits from this one and override  properties that
     need to changed
     """

     # 模型保存路径前缀(几个epoch后保存)
     model_prefix = 'checkpoints/tang'

     # 模型保存路径
     model_path = 'checkpoints/tang.pth'

     # start words
     start_words = '春江花月夜'

     # 生成诗歌的类型,默认为藏头诗
     p_type = 'acrostic'

     # 训练次数
     max_epech = 200

     # 数据存放的路径
     pickle_path = 'data/tang.npz'

     # mini批大小
     batch_size =128###128

     # dataloader加载数据使用多少进程
     num_workers = 4

     # LSTM的层数
     num_layers = 2

     # 词向量维数
     embedding_dim = 128

     # LSTM隐藏层维度
     hidden_dim = 256

     # 多少个epoch保存一次模型权重和诗
     save_every = 10

     # 训练是生成诗的保存路径
     out_path = 'out'

     # 测试生成诗的保存路径
     out_poetry_path = 'out/poetry.txt'

     # 生成诗的最大长度
     max_gen_len = 200
     use_gpu=True

model.py——模型

 import torch.nn as nn
 import torch
 class PoetryModel(nn.Module):
     def __init__(self, vocab_size, conf, device):
         super(PoetryModel, self).__init__()
         self.num_layers = conf.num_layers
         self.hidden_dim = conf.hidden_dim
         self.device = device
         # 定义词向量层
         self.embeddings = nn.Embedding(vocab_size, conf.embedding_dim)#（词库个数，词向量维度)
         # 定义2层的LSTM，并且batch位于函数参数的第一位
         self.lstm = nn.LSTM(conf.embedding_dim, conf.hidden_dim, num_layers=self.num_layers)
         # 定义全连接层,后接一个softmax进行分类
         self.linear_out = nn.Linear(conf.hidden_dim, vocab_size)

     def forward(self, input, hidden=None):
         '''
         :param input: (seq,batch)
         :return: 模型的结果
         '''
         seq_len, batch_size = input.size()
         embeds = self.embeddings(input) # embeds_size:(seq_len,batch_size,embedding_dim)
         if hidden is None:
             h0 = torch.zeros(self.num_layers, batch_size, self.hidden_dim).to(self.device)
             c0 = torch.zeros(self.num_layers, batch_size, self.hidden_dim).to(self.device)
         else:
             h0, c0 = hidden
         output, hidden = self.lstm(embeds, (h0, c0))#(seq_len,batch_size,隐藏层维度）

         output = self.linear_out(output.view(seq_len * batch_size, -1)) # output_size:(seq_len*batch_size,vocab_size)
         return output, hidden

train.py——训练模型

 import torch
 from torch import nn
 from torch.autograd import Variable
 from torch.optim import Adam
 from torch.utils.data import DataLoader

 from data import get_data
 from model import PoetryModel
 from config import Config
 device=torch.device('cuda:0')
 conf = Config()

 def generate(model, start_words, ix2word, word2ix, prefix_words=None):
     '''
     给定几个词，根据这几个词接着生成一首完整的诗歌
     '''
     print(start_words)
     results = list(start_words)
     start_word_len = len(start_words)
     # 手动设置第一个词为<START>
     # 这个地方有问题，最后需要再看一下
     input = Variable(torch.Tensor([word2ix['<START>']]).view(1, 1).long())
     if conf.use_gpu: input = input.cuda()
     hidden = None

     if prefix_words:
         for word in prefix_words:
             output, hidden = model(input, hidden)
             # 下边这句话是为了把input变成1*1？
             input = Variable(input.data.new([word2ix[word]])).view(1, 1)
     for i in range(conf.max_gen_len):
         output, hidden = model(input, hidden)#input只有一个词，对应的是'<START>'的序号

         if i < start_word_len:
             w = results[i]
             input = Variable(input.data.new([word2ix[w]])).view(1, 1)
         else:
             top_index = output.cpu().data.topk(1)[1][0].numpy()[0]

             w = ix2word[top_index]
             results.append(w)
             input = Variable(input.data.new([top_index])).view(1, 1)
         if w == '<EOP>':
             del results[-1]  # -1的意思是倒数第一个
             break
     return results

 def gen_acrostic(model, start_words, ix2word, word2ix, prefix_words=None):
     '''
     生成藏头诗
     start_words : u'深度学习'
     生成：
     深木通中岳，青苔半日脂。
     度山分地险，逆浪到南巴。
     学道兵犹毒，当时燕不移。
     习根通古岸，开镜出清羸。
     '''
     results = []
     start_word_len = len(start_words)
     input = Variable(torch.Tensor([word2ix['<START>']]).view(1, 1).long())
     if conf.use_gpu: input = input.cuda()
     hidden = None

     index = 0  # 用来指示已经生成了多少句藏头诗
     # 上一个词
     pre_word = '<START>'

     if prefix_words:
         for word in prefix_words:
             output, hidden = model(input, hidden)
             input = Variable(input.data.new([word2ix[word]])).view(1, 1)

     for i in range(conf.max_gen_len):
         output, hidden = model(input, hidden)
         top_index = output.data[0].topk(1)[1][0]
         w = ix2word[top_index]

         if (pre_word in {u'。', u'！', '<START>'}):
             # 如果遇到句号，藏头的词送进去生成

             if index == start_word_len:
                 # 如果生成的诗歌已经包含全部藏头的词，则结束
                 break
             else:
                 # 把藏头的词作为输入送入模型
                 w = start_words[index]
                 index += 1
                 input = Variable(input.data.new([word2ix[w]])).view(1, 1)
         else:
             # 否则的话，把上一次预测是词作为下一个词输入
             input = Variable(input.data.new([word2ix[w]])).view(1, 1)
         results.append(w)
         pre_word = w
     return results

 def train(**kwargs):

     for k, v in kwargs.items():
         setattr(conf, k, v)
     # 获取数据
     data, word2ix, ix2word = get_data(conf)
     # 生成dataload
     dataloader = DataLoader(dataset=data, batch_size=conf.batch_size,
                             shuffle=True,
                             drop_last=True,
                             num_workers=conf.num_workers)
     # 定义模型
     model = PoetryModel(len(word2ix), conf, device).to(device)
     # model.load_state_dict(torch.load(r'C:\Users\ocean\PycharmProjects\guesswhat_pytorch\checkpoints\tang_0.pth'))
     # fout = open('%s/p%d' % (conf.out_path, 1), 'w',encoding='utf-8')
     # # for word in list('春江花月夜'):
     # #     gen_poetry = generate(model, word, ix2word, word2ix)
     # #     fout.write("".join(gen_poetry) + "\n\n")
     # gen_poetry = generate(model, list("北邮真的号"), ix2word, word2ix)
     #
     # fout.write("".join(gen_poetry) + "\n\n")
     # fout.close()
     # torch.save(model.state_dict(), "%s_%d.pth" % (conf.model_prefix, 1))

     # 定义优化器
     optimizer = Adam(model.parameters())
     # 定义损失函数
     criterion = nn.CrossEntropyLoss()
     # 开始训练模型
     for epoch in range(conf.max_epech):
         epoch_loss = 0
         for i, data in enumerate(dataloader):

             data = data.long().transpose(1, 0).contiguous()#(sequence长度，batch_size)

             input, target = data[:-1, :], data[1:, :]
             input, target = input.to(device), target.to(device)
             optimizer.zero_grad()
             output, _ = model(input)

             loss = criterion(output, target.view(-1))

             loss.backward()
             optimizer.step()
             epoch_loss += loss.item()
         print("epoch_%d_loss:%0.4f" % (epoch, epoch_loss / conf.batch_size))
         if epoch % conf.save_every == 0:
             fout = open('%s/p%d' % (conf.out_path, epoch), 'w',encoding='utf-8')
             for word in list('春江花月夜'):
                 gen_poetry = generate(model, word, ix2word, word2ix)
                 fout.write("".join(gen_poetry) + "\n\n")
             fout.close()
             torch.save(model.state_dict(), "%s_%d.pth" % (conf.model_prefix, epoch))

 if __name__ == '__main__':

     train()

最终效果：

春雨，君王背日暮花枝。桂花飘雨裛芙蓉，花蕚垂红绾芙蓉。上天高峨落不归，中有一枝春未老。一枝香蘂红妆结，春风吹花飘落萼。今朝今日凌风沙，今日还家花落早。东风吹落柳条生，柳色参差春水东。昨日风烟花满树，今日东风正如萍。杏园春色不自胜，青春忽倒春风来。春风不哢花枝落，况复春风花满枝。

江上春未央，春光照四面。一日一千里，一朝一瞬息。不如塌然云，不见巢下树。一身一何讬，万事皆有敌。君子不敢横，君心若为役。呜呼两鬓苦，又如寒玉翦。不知何代费，所以心不殒。一朝得之愚，所以心所施。我亦我未领，我来亦未归。始知与君子，不觉身不饥。彭泽有余事，吾君何所为。何以为我人，於今有耆谁。

花间一人家，十五日中见。一朝出门门，不见君子诺。车骑徒自媒，朱绂不能竞。拜军拜车骑，倏忽嫖姚羌。既无征镇愤，慷慨望乡国。一朝辞虏府，暮宿在蓟垒。君子傥封侯，今人在咸朔。英英在其间，日昃不敢作。云山互相见，魏阙空怀戚。何必在沛人，裴回眇眇。所念无穷，斯人不怠。。

月白风来吹，君心不可攀。从来一字内，不觉一朝闲。未达身难弃，衰容事不闲。不忧讥孺子，不觉老农闲。寝食能供给，闲橙媿漉肱。酒阑湘口臥，窗拔峡添灯。静谭畬茶骇，遥闻夜笛闲。芦洲多雨霁，石火带霜蒸。酿酒眠新熟，扁舟醉自闲。夜渔疎竹坞，春水钓渔关。石笋穿云烧，江花带笋斑。此时多好客，不敢问山僧。

夜夜拍人笑，春风弄酒丝。花开桃李岭，花落洞庭春。酒思同君醉，诗成是袜尘。自怜心已矣，何事梦何如。摈世才难易，伤心镜不如。脸如银烛薄，色映玉楼嚬。绣户雕筵软，鸳鸯拂枕春。相逢期洛下，梦想忆扬秦。玉匣调金鼎，金盘染髻巾。鷰人曾有什，山寺不相亲。鹤毳应相毒，蝇蚊爽有真。空余襟袖下，不觉世间人。

参考博客：https://blog.csdn.net/jiangpeng59/article/details/81003058