【自学记录】深度学习进阶：自然语言处理（第一章 神经网络的复习）

1.1 数学和python的复习

今天，终于，借此机会，终于学会用命令行了！学习记录（感谢步老师！！！）
需要注意的点是 np.dot(),当参数是一维数组时，计算向量内积；当参数是二维数组时，计算矩阵乘积。

>>> import numpy as np
>>> x=np.array([1,2,3])
>>> x.__class__#输出类名
<class 'numpy.ndarray'>
>>> x.shape
(3,)
>>> x.ndim
1   
>>> W=np.array([[1,2,3],[4,5,6]])
>>> W.shape
(2, 3)
>>> W.ndim
2
>>> W=np.array([[1,2,3],[4,5,6]])
>>> X=np.array([[0,1,2],[3,4,5]])
>>> W+X
array([[ 1,  3,  5],
       [ 7,  9, 11]])
>>> W*X
array([[ 0,  2,  6],
       [12, 20, 30]])
>>> #广播
>>> A=np.array([[1,2],[3,4]])
>>> A*10
array([[10, 20],
       [30, 40]])
>>> A=np.array([[1,2],[3,4]])
>>> b=np.array([10,20])
>>> A*b
array([[10, 40],
       [30, 80]])
>>> b=np.array([4,5,6])
>>> np.dot(a,b)#当参数是一维数组时，计算向量内积
32
>>> A=np.array([[1,2],[3,4]])
>>> B=np.array([[5,6],[7,8]])
>>> np.dot(A,B)#当参数是二维数组时，计算矩阵乘积
array([[19, 22],
       [43, 50]])
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

1.2 神经网络的推理

1.2.1 神经网络的推理的全貌图

x 的形状是(10, 2)，表示10笔二维数据组织为了1个mini-batch。最终输出的s 的形状是(10, 3)

#Python写出mini-batch版的全连接层变换
def sigmoid(x):
    return 1/(1+np.exp(-x))
import numpy as np
x=np.random.randn(10,2)#输入
W1=np.random.randn(2,4)#权重
b1=np.random.randn(4) #偏置

W2=np.random.randn(4,3)#权重
b2=np.random.randn(3) #偏置

h=np.dot(x,W1)+b1 
a=sigmoid(h)#sigmoid非线性变换
s=np.dot(a,W2)+b2 
1
2
3
4
5
6
7
8
9
10
11
12
13
14

以上就是神经网络的推理部分的实现。 接下来，我们使用Python的类，将这些处理实现为层。

1.2.2 层的类化及正向传播的实现

只考虑正向传播，所以我们仅关注代码规范中的以下两点：一是在层中实现forward() 方法；二是将参数整理到实例变量params 中

#sigmoid层
import numpy as np
class Sigmoid:
    def __init__(self):
        self.params=[]#因为Sigmoid层没有需要学习的参数，所以使用空列表来初始化实例变量params
    def forward(self,x):
        return 1/(1+np.exp(-x))
#Affine层
class Affine:
    def __init__(self,W,b):#Affine层在初始化时接收权重和偏置
        self.params=[W,b]#此时，Affine层的参数是权重和偏置（在神经网络的学习时，这两个参数随时被更新）
    def forward(self,x):
        W,b=self.params#这是个什么语法 列表里只有两个值，所以可以这样取出来吗？[对的！]
        out=np.dot(x,W)+b 
        return out
#输入X经由Affine层、Sigmoid层和Affine层后输出得分S。我们将这个神经网络实现为名为TwoLayerNet 的类，将主推理处理
#实现为predict(x) 方法       
class TwoLayerNet:
    def __init__(self,input_size,hidden_size,output_size):
        I,H,O=input_size,hidden_size,output_size
        #初始化权重和偏置
        W1=np.random.randn(I,H)
        b1=np.random.randn(H)
        W2=np.random.randn(H,O)
        b2=np.random.randn(O)
        #生成层
        self.layers=[
            Affine(W1,b1),
            Sigmoid(),
            Affine(W2,b2)
        ]

        #将所有的权重整理到列表中
        self.params=[] ##类的实例属性
        for layer in self.layers:
            self.params+=layer.params
    def predict(self,x):
        for layer in self.layers:
            x=layer.forward(x)
        return x    
x=np.random.randn(10,2)
model=TwoLayerNet(2,4,3)#实例化一个网络类
s=model.predict(x)
print(s)
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

其中，

for layer in self.layers:
            self.params+=layer.params
1
2

因为各个层的实例变量params 中都保存了学习参数，所以只需要将它们拼接起来即可。这样一来，TwoLayerNet 的params
变量中就保存了所有的学习参数。像这样，通过将参数整理到一个列表中，可以很轻松地进行参数的更新和保存

>>> a=['A','B']
>>> a+=['c','d']
>>> a
['A', 'B', 'c', 'd']
1
2
3
4

此外，Python中可以使用+ 运算符进行列表之间的拼接。下面是一个
简单的例子。

######以上代码保存于my_forward_net.py中 23.11.20