感知机的策略

定义损失函数的第一种方法

损失函数1：当前超平面下误分类点的个数

优点：找到了一个可以反应出当下的模型的信息损失的方式

缺点：离散型的变量，不好做优化，需要将离散的变量转换成连续的变量

损失函数2：当前超平面下误分类点的点到超平面的距离总和

优点：将离散的信息损失转换成了连续的信息损失，可以尝试做求导

缺点：公式中有一个绝对值存在，做求导非常的困难

y(wx+b)又叫做函数间隔

损失函数3：当前超平面下误分类点的点到超平面的函数间隔的总和

Batch 梯度下降的解法

1）选择初始值w0,b0

2) 在训练集找出所有的误分类点，这个误分类点的集合可称之为M集合

3）如果yi(w*xi+b)<0,则这个点就是当前模型wk，bk误分类点，将所有的误分类点找出来，用来需要更新为wk+1,bk+1

4)转到第二步，直到训练集中没有误分类点为止

Batch梯度下降算法的实现

回归之前的梯度下降的算法，Batch是利用整个数据集来更新w与b

import numpy as np

import pandas as pd

import matplotlib.pyplot as plt

import random

from sklearn.datasets import make_blobs

sample_size=200

centers=[[1,1],[3,4]]

X,Y=make_blobs(n_samples=sample_size,centers=centers,cluster_std=0.6,random_state=11)

Y[Y==0]=-1

plt.scatter(X[:,0],X[:,1],cmap='cool',c=Y)

x_mat=np.mat(X)

w=np.mat([1]*x_mat.shape[1]).T

b=0

w

首先对所有的数据都做操作，将所有的点都算一遍，然后用np.where这样的形式将所有的误分类点给找出来。

tmp=np.ravel(x_mat*w+b)*Y

tmp_result_X=np.array(X[np.where(tmp<=0)])

tmp_result_Y=Y[np.where(tmp<=0)]

现在我们已经找到所有的误分类点，然后就是利用公式

首先算出后面求和的这一部分

total_w=tmp_result_X*np.array([tmp_result_Y]*x_mat.shape[1]).T

total_w.sum(axis=0)

tmp_result_Y.sum()

算出之后，进行更新操作

w=w-np.mat(total_w.sum(axis=0)).T*alpha

b=b-tmp_result_Y.sum()*alpha

w,b

将代码综合起来

x_mat=np.mat(X)

w=np.mat([1]*x_mat.shape[1]).T

b=0

alpha=0.01

while True:

tmp=np.ravel(x_mat*w+b)*Y

missing_TF=tmp<0

print('missing points are now {}'.format(sum(missing_TF)))

if sum(missing_TF)==0:

break

finding=np.where(missing_TF)

tmp_result_X=X[finding]

tmp_result_Y=Y[finding]

total_w=tmp_result_X*np.array([tmp_result_Y]*tmp_result_X.shape[1]).T

w=w+np.mat(total_w.sum(axis=0)).T*alpha

b=b+tmp_result_Y.sum()*alpha

print(w)

print(b)

这样一个batch就做好了，可以发现如果使用不同的初始点，最后的结果是不一样的。

单样本梯度下降的实现

我们也可以使用单样本的梯度下降来求解感知机，这里倾向于使用单样本梯度下降，因为会引出对偶的形态。

1）初始值w=1,b=1

2) 找出一个误分类点，假如说某个xi点符合yi(w*xi+b)<=0,就是误分类点

3）w=w+λyixi

b=b+λyi

4)重复2,3步直到没有误分类点

w=np.array([1]*X.shape[1])

b=0

lam=0.1

#记录count的值，这个值是用来看模型迭代了多少次

count=0

while True:

count += 1

missing_index = -1

for i in range(X.shape[0]):

checking=Y[i]*(np.dot(w,X[i])+b)

if checking < 0:

missing_index = i

break

if missing_index == -1:

break

w=w+lam*Y[missing_index]*X[missing_index]

b=b+lam*Y[missing_index]

感知机的对偶形式

在感知机和SVM的线性形势下，模型是有参数模型。在感知机和SVM的对偶形式，以及需要使用到对偶形式的核函数模型下，是无参数模型

SVM

支持向量机几乎囊括了我们之前了解的所有算法的功能：

SVM损失函数1

SVM损失函数2

SVM损失函数3

拉格朗日优化方法

拉格朗日的激活

1. 激活，激活的状态其实就是约束条件起到了约束的作用
   

   

2. 不激活

   

3. 综合形态

   

拉格朗日求解SVM原始损失函数

SVM的结果解析

在拉格朗日当中，主要对a*g(x)=0进行了最常见的两种情况的探讨，在激活的状态下a>0,g(x)=0,在未激活状态下，a=0,g(x)<0

1)激活状态

2）未激活状态

线性SVM决策过程的可视化

我们可以使用sklearn中的式子来为可视化我们的决策边界，支持向量，以及决策边界平行的两个超平面。

1）导入需要的模块

from sklearn.datasets import make_blobs

from sklearn.svm import SVC

import matplotlib.pyplot as plt

import numpy as np

2)实例化数据集，可视化数据集

X,y=make_blobs(n_samples=50,centers=2,random_state=0,cluster_std=0.6)

plt.scatter(X[:,0],X[:,1],c=y,s=50,cmap='rainbow')

plt.show()

3)画决策边界：理解函数contour

matplotlib.axes.Axes.contour([X,Y]Z,[levels],**kwargs)

我们的决策边界是w*x+b=0,并在决策边界的两边找出两个超平面，使得超平面到决策边界的相对距离为1。那其实，我们只需要在我们的样本构成的平面上，把所有到决策边界的距离为0的点相连，就是我们的决策边界，而把所有的到决策边界的相对距离为1的点相连，就是我们的两个平行于决策边界的超平面了。此时，Z就是平面上的任意点到达超平面的距离。

#首先要有散点图

plt.scatter(X[:,0],X[:,1],c=y,s=50,cmap='rainbow')

ax=plt.gca()#获取当前的子图，如果不存在，则创建新的子图

4）画决策边界：制作网格，理解函数meshgrid

#获取平面上两条坐标轴的最大值和最小值

xlim=ax.get_xlim()

ylim=ax.get_ylim()

#在最大值和最小值之间形成30个规律的数据

axisx=np.linspace(xlim[0],xlim[1],30)

axisy=np.linspace(ylim[0],ylim[1],30)

axisy,axisx=np.meshgrid(axisy,axisx)

xy=np.vstack([axisx.ravel(),axisy.ravel()]).T

plt.scatter(xy[:,0],xy[:,1],s=1,cmap='rainbow')

5)建模，计算决策边界并找出网格上每个点到决策边界的距离

clf=SVC(kernel='linear').fit(X,y)

Z=clf.decision_function(xy).reshape(axisx.shape)

ax.contour(axisx,axisy,Z,colors='k',levels=[-1,0,1],alpha=0.5,linestyles=['--','-','--'])

ax.set_xlim(xlim)

ax.set_ylim(ylim)

6)探索建好的模型

clf.predict(X)

#根据决策边界，对X中的样本进行分类，返回的结构为n_samples

clf.score(X,y)

#返回给定测试数据和标签的平均准确度

clf.support_vectors_

#返回支持向量

clf.n_support_

#返回每个类中支持向量的个数

软间隔的sklearn实现：使用参数C来确定惩罚值得大小

核函数