【自然语言处理】RNN文本生成Python(纯Numpy)实现

Dear 丶 2022-05-24 11:58 496阅读 0赞

# 前言 #

Github:[代码下载][Link 1]  
由于RNN具有记忆功能，之前文章有介绍RNN来实现二进制相加，并取得了比较好的效果。那这次本文使用RNN来进行古诗生成。

# 数据集 #

数据集就是我们的古诗了，每行都是一首古诗，并且以格式"题目：古诗"。  
![古诗][70]  
首先需要创建一个词典，词典可以是每个字的词频高的前6000字作为词典，然后用one-hot来表示词向量。

def getVocab(filename='poetry.txt'):
        with open(filename, encoding='utf-8') as f:
            lines = f.readlines()   #读取每一行
            wordFreqDict = dict()   #将每个词都进行词频计算,取词频高的前多少词用来做词典
            for line in lines:  #遍历每一行
                tokens = dict(nltk.FreqDist(list(line)))    #分词，并且计算词频
                wordFreqDict = dict(Counter(wordFreqDict) + Counter(tokens))    #把每个词的词频相加
            wordFreqTuple = sorted(wordFreqDict.items(), key = lambda x: x[1], reverse=True)    #按词频排序，逆排序
            fw = open('vocab.txt','w', encoding='utf-8')    #将词典的每个词（这里是每个字作为一个词）写入到文件
            vocab = wordFreqTuple[:6000]    #词典
            for word in vocab:
                fw.write(word[0] + '\n')

这个函数就是按词频的前6000个字做成词典，并写入到txt文件中，保存。

def loadData(filename = 'poetry.txt'):
        vocab = readVocab() #获取词典，词典是以['词', '典']这样存放的，类似这样
        word2Index = {word: index for index, word in enumerate(vocab)}  #将词典映射成{词:0, 典:1}，类似这样
        fr = open(filename, 'r', encoding='utf-8')  #读取文件，准备数据集
        lines = fr.readlines()  #所有行
        dataSet = list()    #数据集
        labels = list() #标签
        for line in lines:
            poetry = line.split(":")[1].rstrip()  #去除标题
            X = [word2Index.get(word, 0) for word in list(poetry)] #把对应的文字转成索引，形成向量
            y = X.copy()
            X.insert(0, 1)  #1代表是词典里的START，代表开始
            dataSet.append(X)
            y.append(2) #2代表是词典里的END
            labels.append(y)
        return dataSet, labels

这里读取每首古诗的诗，就是去掉标题的部分。比如"临洛水:春蒐驰骏骨，总辔俯长河。霞处流萦锦，风前漾卷罗。水花翻照树，堤兰倒插波。岂必汾阴曲，秋云发棹歌。"，那只要"春蒐驰骏骨，总辔俯长河。霞处流萦锦，风前漾卷罗。水花翻照树，堤兰倒插波。岂必汾阴曲，秋云发棹歌。"，并且转成索引列表，形成词向量\[\]，并且添加首位标志，那么这里可能会产生一个问题，这里的标签是从何而来？其实这里标签也是古诗，不过是词向量加上一个末尾标志。所以最终的数据集和标签集可能长这样。因为我们希望’春’能够通过RNN预测’蒐’，‘蒐’预测’驰’。  
至此，有了数据集和标签，就可以来训练RNN了。

# 算法实现 #

def __init__(self):
            self.wordDim = 6000
            wordDim = self.wordDim
            self.hiddenDim = 100
            hiddenDim = self.hiddenDim
            self.Wih = np.random.uniform(-np.sqrt(1. / wordDim), np.sqrt(1. / wordDim), (hiddenDim, wordDim))  #输入层到隐含层的权重矩阵(100, 6000)
            self.Whh = np.random.uniform(-np.sqrt(1. / self.hiddenDim), np.sqrt(1. / self.hiddenDim), (hiddenDim, hiddenDim))  #隐含层到隐含层的权重矩阵(100, 100)
            self.Why = np.random.uniform(-np.sqrt(1. / self.hiddenDim), np.sqrt(1. / self.hiddenDim), (wordDim, hiddenDim))  #隐含层到输出层的权重矩阵(10, 1)

最开始先初始化词典大小（维度），一集隐含层大小。

## 前向传播 ##

这里先给出前向传播的公式：  
 z t h = W i h x + W h h a t − 1 h a t h = tanh ⁡ ( z t h ) z t k = W h y a t h a t k = s o f t m a x ( z t k ) E = − ∑ t = 1 N y t log ⁡ ( a t k ) \\begin\{array\}\{l\} z\_t^h = \{W\_\{ih\}\}x + \{W\_\{hh\}\}a\_\{ \{\\rm\{t - 1\}\}\}^h\\\\ a\_t^h = \\tanh \\left( \{z\_t^h\} \\right)\\\\ z\_t^k = \{W\_\{hy\}\}a\_t^h\\\\ a\_t^k = \{\\mathop\{\\rm softmax\}\\nolimits\} \\left( \{z\_t^k\} \\right)\\\\ E =- \\sum\\limits\_\{t = 1\}^N \{ \{y\_t\}\\log \\left( \{a\_t^k\} \\right)\} \\end\{array\} zth=Wihx\+Whhat−1hath=tanh(zth)ztk=Whyathatk=softmax(ztk)E=−t=1∑Nytlog(atk)  
相比上一节RNN来做二进制相加的公式来看，可以看到之前的2个sigmoid函数被改成tanh函数和softmax函数了。  
同时损失函数改成了交叉熵。

def forward(self, data):  #前向传播，原则上传入一个数据样本和标签
            T = len(data)
            output = np.zeros((T, self.wordDim, 1)) #输出
            hidden = np.zeros((T+1, self.hiddenDim, 1)) #隐层状态
            for t in range(T): #时间循环
                X = np.zeros((self.wordDim, 1)) #构建(6000,1)的向量
                X[data[t]][0] = 1   #将对应的值置为1，形成词向量
                Zh = np.dot(self.Wih, X) + np.dot(self.Whh, hidden[t-1])   #(100, 1)
                ah = np.tanh(Zh)   #(100, 1)，隐层值
                hidden[t] = ah
                Zk = np.dot(self.Why, ah)   #(6000,1)
                ak = self.softmax(Zk)   #(6000, 1)，输出值
                output[t] = ak #把index写进去
            return hidden, output

## 代码不难懂，跟公式是对应的。   反向传播 ##

反向传播的公式：  
 δ t k = ∂ E ∂ a k ∂ a k ∂ z k = \{ i = j , a j − 1 i = ̸ j , a j δ T h = ∂ E ∂ a T k ∂ a T k ∂ z T k ∂ z T k ∂ a T h ∂ a T h ∂ z T h = ( W h y ) T δ T k × ( 1 − tanh ⁡ 2 ( a t h ) ) δ t h = ∂ E ∂ a t k ∂ a t k ∂ z t k ∂ z t k ∂ a t h ∂ a t h ∂ z t h + ∂ E ∂ a t + 1 k ∂ a t + 1 k ∂ z t + 1 k ∂ z t + 1 k ∂ a t + 1 h ∂ a t + 1 h ∂ z t + 1 h ∂ z t + 1 h ∂ a t h ∂ a t h ∂ z t h = ( ( W h h ) T δ t + 1 h + ( W h y ) T δ t k ) ∂ a t h ∂ z t h = ( ( W h h ) T δ t + 1 h + ( W h y ) T δ t k ) × ( 1 − tanh ⁡ 2 ( a t h ) ) W i h = W i h − η δ t h ( x t ) T W h h = W h h − η δ t h ( a t − 1 h ) T W h y = W h y − η δ t k ( a t h ) T \\begin\{array\}\{l\} \\delta \_t^k = \\frac\{ \{\\partial E\}\}\{ \{\\partial \{a^k\}\}\}\\frac\{ \{\\partial \{a^k\}\}\}\{ \{\\partial \{z^k\}\}\} = \\left\\\{ \\begin\{array\}\{l\} i = j,\{a\_j\} - 1\\\\ i =\\not j,\{a\_j\} \\end\{array\} \\right.\\\\ \\delta \_T^h = \\frac\{ \{\\partial E\}\}\{ \{\\partial a\_T^k\}\}\\frac\{ \{\\partial a\_T^k\}\}\{ \{\\partial z\_T^k\}\}\\frac\{ \{\\partial z\_T^k\}\}\{ \{\\partial a\_\{\\rm\{T\}\}^h\}\}\\frac\{ \{\\partial a\_T^h\}\}\{ \{\\partial z\_\{\\rm\{T\}\}^h\}\} = \{\\left( \{ \{W\_\{hy\}\}\} \\right)^T\}\\delta \_T^k \\times \{\\rm\{(\}\}1 - \{\\tanh ^2\}\\left( \{a\_t^h\} \\right))\\\\ \{\\delta \_t^h = \\frac\{ \{\\partial E\}\}\{ \{\\partial a\_t^k\}\}\\frac\{ \{\\partial a\_t^k\}\}\{ \{\\partial z\_t^k\}\}\\frac\{ \{\\partial z\_t^k\}\}\{ \{\\partial a\_t^h\}\}\\frac\{ \{\\partial a\_t^h\}\}\{ \{\\partial z\_t^h\}\} + \\frac\{ \{\\partial E\}\}\{ \{\\partial a\_\{t + 1\}^k\}\}\\frac\{ \{\\partial a\_\{t + 1\}^k\}\}\{ \{\\partial z\_\{t + 1\}^k\}\}\\frac\{ \{\\partial z\_\{t + 1\}^k\}\}\{ \{\\partial a\_\{t\{\\rm\{ + \}\}1\}^h\}\}\\frac\{ \{\\partial a\_\{t\{\\rm\{ + \}\}1\}^h\}\}\{ \{\\partial z\_\{t + 1\}^h\}\}\\frac\{ \{\\partial z\_\{t + 1\}^h\}\}\{ \{\\partial a\_t^h\}\}\\frac\{ \{\\partial a\_t^h\}\}\{ \{\\partial z\_t^h\}\}\}\\\\ \{\\rm\{ \}\} = \\left( \{ \{ \{\\left( \{ \{W\_\{hh\}\}\} \\right)\}^T\}\\delta \_\{t + 1\}^h + \{ \{\\left( \{ \{W\_\{hy\}\}\} \\right)\}^T\}\\delta \_t^k\} \\right)\\frac\{ \{\\partial a\_t^h\}\}\{ \{\\partial z\_t^h\}\}\\\\ \{\\rm\{ \}\} = \\left( \{ \{ \{\\left( \{ \{W\_\{hh\}\}\} \\right)\}^T\}\\delta \_\{t + 1\}^h + \{ \{\\left( \{ \{W\_\{hy\}\}\} \\right)\}^T\}\\delta \_t^k\} \\right) \\times \\left( \{1 - \\tanh^\{2\} \\left( \{a\_t^h\} \\right)\} \\right)\\\\ \{W\_\{ih\}\} = \{W\_\{ih\}\} - \\eta \\delta \_t^h\{\\left( \{ \{x\_t\}\} \\right)^T\}\\\\ \{W\_\{hh\}\} = \{W\_\{hh\}\} - \\eta \\delta \_t^h\{\\left( \{a\_\{t - 1\}^h\} \\right)^T\}\\\\ \{W\_\{hy\}\} = \{W\_\{hy\}\} - \\eta \\delta \_t^k\{\\left( \{a\_t^h\} \\right)^T\} \\end\{array\} δtk=∂ak∂E∂zk∂ak=\{ i=j,aj−1i≠j,ajδTh=∂aTk∂E∂zTk∂aTk∂aTh∂zTk∂zTh∂aTh=(Why)TδTk×(1−tanh2(ath))δth=∂atk∂E∂ztk∂atk∂ath∂ztk∂zth∂ath\+∂at\+1k∂E∂zt\+1k∂at\+1k∂at\+1h∂zt\+1k∂zt\+1h∂at\+1h∂ath∂zt\+1h∂zth∂ath=((Whh)Tδt\+1h\+(Why)Tδtk)∂zth∂ath=((Whh)Tδt\+1h\+(Why)Tδtk)×(1−tanh2(ath))Wih=Wih−ηδth(xt)TWhh=Whh−ηδth(at−1h)TWhy=Why−ηδtk(ath)T  
这里主要是softmax求导可能会有问题，这里我推荐一个文章，写得很好。[softmax求导][softmax]

def backPropagation(self, data, label, alpha = 0.002):  #反向传播
            hidden, output = self.forward(data)  #(N, 6000)
            T = len(output) #时间长度=词向量的长度
            deltaHPre = np.zeros((self.hiddenDim, 1))   #前一时刻的隐含层偏导
            WihUpdata = np.zeros(self.Wih.shape)    #权重更新值
            WhhUpdata = np.zeros(self.Whh.shape)
            WhyUpdata = np.zeros(self.Why.shape)
            for t in range(T-1, -1, -1):
                X = np.zeros((self.wordDim, 1))  # (6000,1)
                X[data[t]][0] = 1   #构建出词向量
                output[t][label[t]][0] -= 1 #求导后，输出结点的误差跟output只差在i=j时需要把值减去1
                deltaK = output[t].copy()   #输出结点的误差
                deltaH = np.multiply(np.add(np.dot(self.Whh.T, deltaHPre),np.dot(self.Why.T, deltaK)), (1 - (hidden[t] ** 2)))  #隐含层结点误差
                deltaHPre=deltaH.copy()
                WihUpdata += np.dot(deltaH, X.T)
                WhhUpdata += np.dot(deltaH, hidden[t-1].T)
                WhyUpdata += np.dot(deltaK, hidden[t].T)
            self.Wih -= alpha * WihUpdata
            self.Whh -= alpha * WhhUpdata
            self.Why -= alpha * WhyUpdata

最后就是训练了。

def train(self,dataSet, labels):    #训练
            N = len(dataSet)
            for i in range(N):
                if (i % 100 == 0 and i >= 100):
                    self.calcEAll(dataSet[i-100:i], labels[i-100:i])
                self.backPropagation(dataSet[i], labels[i])
            pass

到这里，RNN的核心部分就是如此，这时可以利用RNN来进行文本生成了。

[Link 1]: https://github.com/FlameCharmander/MachineLearning
[70]: /images/20220524/b898299f228c4c6fbd02560fd655c832.png
[softmax]: https://www.jianshu.com/p/ffa51250ba2e