【转载】nn.BiLinear功能

101 阅读 0 评论 67 点赞

我是靠谱客的博主欢喜太阳，这篇文章主要介绍【转载】nn.BiLinear功能，现在分享给大家，希望可以做个参考。

本文链接： https://blog.csdn.net/nihate/article/details/90480459

我们都知道在pytorch中的nn.Linear表示线性变换，官方文档给出的数学计算公式是 y = xA^T + b，其中x是输入，A是权值，b是偏置，y是输出，卷积神经网络中的全连接层需要调用nn.Linear就可以实现。而在看pytorch的源码linear.py文件时可以看到里面有Bilinear的定义，起初看到这个名字，大家会以为它是实现对图像做放大的上采样插值，可是在pytorch中有nn.Upsample模块是对图像做上采样的。于是看linear.py文件中对Bilinear的定义，如下图所示

可以看到它的数学计算公式是y = x1 * A * x2 + b，不过里面关于shape的说明，讲的含糊不清。为了弄懂Bilinear的计算过程，我们按照文档给出的例子运行一次nn.Bilinear的计算，然后把两个输入input1和input2，以及weight和bias都转换成numpy.array的形式，然后用numpy函数实现一次Bilinear的计算，把最后的输出结果跟nn.Bilinear的计算输出结果求误差值，代码如下：

复制代码

print(
     
     'learn nn.Bilinear')
    
    
   
   
   
   
    
    
   
   
   
   
    
    
     
     m = nn.Bilinear(
     
     20, 
     
     30, 
     
     40)
    
    
   
   
   
   
    
    
   
   
   
   
    
    
     
     input1 = torch.randn(
     
     128, 
     
     20)
    
    
   
   
   
   
    
    
   
   
   
   
    
    
     
     input2 = torch.randn(
     
     128, 
     
     30)
    
    
   
   
   
   
    
    
   
   
   
   
    
    
     
     output = m(input1, input2)
    
    
   
   
   
   
    
    
   
   
   
   
    
    
     
     print(output.size())
    
    
   
   
   
   
    
    
   
   
   
   
    
    
     
     arr_output = output.
     
     data.cpu().numpy()
    
    
   
   
   
   
    
    
   
   
   
   
    
     
    
    
   
   
   
   
    
    
   
   
   
   
    
    
     
     weight = m.weight.
     
     data.cpu().numpy()
    
    
   
   
   
   
    
    
   
   
   
   
    
    
     
     bias = m.bias.
     
     data.cpu().numpy()
    
    
   
   
   
   
    
    
   
   
   
   
    
    
     
     x1 = input1.
     
     data.cpu().numpy()
    
    
   
   
   
   
    
    
   
   
   
   
    
    
     
     x2 = input2.
     
     data.cpu().numpy()
    
    
   
   
   
   
    
    
   
   
   
   
    
    
     
     print(x1.shape,weight.shape,x2.shape,bias.shape)
    
    
   
   
   
   
    
    
   
   
   
   
    
    
     
     y = np.zeros((x1.shape[
     
     0],weight.shape[
     
     0]))
    
    
   
   
   
   
    
    
   
   
   
   
    
    
     
     for k 
     
     in range(weight.shape[
     
     0]):
    
    
   
   
   
   
    
    
   
   
   
   
    
    
     
         buff = np.dot(x1, weight[k])
    
    
   
   
   
   
    
    
   
   
   
   
    
    
     
         buff = buff * x2
    
    
   
   
   
   
    
    
   
   
   
   
    
    
     
         buff = np.sum(buff,axis=
     
     1)
    
    
   
   
   
   
    
    
   
   
   
   
    
    
     
         y[:,k] = buff
    
    
   
   
   
   
    
    
   
   
   
   
    
    
     
     y += bias
    
    
   
   
   
   
    
    
   
   
   
   
    
    
     
     dif = y - arr_output
    
    
   
   
   
   
    
    
   
   
   
   
    
    
     
     print(np.mean(np.abs(dif.flatten())))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391

 
 
   
   
    
    
   
   
   
   
    
    
     
     print(
     
     'learn nn.Bilinear')
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     m = nn.Bilinear(
     
     20, 
     
     30, 
     
     40)
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     input1 = torch.randn(
     
     128, 
     
     20)
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     input2 = torch.randn(
     
     128, 
     
     30)
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     output = m(input1, input2)
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     print(output.size())
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     arr_output = output.
     
     data.cpu().numpy()
    
    
   
   

   
   
    
    
   
   
   
   
    
     
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     weight = m.weight.
     
     data.cpu().numpy()
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     bias = m.bias.
     
     data.cpu().numpy()
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     x1 = input1.
     
     data.cpu().numpy()
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     x2 = input2.
     
     data.cpu().numpy()
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     print(x1.shape,weight.shape,x2.shape,bias.shape)
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     y = np.zeros((x1.shape[
     
     0],weight.shape[
     
     0]))
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     for k 
     
     in range(weight.shape[
     
     0]):
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         buff = np.dot(x1, weight[k])
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         buff = buff * x2
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         buff = np.sum(buff,axis=
     
     1)
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
         y[:,k] = buff
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     y += bias
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     dif = y - arr_output
    
    
   
   

   
   
    
    
   
   
   
   
    
    
     
     print(np.mean(np.abs(dif.flatten())))

最后的运行结果是：

可以看到我们自己用numpy实现的Bilinear跟调用pytorch的Bilinear的输出结果的误差在小数点后7位，通过编写这个程序，现在可以理解Bilinear的计算过程了。需要注意的是Bilinear的weight是一个3维矩阵，这是跟nn.linear的一个最大区别。

首先，以weight的第0维开始，逐个遍历weight的每一页，当遍历到第k页时，输入x1与weight[k,:,:]做矩阵乘法得到buff，然后buff与输入x2做矩阵点乘得到新的buff，接下来对buff在第1个维度，即按行求和得到新的buff，这时把buff的值赋值给输出y的第k列

遍历完weight的每一页之后，加上偏置项，这时候Bilinear的计算就完成了。为了检验编写的numpy程序是否正确，我们把输出y跟调用pytorch的nn.Bilinear得到的输出output转成numpy形式的arr_output做误差比较。

我们在学习深度学习算法时，需要理解一个深度神经网络里的每种类型的层的计算原理，比如卷积层，池化层，以及在这篇文章里讲到的nn.Bilinear双线性变换层，而不能仅仅只是学会调用一个深度学习框架的接口函数就觉得已经掌握了深度学习算法。为了弄懂神经网络中的一个层的计算原理，比如pytorch框架里的nn.Module和nn.functional模块里的函数，我们可以把张量数据转换成numpy形式的数据，然后用numpy函数实现这个功能，最后把输出结果跟调用pytorch的输出结果做误差比较，这样有利于对深度学习算法的实现原理的理解