用numpy实现一个简单的多层感知机

最近在搞神经网络，不使用pytorch或是tensorflow等框架自己实现一个多层感知机，所需要的numpy函数一览，最后附上自己实现的多层感知机代码。

import numpy as np

1、np.random.randn()

np.random.randn(d0,d1,…,dn)

• randn 函数返回一个或一组样本，具有标准正态分布。
• dn 表格每个维度
• 返回值为指定维度的array

np.random.randn(2,1)

array([[-0.18537434],
       [ 0.53162893]])

2、np.dot()

np.dot(m1,m2)==m1.dot(m2)

• 返回矩阵m1和m2的积 (遵循矩阵乘法规则)
• 一维数组返回内积

a=np.random.randn(2,1)
b=np.random.randn(1,3)
c=np.dot(a,b)
print("a:{},\nb:{},\nc:{}".format(a,b,c))

a:[[-0.57178023]
 [-0.3703979 ]],
b:[[0.95765202 0.41837473 2.41371689]],
c:[[-0.54756649 -0.2392184  -1.38011559]
 [-0.3547123  -0.15496512 -0.89403567]]

3、np.multiply()

np.multiply(m1,m2)

• 返回一个与m1，m2大小一致的矩阵，该矩阵么一个元素为m1和m2对应位置元素相乘（m1和m2大小应该相等）

np.multiply([[1,2],[1,2]],[[1,3],[1,3]])

[[1,6],[1,6]]

4、np.sum()

np.sum(a,axis=None,keepdims=np._NoValue)

• a 要进行加和的矩阵

• axis

• 缺省None 将矩阵所有元素相加得到一个和
• axis=0/-2将每一列的元素相加，将矩阵压缩为一行
• axis=1/-1 将每一行的元素相加，将矩阵压缩为一列（第二个维度输出）
• axis=(x,y) ，以axis=x和axis=y情况下得到的一个和
• 如果设置keepdims=True，那么被删去的维度在结果中置一

a=[[0,2],[1,3]]
np.sum(a,axis=0)
np.sum(a,axis=1)
np.sum(a,axis=(1,0))

[1,5]
[2,4]
6

5、np.power()

np.power(x1,x2)

• 数组的元素分别求n次方，x2可以是数字（求x1中每个元素的x2次方），也可以是数组，列数要与x1相同

a=[[0,2],[2,3]]
b=[[1,2],[2,2]]
print(np.power(a,3))
print(np.power(a,b))

[[ 0  8]
 [ 8 27]]
 
[[0 4]
 [4 9]]

5、np.squeeze()

np.squeeze(a,axis=None)

从数组的形状中删除单维度条目，即把shape中为1的维度去掉
利用matplotlib库函数画图时，可以正常的显示结果

• a表示输入的数组；
• axis用于指定需要删除的维度，但是指定的维度必须为单维度，否则将会报错；
• axis的取值可为None 或 int 或 tuple of ints, 可选。若axis为空，则删除所有单维度的条目；
• 返回值：数组
• 不会修改原数组；

import numpy as np
import random
#全连接层
class linearlayer:
    def __init__(self,i_d,o_d):
        self.w=np.random.randn(i_d,o_d)
        self.b=np.random.randn(1,o_d)
        self.grad_w=np.zeros((i_d,o_d))
        self.grad_b=np.zeros((1,o_d))
        
    def forward(self,x):
        return np.dot(x,self.w)+self.b
    
    def backprop(self,x,grad):
        self.grad_w=np.dot(x.T,grad)
        self.grad_b=np.dot(grad.T,np.ones(x.shape[0]))
        return np.dot(grad,self.w.T)
    
    def update(self,lr):
        self.w=self.w-self.grad_w*lr
        self.b=self.b-self.grad_b*lr
#隐层        
class sigmoid:
    def __init__(self):
        pass
    
    def forward(self,x):
        return 1/(1+np.exp(-x))
    
    def backprop(self,x,grad):
        g=1/(1+np.exp(-x))
        return g*(1-g)*grad


def MSEloss(x,y):
    return np.linalg.norm(x-y)**2

def predict(model,x):
    temp=x
    for layer in model:
        temp=layer.forward(temp)
    return np.where(temp>=0.5,1,0)

train_x=np.array([[0,0],[0,1],[1,0],[1,1]])
train_y=np.array([0,1,1,0])
epoch=10000
learning_rate=0.01

linear1=linearlayer(2,3)
sigmoid=sigmoid()
linear2=linearlayer(3,1)

for i in range(epoch):
    z0=train_x
    a1=linear1.forward(z0)
    z1=sigmoid.forward(a1)
    a2=linear2.forward(z1)
    z2=a2
    
    y=z2.reshape(z2.shape[0])
    loss=MSEloss(train_y,y)
    
    grad=(y-train_y).reshape(y.shape[0],1)
    grad=linear2.backprop(z1,grad)
    grad=sigmoid.backprop(a1,grad)
    grad=linear1.backprop(z0,grad)
    
    linear1.update(learning_rate)
    linear2.update(learning_rate)
    
    if i%2000==0:
        print("已完成{}次迭代，目前测试误差为：{:6f}".format(i,loss))
        
model=[linear1,sigmoid,linear2]

x=np.array([[0,0],[0,1],[1,0],[1,1]])
result=predict(model,x)
num=random.randint(0,3)
print("预测数据",x[num])
print("预测结果",result[num])