机器学习-SVM-SMO与SGD求解(附鸢尾花数据集实战,含代码)

代码SMO部分参考书籍为《机器学习实践》

原理的整体认知:

首先,我们认识到SVM其实就是求一个最优(超)平面的过程,说svm有三宝,间隔,对偶,核技巧

间隔就是说要求得的平面距离所有点间隔最大,这是一个最优化问题,可以用拉格朗日乘数法,解决。

化为这个形式后,求它的对偶问题,

求解的对偶问题的答案,按照以下公式反推到原问题的答案

两种常用的求解算法:

1.SGD

将原问题转变为一个最小损失函数的问题,用梯度下降的方法,优化参数,减小损失

2.SMO

每次只从参数中挑去两个进行优化,这样能使问题简化成很多个二次凸优化问题

机器学习-SVM-SMO与SGD求解(附鸢尾花数据集实战,含代码)_第1张图片

虽然在这里两种方法都用高斯映射,但是SMO方法其实可以通过核函数直接求解,并不需要进行映射,而SGD则必须要映射后进行求解,无法使用核函数。从他们要优化的公式里可以看出这一点。

SGD算法

import numpy as np
import matplotlib.pyplot as plt
import sklearn.datasets as datasets
def relu(x):
    if x>0:
        return x
    else:
        return 0

def gradient_descent(loss,w,b,exp_loss,x,y,lr=0.0001,lambda0=0.1):#这里没有加lambda
    C=1000
    if exp_loss==0:
        b=b-lr*0
        w=w-lr*0#2*w*lambda0
    else:
        b=b-lr*(-y)*C
        w=w-lr*(-y*x)*C
    return w,b
def Hingeloss_gradient_descent(y_pre,y_label,weight,x,b,lr=0.000001):
    lam=1
    loss=relu(1-y_label * y_pre)+np.linalg.norm(weight)*lam
    weight,b=gradient_descent(loss,weight,b,relu(1-y_label*(y_pre)),x,y_label,lr=lr,lambda0=lam)
    return weight,b
def svm(data,label,epoch):
    w=np.zeros((np.shape(data)[1],1)).T
    b=0
    for i in range(epoch):
        for j in range(np.shape(data)[0]):
            y_pre=np.matmul(w,data[j,:])+b
            w,b=Hingeloss_gradient_descent(y_pre,label[j],w,data[j],b)
    return w,b


def get_data():
    fig = plt.figure()
    x, y1 =datasets.make_circles(n_samples=100, factor=0.1, noise=0.1)
    plt.scatter(x[:, 0], x[:, 1], marker='o', c=y1)
    plt.pause(2)
    for i in range(len(y1)):
        if y1[i]==0:
            y1[i]=-1
    return x,y1


def process(_x):
    '''
    映射到高维核空间
    :param data_point:
    :param data_noise:
    :return:
    '''
    Z = np.zeros([100, 3])
   
    # 高斯核映射
    Z[:, 0] = np.exp(-(_x[:, 0] ** 2)) * np.exp(-(_x[:, 1] ** 2))
    Z[:, 1] = 2 * _x[:, 0] * _x[:, 1] * np.exp(-(_x[:, 0] ** 2)) * np.exp(-(_x[:, 1] ** 2))
    Z[:, 2] = 2 * _x[:, 0] ** 2 * _x[:, 1] ** 2 * np.exp(-(_x[:, 0] ** 2)) * np.exp(-(_x[:, 1] ** 2))

    return Z


X,y=get_data()
x=process(X)
# x=X
print(X,y)
w,b=svm(x,y,700)
for i in range(np.shape(X)[0]):
    if np.matmul(w,x[i])+b > 0:
        plt.scatter(X[i,0],X[i,1],c='red')
        print(np.matmul(w,x[i])+b)
    elif np.matmul(w,x[i])+b < 0:
        plt.scatter(X[i, 0], X[i, 1], c='blue')
plt.pause(8)
print(b,w)

 SMO算法

​
import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
import torch
import time
iris =datasets.load_iris()
def get_data():
    fig = plt.figure()
    x, y1 =datasets.make_circles(n_samples=100, factor=0.1, noise=0.1)
    plt.scatter(x[:, 0], x[:, 1], marker='o', c=y1)
    plt.pause(2)

    return x,y1


def process(_x):
    '''
    映射到高维核空间
    :param data_point:
    :param data_noise:
    :return:
    '''
    Z = np.zeros([100, 3])

    # 高斯核映射
    Z[:, 0] = np.exp(-(_x[:, 0] ** 2)) * np.exp(-(_x[:, 1] ** 2))
    Z[:, 1] = 2 * _x[:, 0] * _x[:, 1] * np.exp(-(_x[:, 0] ** 2)) * np.exp(-(_x[:, 1] ** 2))
    Z[:, 2] = 2 * _x[:, 0] ** 2 * _x[:, 1] ** 2 * np.exp(-(_x[:, 0] ** 2)) * np.exp(-(_x[:, 1] ** 2))

    return Z




def selectJ(i,samples_num):
    j=i
    while j==i:
        j=int(np.random.uniform(0,samples_num))

    return  j

def clipAlpha(L,H,alpha):
    if alpha>H:
        alpha= H
    if alpha toler and alpha[i] > 0):  # 和书上kkt不一样为什么?
                j = selectJ(i, m)
                gx_j = float(np.multiply(alpha, labelMat).T * (dataMat * dataMat[j, :].T)) + b
                Ej = gx_j - float(labelMat[j])
                alpha_i_old = alpha[i].copy()
                alpha_j_old = alpha[j].copy()
                print(i, itera, gx_i, gx_j,b,np.sum(alpha))
                time.sleep(0.01)
                if labelMat[i] != labelMat[j]:
                    L = max(0, alpha[j] - alpha[i])
                    H = min(C, C + alpha[j] - alpha[i])
                else:
                    L = max(0, alpha[j] + alpha[i] - C)
                    H = min(C, alpha[j] + alpha[i])
                if L==H:
                    print('L==H')
                    continue
                eta=2.0*dataMat[i,:]*dataMat[j,:].T-dataMat[i,:]*dataMat[i,:].T-dataMat[j,:]*dataMat[j,:].T#什么东西这是?epsilon
                print(eta)
                if eta>=0:
                    print('eta>=0')#why????????????
                    continue

                alpha[j] -= labelMat[j] * (Ei - Ej) / eta  # +or->>>>
                alpha[j] = clipAlpha(L, H, alpha[j])
                if abs(alpha[j] - alpha_j_old) < 0.00001:
                    print('j not moving enough')
                    continue
                alpha[i] += labelMat[j] * labelMat[i] * (alpha_j_old - alpha[j])
                b1 = b - Ei - labelMat[i] * (alpha[i] - alpha_i_old) * dataMat[i, :] * dataMat[i, :].T - labelMat[
                    j] * (alpha[j] - alpha_j_old) * dataMat[i, :] * dataMat[j, :].T
                b2 = b - Ej - labelMat[i] * (alpha[i] - alpha_i_old) * dataMat[i, :] * dataMat[j, :].T - labelMat[
                    j] * (alpha[j] - alpha_j_old) * dataMat[j, :] * dataMat[j, :].T
                if alpha[i] > 0 and alpha[i] < C:
                    b = b1
                elif alpha[j] > 0 and alpha[j] < C:
                    b=b2
                else:
                    b=(b1+b2)/2.0
                alphaPairChange+=1
                print(("iter{},i:{},pairchange{}".format(itera,i,alphaPairChange)))
        if (alphaPairChange==0):
            itera+=1
        else:
            itera=0
        print('iteration{},m{}'.format(itera,i))

    return b,alpha

np.random.seed(0)
x=np.random.random((100,2))
x[:50,:]+=0.8
x[50:,:]-=0.8
print
y=np.array([0]*100)
y[:50]+=1
y[50:]-=1
print('y{}'.format(y))
plt.scatter(x[:50,0],x[:50,1],c='r')
plt.scatter(x[50:,0],x[50:,1],c='g')
# plt.pause(3)
b,alpha=smo(dataIn=x,classLabel=y,C=0.6,toler=0.001,maxIter=40)
print(b,alpha)
# w=alpha*y*x.T
#画出分割面
for i in range(100):
    if alpha[i]>0.0:
        print(x[i],y[i])
        plt.scatter(x[i,0], x[i, 1], c='y')

plt.pause(10)

​

鸢尾花数据集实战

正常人眼里的鸢尾花:

机器学习-SVM-SMO与SGD求解(附鸢尾花数据集实战,含代码)_第2张图片

 计算机人眼里的鸢尾花机器学习-SVM-SMO与SGD求解(附鸢尾花数据集实战,含代码)_第3张图片

机器学习-SVM-SMO与SGD求解(附鸢尾花数据集实战,含代码)_第4张图片

机器学习-SVM-SMO与SGD求解(附鸢尾花数据集实战,含代码)_第5张图片

import numpy as np
import matplotlib.pyplot as plt
import sklearn.datasets as datasets
import math
from sklearn.preprocessing import MinMaxScaler
import sklearn.utils as utils
def relu(x):
    if x>0:
        return x
    else:
        return 0

def gradient_descent(loss,w,b,exp_loss,x,y,lr=0.01,lambda0=0.1):#这里没有加lambda
    C=10
    if exp_loss==0:
        b=b-lr*0
        w=w-lr*0#2*w*lambda0
    else:
        b=b-lr*(-y)*C
        w=w-lr*(-y*x)*C
    return w,b
def Hingeloss_gradient_descent(y_pre,y_label,weight,x,b,lr=0.001):
    lam=1
    loss=relu(1-y_label * y_pre)+np.linalg.norm(weight)*lam
    weight,b=gradient_descent(loss,weight,b,relu(1-y_label*(y_pre)),x,y_label,lr=lr,lambda0=lam)
    return weight,b
def svm(data,label,epoch):
    w=np.zeros((np.shape(data)[1],1)).T
    b=0
    for i in range(epoch):
        for j in range(np.shape(data)[0]):
            y_pre=np.matmul(w,data[j,:])+b
            w,b=Hingeloss_gradient_descent(y_pre,label[j],w,data[j],b)
    return w,b

def get_iris_data():
    iris=datasets.load_iris()
    print(iris.data,iris.target)
    scaler=MinMaxScaler()
    data=scaler.fit_transform(iris.data)
    print(data)
    x,y=utils.shuffle(data,iris.target)
    train_size=int(x.shape[0]*5/10)
    train_x,train_y,test_x,test_y=x[:train_size,:],y[:train_size],x[train_size:,:],y[train_size:]
    return train_x,train_y,test_x,test_y
def get_data():
    fig = plt.figure()
    x, y1 =datasets.make_circles(n_samples=100,noise=0.5 )
    # x, y1 = datasets.make_moons(n_samples=100, noise=0.0)
    plt.scatter(x[:, 0], x[:, 1], marker='o', c=y1)

    plt.pause(2)
    for i in range(len(y1)):
        if y1[i]==0:
            y1[i]=-1
    return x,y1


def process(_x):
  
    Z = np.zeros([100, 3])
    # # 二项式映射
    # X[:,0] = _x[:,0]**2
    # X[:, 1] = math.sqrt(2)*_x[:,0]*_x[:,1]
    # X[:,2] = _x[:,1]**2

    # 高斯核映射
    Z[:, 0] = np.exp(-(_x[:, 0] ** 2)) * np.exp(-(_x[:, 1] ** 2))
    Z[:, 1] = 2 * _x[:, 0] * _x[:, 1] * np.exp(-(_x[:, 0] ** 2)) * np.exp(-(_x[:, 1] ** 2))
    Z[:, 2] = 2 * _x[:, 0] ** 2 * _x[:, 1] ** 2 * np.exp(-(_x[:, 0] ** 2)) * np.exp(-(_x[:, 1] ** 2))

    return Z

train_x,train_y,test_x,test_y=get_iris_data()
svm_list=[]
w_list,b_list=[],[]
pre_out=[]
y_pre=[]
label_y=np.zeros_like(train_y)
for i in range(3):
    for j in range(train_x.shape[0]):
        if train_y[j]==i:
            label_y[j]=1
        else:
            label_y[j]=-1
    # print(label_y)
    w, b = svm(train_x, label_y, 700)
    w_list.append(w)
    b_list.append(b)

correct_n=0
for i in range(test_x.shape[0]):
    for j in range(3):
        pre_out.append(float(np.matmul(w_list[j],test_x[i,:])+b_list[j]))
    y_pre.append(pre_out.index(max(pre_out)))
    if  pre_out.index(max(pre_out))==test_y[i]:
        correct_n+=1
    print(pre_out.index(max(pre_out)),test_y[i],pre_out)
    pre_out.clear()

print("测试集大小{:},预测正确数目{},正确率{:.2f}".format(test_y.shape[0],correct_n,correct_n/test_y.shape[0]))

手撕原理:

        看完了代码和大体原理,我们再来细细了解详细原理,此处主要参考李航的《统计学习方法》

        1.首先清楚要找到这样一个平面将样本完全分开,且最大化 最小的“几何间隔”最大。几何间隔定义为图1。(至于为什么定义成这样书上有写,此处为连贯性略)。

机器学习-SVM-SMO与SGD求解(附鸢尾花数据集实战,含代码)_第6张图片

图1

        2.这样一个最大化问题,可以等价转化为下面这样一约束最大化问题(证明略书上有)机器学习-SVM-SMO与SGD求解(附鸢尾花数据集实战,含代码)_第7张图片

         3.用拉格朗日乘数法,又可以等价转化为下式子,alpha为拉格朗日乘子向量,由解满足KKT条件可证(此略),alpha与w,b的关系下图二。

 机器学习-SVM-SMO与SGD求解(附鸢尾花数据集实战,含代码)_第8张图片

机器学习-SVM-SMO与SGD求解(附鸢尾花数据集实战,含代码)_第9张图片

         4.根据拉格朗日对偶性,(白板推导里有讲,此略)原问题的对偶问题为下,求出alpha则求的出原问题解

       

两种优化算法

        SGD:1.可证(此略),下面两个最优化问题是等价的,第二个称为 合页损失函数+正则项

机器学习-SVM-SMO与SGD求解(附鸢尾花数据集实战,含代码)_第10张图片

机器学习-SVM-SMO与SGD求解(附鸢尾花数据集实战,含代码)_第11张图片

 所以,我们可以通过梯度下降的 方法优化损失函数,直接求偏导就行,可以参照上面给出的代码学习。

         SMO:1.为了进一步求解 maxminL(w,b,a),先求minL(w,b,a),对w,b求偏导,问题等价化为:

 机器学习-SVM-SMO与SGD求解(附鸢尾花数据集实战,含代码)_第12张图片

ps:核技巧就是将xi*xj化为了K(xi,xj),K是核函数,表示映射到高维的xi,xj的乘积的值。

        2.SMO算法全名叫序列最小最优化(Sequential minimal optimization),因为KKT条件是该最优化问题的充分必要条件(证明略),即当所有样本均满足KKT条件时,为最优化问题的解。首先,从所有α中选择两个变量α1,α2,固定其他变量,针对这两个变量构建一二次规划问题,此子问题可通过解析方法求解。重复这一步骤不断优化,直到所有变量都满足KKT条件得到最终解。

        2.1 解析方法求解二次规划问题

        子问题可以写作以下形式机器学习-SVM-SMO与SGD求解(附鸢尾花数据集实战,含代码)_第13张图片

 机器学习-SVM-SMO与SGD求解(附鸢尾花数据集实战,含代码)_第14张图片

 未完待续

你可能感兴趣的:(机器学习)