单层感知机_线性神经网络_BP神经网络

单层感知机

单层感知机基础总结很详细的博客

关于单层感知机的视频

 

 最终y=t,说明经过训练预测值和真实值一致。下面图是sign函数

 

 

 根据感知机规则实现的上述题目的代码

import numpy as np
import matplotlib.pyplot as plt
#输入数据
X = np.array([[1,3,3],
              [1,4,3],
              [1,1,1],
              [1,0,2]])
#标签
Y = np.array([[1],
              [1],
              [-1],
              [-1]])
#权值初始化，3行1列，取值范围-1到1
W = (np.random.random([3,1])-0.5)*2
print(W)
#学习率设置
lr = 0.11
#神经网络输出
O = 0

def update():
    global X,Y,W,lr
    O = np.sign(np.dot(X,W))
    W_C = lr*(X.T.dot(Y-O))/int(X.shape[0])#除于样本个数目的是分子计算的误差是所有样本误差之和，所以要进行平均
    W = W + W_C
for i in range(100):
    update()#更新权值
    print(W)
    print(i)
    O = np.sign(np.dot(X,W))
    if(O == Y).all():
        print('finished')
        print('epoch:',i)
        break
#正样本
x1 = [3,4]
y1 = [3,3]
    #负样本
x2 = [1,0]
y2 = [1,2]

    #计算分界线的斜率以及截距
k = -W[1]/W[2]
d = -W[0]/W[2]
print('k=',k)
print('d=',d)

xdata = (0,5)

plt.figure()
plt.plot(xdata,xdata*k+d,'r')
plt.scatter(x1,y1,c='b')
plt.scatter(x2,y2,c='y')
plt.show()

 单层感知机解决异或问题

'''
异或
0^0 = 0
0^1 = 1
1^0 = 1
1^1 = 0
'''
import numpy as np
import matplotlib.pyplot as plt
#输入数据
X = np.array([[1,0,0],
              [1,0,1],
              [1,1,0],
              [1,1,1]])
#标签
Y = np.array([[-1],
              [1],
              [1],
              [-1]])

#权值初始化，3行1列，取值范围-1到1
W = (np.random.random([3,1])-0.5)*2

print(W)
#学习率设置
lr = 0.11
#神经网络输出
O = 0

def update():
    global X,Y,W,lr
    O = np.sign(np.dot(X,W)) # shape:(3,1)
    W_C = lr*(X.T.dot(Y-O))/int(X.shape[0])
    W = W + W_C
for i in range(100):
    update()#更新权值
    print(W)#打印当前权值
    print(i)#打印迭代次数
    O = np.sign(np.dot(X,W))#计算当前输出
    if(O == Y).all(): #如果实际输出等于期望输出，模型收敛，循环结束
        print('Finished')
        print('epoch:',i)
        break

#正样本
x1 = [0,1]
y1 = [1,0]
#负样本
x2 = [0,1]
y2 = [0,1]

#计算分界线的斜率以及截距
k = -W[1]/W[2]
d = -W[0]/W[2]
print('k=',k)
print('d=',d)

xdata = (-2,3)

plt.figure()
plt.plot(xdata,xdata*k+d,'r')
plt.scatter(x1,y1,c='b')
plt.scatter(x2,y2,c='y')
plt.show()

 运行结果如上，可以知道单层感知机不适合解决如上类似的异或问题

线性神经网络

一篇优秀的线性神经网络博客总结链接

线性神经网络的学习视频

 同时相比于感知机引入了Delta学习规则

 

 解决感知机无法处理异或问题的方法

 对于第二个方法

 说明：X0是偏置值，值为1，X1，X2为线性输入，其它为添加的非线性输入，使用purelin激活函数（y=x）进行模型训练，再下面是y值的求法，用于图形绘制。

程序如下

#题目：异或运算
#0^0=0
#0^1=1
#1^0=1
#1^1=0
import numpy as np
import matplotlib.pyplot as plt
#输入数据--这里偏置定为1
X = np.array([[1,0,0,0,0,0],
              [1,0,1,0,0,1],
              [1,1,0,1,0,0],
              [1,1,1,1,1,1]])
#标签--期望输出
Y = np.array([-1,1,1,-1])
#权值初始化，1行6列，取-1到1的随机数
W = (np.random.random(6)-0.5)*2
print(W)
#学习率
lr = 0.11
#计算迭代次数
n = 0
#神经网络输出
o = 0

def update():
    global X,Y,W,lr,n
    n+=1
    o = np.dot(X,W.T)
    W_C = lr*((Y-o.T).dot(X))/(X.shape[0])#权值改变数，这里除掉行数求平均值，因为行数多，权值改变就会很大。
    W = W + W_C
for  i in range(1000):
    update()#更新权值

o = np.dot(X,W.T)
print("执行一千次后的输出结果：",o)#看下执行一千次之后的输出

#用图形表示出来
#正样本
x1 = [0,1]
y1 = [1,0]
#负样本
x2 = [0,1]
y2 = [0,1]

def calculate(x,root):
    a = W[5]
    b = W[2]+x*W[4]
    c = W[0]+x*W[1]+x*x*W[3]
    if root == 1:#第一个根
        return (-b+np.sqrt(b*b-4*a*c))/(2*a)
    if root == 2:#第二个根
        return (-b-np.sqrt(b*b-4*a*c))/(2*a)

xdata = np.linspace(-1,2)

plt.figure()
plt.plot(xdata,calculate(xdata,1),'r')#用红色
plt.plot(xdata,calculate(xdata,2),'r')#用红色
plt.plot(x1,y1,'bo')#用蓝色
plt.plot(x2,y2,'yo')#用黄色
plt.show()

 

利用神经网络解决上述感知机题目

import numpy as np
import matplotlib.pyplot as plt
#输入数据
X = np.array([[1,3,3],
              [1,4,3],
              [1,1,1],
              [1,0,2]])
#标签
Y = np.array([[1],
              [1],
              [-1],
              [-1]])

#权值初始化，3行1列，取值范围-1到1
W = (np.random.random([3,1])-0.5)*2

print(W)
#学习率设置
lr = 0.11
#神经网络输出
O = 0

def update():
    global X,Y,W,lr
    O = np.dot(X,W)
    W_C = lr*(X.T.dot(Y-O))/int(X.shape[0])
    W = W + W_C
for i in range(100):
    update()#更新权值

    #正样本
    x1 = [3,4]
    y1 = [3,3]
    #负样本
    x2 = [1,0]
    y2 = [1,2]

    #计算分界线的斜率以及截距
    k = -W[1]/W[2]
    d = -W[0]/W[2]
    print('k=',k)
    print('d=',d)

    xdata = (0,5)
    if i % 10 == 0:
        plt.figure()
        plt.plot(xdata,xdata*k+d,'r')
        plt.scatter(x1,y1,c='b')
        plt.scatter(x2,y2,c='y')
        plt.show()

BP神经网络

视频链接

反向传播（Back Propagation，简称BP）神经网络解决了多层神经网络的学习问题，广泛应用于分类识别、图像识别、压缩、逼近以及回归等领域，其结构如下所示。

另外介绍及格激活函数：sigmoid、tanh和softsign。神经网络中的激活函数，其作用就是引入非线性。
Sigmoid：sigmoid的优点是输出范围有限，数据在传递的过程中不容易发散，求导很容易（y=sigmoid(x), y’=y(1-y)）。缺点是饱和的时候梯度太小。其输出范围为(0, 1)，所以可以用作输出层，输出表示概率。
 
公式：

tanh和softsign：

要注意的是对多层神经元先对最后一层权重更新，其结果再更新前一层的权重

 

 bp神经网络解决异或问题的程序如下

import numpy as np

# 输入数据
X = np.array([[1, 0, 0],
              [1, 0, 1],
              [1, 1, 0],
              [1, 1, 1]])
# 标签
Y = np.array([[0, 1, 1, 0]])
# 权值初始化，取值范围-1到1
V = np.random.random((3, 4)) * 2 - 1
W = np.random.random((4, 1)) * 2 - 1
print(V)
print(W)
# 学习率设置
lr = 0.11
def sigmoid(x):
    return 1 / (1 + np.exp(-x))
def dsigmoid(x):
    return x * (1 - x)#激活函数的导数
def update():
    global X, Y, W, V, lr

    L1 = sigmoid(np.dot(X, V))  # 隐藏层输出(4,4)
    L2 = sigmoid(np.dot(L1, W))  # 输出层输出(4,1)

    L2_delta = (Y.T - L2) * dsigmoid(L2)
    L1_delta = L2_delta.dot(W.T) * dsigmoid(L1)

    W_C = lr * L1.T.dot(L2_delta)
    V_C = lr * X.T.dot(L1_delta)

    W = W + W_C
    V = V + V_C


for i in range(20000):
    update()  # 更新权值
    if i % 500 == 0:
        L1 = sigmoid(np.dot(X, V))  # 隐藏层输出(4,4)
        L2 = sigmoid(np.dot(L1, W))  # 输出层输出(4,1)
        print('Error:', np.mean(np.abs(Y.T - L2)))

L1 = sigmoid(np.dot(X, V))  # 隐藏层输出(4,4)
L2 = sigmoid(np.dot(L1, W))  # 输出层输出(4,1)
print(L2)


def judge(x):
    if x >= 0.5:
        return 1
    else:
        return 0


for i in map(judge, L2):
    print(i)