感知机学习算法的对偶形式

最新推荐文章于 2024-02-18 11:00:00 发布

Godxv

最新推荐文章于 2024-02-18 11:00:00 发布

阅读量1.2w

点赞数 19

分类专栏：机器学习统计学习方法 Python 算法文章标签：感知机感知机对偶形式机器学习统计学习方法

本文链接：https://blog.csdn.net/qq_29591261/article/details/77945561

版权

算法同时被 3 个专栏收录

8 篇文章 0 订阅

订阅专栏

机器学习

7 篇文章 0 订阅

订阅专栏

统计学习方法

7 篇文章 0 订阅

订阅专栏

感知机学习算法的原始形式：http://blog.csdn.net/qq_29591261/article/details/77934696

本文相对于原文在代码中添加了自己的理解和注释，省略推理过程，想看原理推导的请参考原文：http://www.hankcs.com/ml/the-perceptron.html

关于对偶

对偶，简单地说，就是从一个不同的角度去解答相似问题，但是问题的解是相通的。
或者说原始问题比较难求解，我们去求解另外一个问题，希望通过更简单的方法得到原始问题的解。
对于感知机来说，简单来说，就是用α去记录每个yixi要加多少次，最后一次加上去就好了。
具体理解如下：
这里写图片描述
来源于知乎：https://www.zhihu.com/question/26526858

感知机学习算法的对偶形式

对偶指的是，将w和b表示为测试数据i的线性组合形式，通过求解系数得到w和b。具体说来，如果对误分类点i逐步修改wb修改了n次，则w，b关于i的增量分别为这里写图片描述，这里，则最终求解到的参数分别表示为：

于是有算法2.2：

感知机对偶算法代码

# -*- coding:utf-8 -*-
# Filename: train2.2.py
# Author：hankcs
# Date: 2015/1/31 15:15
import numpy as np
from matplotlib import pyplot as plt
from matplotlib import animation
training_set = np.array([[[3, 3], 1], [[4, 3], 1], [[1, 1], -1], [[5, 2], -1]]) #训练样本
a = np.zeros(len(training_set), np.float) #矩阵a的长度为训练集样本数，类型为float
b = 0.0 #参数初始值为0
Gram = None #Gram矩阵
y = np.array(training_set[:, 1]) #y=[1 1 -1 -1]
x = np.empty((len(training_set), 2), np.float) #x为4*2的矩阵
for i in range(len(training_set)): #x=[[3., 3.], [4., 3.], [1., 1.], [5., 2.]]
x[i] = training_set[i][0]
history = [] #history记录每次迭代结果
def cal_gram():
"""
计算Gram矩阵
:return:
"""
g = np.empty((len(training_set), len(training_set)), np.int)
for i in range(len(training_set)):
for j in range(len(training_set)):
g[i][j] = np.dot(training_set[i][0], training_set[j][0]) #G=[xi*xj]
return g
def update(i):
"""
随机梯度下降更新参数
:param i:
:return:
"""
global a, b
a[i] += 1 #根据误分类点更新参数
b = b + 1 * y[i] #这里1是学习效率η
history.append([np.dot(a * y, x), b]) #history记录每次迭代结果
print a, b #输出每次迭代结果
#计算yi(Gram*xi+b),用来判断是否是误分类点
def cal(i):
global a, b, x, y
res = np.dot(a * y, Gram[i])
res = (res + b) * y[i] #返回
return res
#检查是否已经正确分类
def check():
global a, b, x, y
flag = False
for i in range(len(training_set)): #遍历每个点
if cal(i) <= 0: #如果yi(Gram*xi+b)<=0.则是误分类点
flag = True
update(i) #用误分类点更新参数
if not flag: #如果已正确分类
w = np.dot(a * y, x) #计算w
print "RESULT: w: " + str(w) + " b:" + str(b) #输出最后结果
return False
return True
if __name__ == "__main__":
Gram = cal_gram() #初始化 Gram矩阵
for i in range(1000): #迭代1000次
if not check(): break #如果已正确分类则结束循环
#以下代码是将迭代过程可视化,数据来源于history
# first set up the figure, the axis, and the plotelement we want to animate
fig = plt.figure()
ax = plt.axes(xlim=(0, 2), ylim=(-2, 2))
line, = ax.plot([], [], 'g', lw=2)
label = ax.text([], [], '')
# initialization function: plot the background of eachframe
def init():
line.set_data([], [])
x, y, x_, y_ = [], [], [], []
for p in training_set:
if p[1] > 0:
x.append(p[0][0])
y.append(p[0][1])
else:
x_.append(p[0][0])
y_.append(p[0][1])
plt.plot(x, y, 'bo', x_, y_, 'rx')
plt.axis([-6, 6, -6, 6])
plt.grid(True)
plt.xlabel('x')
plt.ylabel('y')
plt.title('PerceptronAlgorithm 2 (www.hankcs.com)')
return line, label
# animation function. this is called sequentially
def animate(i):
global history, ax, line, label
w = history[i][0]
b = history[i][1]
if w[1] == 0: return line, label
x1 = -7.0
y1 = -(b + w[0] * x1) / w[1]
x2 = 7.0
y2 = -(b + w[0] * x2) / w[1]
line.set_data([x1, x2], [y1, y2])
x1 = 0.0
y1 = -(b + w[0] * x1) / w[1]
label.set_text(str(history[i][0]) + ' ' + str(b))
label.set_position([x1, y1])
return line, label
# call the animator. blit=true means only re-draw the parts that have changed.
anim =animation.FuncAnimation(fig, animate, init_func=init, frames=len(history), interval=1000, repeat=True,
blit=True)
plt.show()
#anim.save('D:/perceptron2.gif',fps=2, writer='imagemagick')