[自然语言处置惩罚]RNN

1 传统RNN模子与LSTM

2. import torch
3. import torch.nn as nn
5. torch.manual_seed(6)
7. # todo:基础RNN模型
8. def dem01():
9.     '''
10.     参数1：input_size 每个词的词向量维度（输入层神经元的个数）
11.     参数2：hidden_size 隐藏层神经元的个数
12.     参数3：hidden_layer 隐藏层的层数
13.     '''
14.     rnn = nn.RNN(5, 6, 1)
15.     '''
16.     参数1：sequence_length 每个样本的句子长度
17.     参数2：batch_size 每个批次的样本数量
18.     参数3：input_size 每个词的词向量维度（输入层神经元的个数）
19.     '''
20.     input = torch.randn(1, 3, 5)
21.     '''
22.     参数1：hidden_layer 隐藏层的层数
23.     参数2：batch_size 每个批次的样本数量
24.     参数3：hidden_size 隐藏层神经元的个数
25.     '''
26.     h0 = torch.randn(1, 3, 6)
27.     output, hn = rnn(input, h0)
28.     print(f'output {output}')
29.     print(f'hn {hn}')
30.     print(f'RNN模型 {rnn}')
32. # todo:增加输入的sequence_length
33. def dem02():
34.     '''
35.     参数1：input_size 每个词的词向量维度（输入层神经元的个数）
36.     参数2：hidden_size 隐藏层神经元的个数
37.     参数3：hidden_layer 隐藏层的层数
38.     '''
39.     rnn = nn.RNN(5, 6, 1)
40.     '''
41.     参数1：sequence_length 每个样本的句子长度
42.     参数2：batch_size 每个批次的样本数量
43.     参数3：input_size 每个词的词向量维度（输入层神经元的个数）
44.     '''
45.     input = torch.randn(4, 3, 5)
46.     '''
47.     参数1：hidden_layer 隐藏层的层数
48.     参数2：batch_size 每个批次的样本数量
49.     参数3：hidden_size 隐藏层神经元的个数
50.     '''
51.     h0 = torch.randn(1, 3, 6)
52.     output, hn = rnn(input, h0)
53.     print(f'output {output}')
54.     print(f'hn {hn}')
55.     print(f'RNN模型 {rnn}')
57. # todo:增加隐藏层的个数
58. def dem03():
59.     '''
60.     参数1：input_size 每个词的词向量维度（输入层神经元的个数）
61.     参数2：hidden_size 隐藏层神经元的个数
62.     参数3：hidden_layer 隐藏层的层数
63.     '''
64.     rnn = nn.RNN(5, 6, 2)
65.     '''
66.     参数1：sequence_length 每个样本的句子长度
67.     参数2：batch_size 每个批次的样本数量
68.     参数3：input_size 每个词的词向量维度（输入层神经元的个数）
69.     '''
70.     input = torch.randn(4, 3, 5)
71.     '''
72.     参数1：hidden_layer 隐藏层的层数
73.     参数2：batch_size 每个批次的样本数量
74.     参数3：hidden_size 隐藏层神经元的个数
75.     '''
76.     h0 = torch.randn(2, 3, 6)
77.     output, hn = rnn(input, h0)
78.     print(f'output {output}')
79.     print(f'hn {hn}')
80.     print(f'RNN模型 {rnn}')
82. # todo:一个一个地向模型输入单词-全零初始化
83. def dem04_1():
84.     '''
85.     参数1：input_size 每个词的词向量维度（输入层神经元的个数）
86.     参数2：hidden_size 隐藏层神经元的个数
87.     参数3：hidden_layer 隐藏层的层数
88.     '''
89.     rnn = nn.RNN(5, 6, 1)
90.     '''
91.     参数1：sequence_length 每个样本的句子长度
92.     参数2：batch_size 每个批次的样本数量
93.     参数3：input_size 每个词的词向量维度（输入层神经元的个数）
94.     '''
95.     input = torch.randn(4, 1, 5)
96.     print(f'input {input}')
97.     '''
98.     参数1：hidden_layer 隐藏层的层数
99.     参数2：batch_size 每个批次的样本数量
100.     参数3：hidden_size 隐藏层神经元的个数
101.     '''
102.     # 每个样本一次性输入神经网络
103.     hn = torch.zeros(1, 1, 6)
104.     print(f'hn1 {hn}')
105.     output, hn = rnn(input, hn)
106.     print(f'output1 {output}')
107.     print(f'hn1 {hn}')
108.     print(f'RNN模型1 {rnn}')
109.     print('*' * 80)
110.     # 每个样本逐词送入神经网络
111.     hn = torch.zeros(1, 1, 6)
112.     print(f'hn2 {hn}')
113.     for i in range(4):
114.         tmp = input[i][0]
115.         print(f'tmp.shape {tmp.shape}')
116.         output, hn = rnn(tmp.unsqueeze(0).unsqueeze(0), hn)
117.         print(f'{i}-output {output}')
118.         print(f'{i}-hn {hn}')
120. # todo:一个一个地向模型输入单词-全一初始化
121. def dem04_2():
122.     '''
123.     参数1：input_size 每个词的词向量维度（输入层神经元的个数）
124.     参数2：hidden_size 隐藏层神经元的个数
125.     参数3：hidden_layer 隐藏层的层数
126.     '''
127.     rnn = nn.RNN(5, 6, 1)
128.     '''
129.     参数1：sequence_length 每个样本的句子长度
130.     参数2：batch_size 每个批次的样本数量
131.     参数3：input_size 每个词的词向量维度（输入层神经元的个数）
132.     '''
133.     input = torch.randn(4, 1, 5)
134.     print(f'input {input}')
135.     '''
136.     参数1：hidden_layer 隐藏层的层数
137.     参数2：batch_size 每个批次的样本数量
138.     参数3：hidden_size 隐藏层神经元的个数
139.     '''
140.     # 每个样本一次性输入神经网络
141.     hn = torch.ones(1, 1, 6)
142.     print(f'hn1 {hn}')
143.     output, hn = rnn(input, hn)
144.     print(f'output1 {output}')
145.     print(f'hn1 {hn}')
146.     print(f'RNN模型1 {rnn}')
147.     print('*' * 80)
148.     # 每个样本逐词送入神经网络
149.     hn = torch.ones(1, 1, 6)
150.     print(f'hn2 {hn}')
151.     for i in range(4):
152.         tmp = input[i][0]
153.         print(f'tmp.shape {tmp.shape}')
154.         output, hn = rnn(tmp.unsqueeze(0).unsqueeze(0), hn)
155.         print(f'{i}-output {output}')
156.         print(f'{i}-hn {hn}')
158. # todo:一个一个地向模型输入单词-随机初始化
159. def dem04_3():
160.     '''
161.     参数1：input_size 每个词的词向量维度（输入层神经元的个数）
162.     参数2：hidden_size 隐藏层神经元的个数
163.     参数3：hidden_layer 隐藏层的层数
164.     '''
165.     rnn = nn.RNN(5, 6, 1)
166.     '''
167.     参数1：sequence_length 每个样本的句子长度
168.     参数2：batch_size 每个批次的样本数量
169.     参数3：input_size 每个词的词向量维度（输入层神经元的个数）
170.     '''
171.     input = torch.randn(4, 1, 5)
172.     print(f'input {input}')
173.     '''
174.     参数1：hidden_layer 隐藏层的层数
175.     参数2：batch_size 每个批次的样本数量
176.     参数3：hidden_size 隐藏层神经元的个数
177.     '''
178.     # 每个样本一次性输入神经网络
179.     hn = torch.randn(1, 1, 6)
180.     print(f'hn1 {hn}')
181.     output, hn = rnn(input, hn)
182.     print(f'output1 {output}')
183.     print(f'hn1 {hn}')
184.     print(f'RNN模型1 {rnn}')
185.     print('*' * 80)
186.     # 每个样本逐词送入神经网络
187.     hn = torch.randn(1, 1, 6)
188.     print(f'hn2 {hn}')
189.     for i in range(4):
190.         tmp = input[i][0]
191.         print(f'tmp.shape {tmp.shape}')
192.         output, hn = rnn(tmp.unsqueeze(0).unsqueeze(0), hn)
193.         print(f'{i}-output {output}')
194.         print(f'{i}-hn {hn}')
196. # todo:设置batch_first=True
197. def dem05():
198.     '''
199.     参数1：input_size 每个词的词向量维度（输入层神经元的个数）
200.     参数2：hidden_size 隐藏层神经元的个数
201.     参数3：hidden_layer 隐藏层的层数
202.     '''
203.     rnn = nn.RNN(5, 6, 1, batch_first=True)
204.     '''
205.     参数1：batch_size 每个批次的样本数量
206.     参数2：sequence_length 每个样本的句子长度
207.     参数3：input_size 每个词的词向量维度（输入层神经元的个数）
208.     '''
209.     input = torch.randn(3, 4, 5)
210.     '''
211.     参数1：hidden_layer 隐藏层的层数
212.     参数2：batch_size 每个批次的样本数量
213.     参数3：hidden_size 隐藏层神经元的个数
214.     '''
215.     h0 = torch.randn(1, 3, 6)
216.     output, hn = rnn(input, h0)
217.     print(f'output {output}')
218.     print(f'hn {hn}')
219.     print(f'RNN模型 {rnn}')
221. # todo:基础LSTM模型
222. def dem06_1():
223.     '''
224.     参数1：input_size 每个词的词向量维度（输入层神经元的个数）
225.     参数2：hidden_size 隐藏层神经元的个数
226.     参数3：hidden_layer 隐藏层的层数
227.     '''
228.     rnn = nn.LSTM(5, 6, 2)
229.     '''
230.     参数1：batch_size 每个批次的样本数量
231.     参数2：sequence_length 每个样本的句子长度
232.     参数3：input_size 每个词的词向量维度（输入层神经元的个数）
233.     '''
234.     input = torch.randn(1, 3, 5)
235.     '''
236.     参数1：hidden_layer 隐藏层的层数
237.     参数2：batch_size 每个批次的样本数量
238.     参数3：hidden_size 隐藏层神经元的个数
239.     '''
240.     h0 = torch.randn(2, 3, 6)
241.     '''
242.     参数1：hidden_layer 隐藏层的层数
243.     参数2：batch_size 每个批次的样本数量
244.     参数3：hidden_size 隐藏层神经元的个数
245.     '''
246.     c0 = torch.randn(2, 3, 6)
247.     output, (hn, cn) = rnn(input, (h0, c0))
248.     print(f'output {output}')
249.     print(f'hn {hn}')
250.     print(f'cn {cn}')
252. # todo:双向LSTM模型
253. def dem06_2():
254.     '''
255.     参数1：input_size 每个词的词向量维度（输入层神经元的个数）
256.     参数2：hidden_size 隐藏层神经元的个数
257.     参数3：hidden_layer 隐藏层的层数
258.     '''
259.     rnn = nn.LSTM(5, 6, 2,bidirectional=True)
260.     '''
261.     参数1：batch_size 每个批次的样本数量
262.     参数2：sequence_length 每个样本的句子长度
263.     参数3：input_size 每个词的词向量维度（输入层神经元的个数）
264.     '''
265.     input = torch.randn(1, 3, 5)
266.     '''
267.     参数1：hidden_layer 隐藏层的层数
268.     参数2：batch_size 每个批次的样本数量
269.     参数3：hidden_size 隐藏层神经元的个数
270.     '''
271.     h0 = torch.randn(4, 3, 6)
272.     '''
273.     参数1：hidden_layer 隐藏层的层数
274.     参数2：batch_size 每个批次的样本数量
275.     参数3：hidden_size 隐藏层神经元的个数
276.     '''
277.     c0 = torch.randn(4, 3, 6)
278.     output, (hn, cn) = rnn(input, (h0, c0))
279.     print(f'output {output}')
280.     print(f'hn {hn}')
281.     print(f'cn {cn}')
283. if __name__ == '__main__':
284.     # dem01()
285.     # dem02()
286.     # dem03()
287.     # dem04_1()
288.     # dem04_2()
289.     # dem04_3()
290.     # dem05()
291.     # dem06_1()
292.     dem06_2()

复制代码

2. D:\nlplearning\nlpbase\python.exe D:\nlpcoding\rnncode.py
3. output tensor([[[ 0.0207, -0.1121, -0.0706,  0.1167, -0.3322, -0.0686],
4.          [ 0.1256,  0.1328,  0.2361,  0.2237, -0.0203, -0.2709],
5.          [-0.2668, -0.2721, -0.2168,  0.4734,  0.2420,  0.0349]]],
6.        grad_fn=<MkldnnRnnLayerBackward0>)
7. hn tensor([[[ 0.1501, -0.2106,  0.0213,  0.1309,  0.3074, -0.2038],
8.          [ 0.3639, -0.0394, -0.1912,  0.1282,  0.0369, -0.1094],
9.          [ 0.1217, -0.0517,  0.1884, -0.1100, -0.5018, -0.4512]],
11.         [[ 0.0207, -0.1121, -0.0706,  0.1167, -0.3322, -0.0686],
12.          [ 0.1256,  0.1328,  0.2361,  0.2237, -0.0203, -0.2709],
13.          [-0.2668, -0.2721, -0.2168,  0.4734,  0.2420,  0.0349]]],
14.        grad_fn=<StackBackward0>)
15. cn tensor([[[ 0.2791, -0.7362,  0.0501,  0.2612,  0.4655, -0.2338],
16.          [ 0.7902, -0.0920, -0.4955,  0.3865,  0.0868, -0.1612],
17.          [ 0.2312, -0.3736,  0.4033, -0.1386, -1.0151, -0.5971]],
19.         [[ 0.0441, -0.2279, -0.1483,  0.3397, -0.5597, -0.4339],
20.          [ 0.2154,  0.4119,  0.4723,  0.4731, -0.0284, -1.1095],
21.          [-0.5016, -0.5146, -0.4286,  1.5299,  0.5992,  0.1224]]],
22.        grad_fn=<StackBackward0>)
24. Process finished with exit code 0

复制代码

2 GRU

2. import torch
3. import torch.nn as nn
5. # todo:基础GRU
6. def dem01():
7.     gru = nn.GRU(5, 6, 1)
8.     input = torch.randn(4, 3, 5)
9.     h0 = torch.randn(1, 3, 6)
10.     output, hn = gru(input, h0)
11.     print(f'output {output}')
12.     print(f'hn {hn}')
14. if __name__ == '__main__':
15.     dem01()

复制代码