Python机器学习算法实现
Author：louwill
前面两讲我们对感知机和神经网络进行了介绍。感知机作为一种线性分类模型，很难处理非线性问题。为了处理非线性的情况，在感知机模型的基础上有了两个方向，一个就是上一讲说到的神经网络，大家也看到了，现在深度学习大放异彩，各种网络功能强大。但实际上在神经网络兴起之前，基于感知机的另一种模型——支持向量机，同样可以解决非线性问题。
支持向量机一般来说有三种任务类型：线性可分情况，近似线性可分情况以及线性不可分情况。针对这三种分别线性可分支持向量机、线性支持向量机和线性不可分支持向量机。笔者将分三次对这三种支持向量机进行介绍。
线性可分支持向量机
和感知机一样，线性可分支持向量机的训练目标也是寻找一个分离超平面，能将数据分成不同的类。通过感知机的学习我们知道，当训练数据线性可分时，一般存在不止一个线性超平面可以将数据分类，可能有无数多个线性超平面。而线性可分支持向量机则是利用间隔最大化求得一个最优的分离超平面。
关于函数间隔、几何间隔和支持向量等相关概念，笔者这里不过多阐述，详细细节可参考统计学习方法一书。总之，线性可分支持向量机可被形式化一个凸二次规划问题：
这里多说一句，感知机、最大熵和支持向量机等模型的优化算法都是一些经典的优化问题，对其中涉及的凸优化、拉格朗日对偶性、KKT条件、二次规划等概念，建议各位找到相关材料和教材认真研读，笔者这里不多做表述。
一般来说，我们可以直接对上述凸二次规划进行求解，但有时候该原始问题并不容易求解，这时候需要引入拉格朗日对偶性，将原始问题转化为对偶问题进行求解。原始二次规划的一般形式为：
引入拉格朗日函数：
定义该拉式函数的最大化函数：
通过证明可得原始问题等价于该拉式函数的极小极大化问题：
原始问题为极小极大化问题，根据拉格朗日对偶性，对偶问题即为极大极小化问题：
为计算该对偶问题的解，我们需要对L(w,b, α)求极小，再对α求极大。具体推导如下。第一步：
第二步：
第三步：根据KKT条件可得：
最后可根据对偶问题求得原始问题的解为：
以上便是线性可分支持向量机的对偶问题推导过程，详细过程可参考相关教材，笔者不做过多展开(主要是打公式太费时间)。
线性可分支持向量机的简单实现
这里我们基采取和之前感知机模型一样的优化思想来求解线性可分支持向量机的原始问题。
先准备示例训练数据：
data_dict = {-1:np.array([[1,7],
[2,8],
[3,8],]),
1:np.array([[5,1],
[6,-1],
[7,3],])}
导入相关package并绘图展示：
import numpy as np
import matplotlib.pyplot as plt
colors = {1:'r',-1:'g'}
fig = plt.figure()
ax = fig.add_subplot(1,1,1)
[[ax.scatter(x[0],x[1],s=100,color=colors[i])
for x in data_dict[i]] for i in data_dict]
plt.show()
接下来定义线性可分支持向量机的模型主体和训练部分：
def train(data):
# 参数字典 { ||w||: [w,b] }
opt_dict = {}
# 数据转换列表
transforms = [[1,1],
[-1,1],
[-1,-1],
[1,-1]]
# 从字典中获取所有数据
all_data = []
for yi in data:
for featureset in data[yi]:
for feature in featureset:
all_data.append(feature)
# 获取数据最大最小值
max_feature_value = max(all_data)
min_feature_value = min(all_data)
all_data = None
# 定义一个步长列表
step_sizes = [max_feature_value * 0.1,
max_feature_value * 0.01,
max_feature_value * 0.001
]
# 参数b的范围设置
b_range_multiple = 2
b_multiple = 5
latest_optimum = max_feature_value*10
# 基于不同步长训练优化
for step in step_sizes:
w = np.array([latest_optimum,latest_optimum])
# 凸优化
optimized = False
while not optimized:
for b in np.arange(-1*(max_feature_value*b_range_multiple),
max_feature_value*b_range_multiple,
step*b_multiple):
for transformation in transforms:
w_t = w*transformation
found_option = True
for i in data:
for xi in data[i]:
yi=i
if not yi*(np.dot(w_t,xi)+b) >= 1:
found_option = False
if found_option:
opt_dict[np.linalg.norm(w_t)] = [w_t,b]
if w[0] < 0:
optimized = True
print('Optimized a step!')
else:
w = w - step
norms = sorted([n for n in opt_dict])
#||w|| : [w,b]
opt_choice = opt_dict[norms[0]]
w = opt_choice[0]
b = opt_choice[1]
latest_optimum = opt_choice[0][0]+step*2
for i in data:
for xi in data[i]:
yi=i
print(xi,':',yi*(np.dot(w,xi)+b))
return w, b
基于示例数据的训练结果如下：
然后定义预测函数：
# 定义预测函数
def predict(features):
# sign( x.w+b )
classification = np.sign(np.dot(np.array(features),w)+b)
if classification !=0:
ax.scatter(features[0], features[1], s=200, marker='^', c=colors[classification])
print(classification)
return classification
基于示例数据的预测结果：
整合成线性可分支持向量机类
整理上述代码并添加结果可视化：
class Hard_Margin_SVM:
def __init__(self, visualization=True):
self.visualization = visualization
self.colors = {1:'r',-1:'g'}
if self.visualization:
self.fig = plt.figure()
self.ax = self.fig.add_subplot(1,1,1)
# 定义训练函数
def train(self, data):
self.data = data
# 参数字典 { ||w||: [w,b] }
opt_dict = {}
# 数据转换列表
transforms = [[1,1],
[-1,1],
[-1,-1],
[1,-1]]
# 从字典中获取所有数据
all_data = []
for yi in self.data:
for featureset in self.data[yi]:
for feature in featureset:
all_data.append(feature)
# 获取数据最大最小值
self.max_feature_value = max(all_data)
self.min_feature_value = min(all_data)
all_data = None
# 定义一个学习率(步长)列表
step_sizes = [self.max_feature_value * 0.1,
self.max_feature_value * 0.01,
self.max_feature_value * 0.001
]
# 参数b的范围设置
b_range_multiple = 2
b_multiple = 5
latest_optimum = self.max_feature_value*10
# 基于不同步长训练优化
for step in step_sizes:
w = np.array([latest_optimum,latest_optimum])
# 凸优化
optimized = False
while not optimized:
for b in np.arange(-1*(self.max_feature_value*b_range_multiple),
self.max_feature_value*b_range_multiple,
step*b_multiple):
for transformation in transforms:
w_t = w*transformation
found_option = True
for i in self.data:
for xi in self.data[i]:
yi=i
if not yi*(np.dot(w_t,xi)+b) >= 1:
found_option = False
# print(xi,':',yi*(np.dot(w_t,xi)+b))
if found_option:
opt_dict[np.linalg.norm(w_t)] = [w_t,b]
if w[0] < 0:
optimized = True
print('Optimized a step!')
else:
w = w - step
norms = sorted([n for n in opt_dict])
#||w|| : [w,b]
opt_choice = opt_dict[norms[0]]
self.w = opt_choice[0]
self.b = opt_choice[1]
latest_optimum = opt_choice[0][0]+step*2
for i in self.data:
for xi in self.data[i]:
yi=i
print(xi,':',yi*(np.dot(self.w,xi)+self.b))
# 定义预测函数
def predict(self,features):
# sign( x.w+b )
classification = np.sign(np.dot(np.array(features),self.w)+self.b)
if classification !=0 and self.visualization:
self.ax.scatter(features[0], features[1], s=200, marker='^', c=self.colors[classification])
return classification
# 定义结果绘图函数
def visualize(self):
[[self.ax.scatter(x[0],x[1],s=100,color=self.colors[i]) for x in data_dict[i]] for i in data_dict]
# hyperplane = x.w+b
# v = x.w+b
# psv = 1
# nsv = -1
# dec = 0
# 定义线性超平面
def hyperplane(x,w,b,v):
return (-w[0]*x-b+v) / w[1]
datarange = (self.min_feature_value*0.9,self.max_feature_value*1.1)
hyp_x_min = datarange[0]
hyp_x_max = datarange[1]
# (w.x+b) = 1
# 正支持向量
psv1 = hyperplane(hyp_x_min, self.w, self.b, 1)
psv2 = hyperplane(hyp_x_max, self.w, self.b, 1)
self.ax.plot([hyp_x_min,hyp_x_max],[psv1,psv2], 'k')
# (w.x+b) = -1
# 负支持向量
nsv1 = hyperplane(hyp_x_min, self.w, self.b, -1)
nsv2 = hyperplane(hyp_x_max, self.w, self.b, -1)
self.ax.plot([hyp_x_min,hyp_x_max],[nsv1,nsv2], 'k')
# (w.x+b) = 0
# 线性分隔超平面
db1 = hyperplane(hyp_x_min, self.w, self.b, 0)
db2 = hyperplane(hyp_x_max, self.w, self.b, 0)
self.ax.plot([hyp_x_min,hyp_x_max],[db1,db2], 'y--')
plt.show()
测试效果如下：
data_dict = {-1:np.array([[1,7],
[2,8],
[3,8],]),
1:np.array([[5,1],
[6,-1],
[7,3],])}
svm = Hard_Margin_SVM()
svm.train(data=data_dict)
predict_us = [[0,10],
[1,3],
[3,4],
[3,5],
[5,5],
[5,6],
[6,-5],
[5,8],
[2,5],
[8,-3]]
for p in predict_us:
svm.predict(p)
svm.visualize()
以上就是本节内容，关于近似线性可分以及软间隔最大化问题，笔者将在下一篇推文中介绍。完整代码文件和数据可参考笔者GitHub地址：
https://github.com/luwill/machine-learning-code-writing
线性支持向量机
在上一讲中，我们探讨了线性可分情况下的支持向量机模型。本节我们来继续探讨svm的第二种情况，线性支持向量机。何谓线性支持呢？就是训练数据中大部分实例组成的样本集合是线性可分的，但有一些特异点的存在造成了数据线性不可分的状态，在去除了这些特异点之后，剩下的数据组成的集合便是线性可分的。
原始问题
所以我们可以在线性可分支持向量机的基础上，推导线性支持向量机的基本原理。假设训练数据线性不可分，这便意味着某些样本点不满足此前线性可分中的函数间隔大于1的约束条件，线性支持向量机这里的处理方法是对每个实例引入一个松弛变量，使得函数间隔加上松弛变量大于等于1。对应于线性可分时的硬间隔最大化(hard margin svm)，线性支持向量机可称为软间隔最大化问题(soft margin svm)。
因而线性支持向量机就可以形式化为一个凸二次规划问题：
其中C>0为惩罚参数，表示对误分类的惩罚程度。最小化该目标函数可包含两层含义：既要使得间隔最大化也要使得误分类点个数最少，C即为二者的调和系数。关于凸二次规划问题(QP)的求解，各位可参考运筹学、凸优化等教材课程，这里不多赘述。
再来看线性支持向量机的对偶问题。首先定义拉格朗日函数如下：
由上一讲的推导可知，对偶问题为拉格朗日函数的极大极小问题。基于该拉格朗日函数对w、b和keci求偏导：
由上三式可得：
将上述三个式子再代回到拉格朗日函数中：
于是便可得到线性支持向量机的对偶问题：
由KKT条件：
计算可得：
以上便是线性支持向量机，也即软间隔最大化对偶问题的推导过程。
cvxopt
本节将使用Python的凸优化求解的第三方库cvxopt实现线性支持向量机。先对该库进行了一个简单介绍。经典的二次规划问题可表示为如下形式：
假设要求解如下二次规划问题：
将目标函数和约束条件写成矩阵形式：
基于cvxopt包求解上述问题如下：
import numpy
from cvxopt import matrix
from cvxopt import solvers
# 定义二次规划参数
P = matrix([[1.0,0.0],[0.0,0.0]])
q = matrix([3.0,4.0])
G = matrix([[-1.0,0.0,-1.0,2.0,3.0],[0.0,-1.0,-3.0,5.0,4.0]])
h = matrix([0.0,0.0,-15.0,100.0,80.0])
# 构建求解
sol = solvers.qp(P,q,G,h)
# 获取最优值
print(sol['x']，sol['primal objective']）
基于cvxopt的线性支持向量机实现
导入相关package：
import numpy as np
from numpy import linalg
import cvxopt
import cvxopt.solvers
import pylab as pl
定义一个线性核函数：
def linear_kernel(x1, x2):
return np.dot(x1, x2)
生成示例数据：
def gen_non_lin_separable_data():
mean1 = [-1, 2]
mean2 = [1, -1]
mean3 = [4, -4]
mean4 = [-4, 4]
cov = [[1.0, 0.8], [0.8, 1.0]]
X1 = np.random.multivariate_normal(mean1, cov, 50)
X1 = np.vstack((X1, np.random.multivariate_normal(mean3, cov, 50)))
y1 = np.ones(len(X1))
X2 = np.random.multivariate_normal(mean2, cov, 50)
X2 = np.vstack((X2, np.random.multivariate_normal(mean4, cov, 50)))
y2 = np.ones(len(X2)) * -1
return X1, y1, X2, y2
X1, y1, X2, y2 = gen_non_lin_separable_data()
基于示例数据生成训练集和测试集：
def split_train(X1, y1, X2, y2):
X1_train = X1[:90]
y1_train = y1[:90]
X2_train = X2[:90]
y2_train = y2[:90]
X_train = np.vstack((X1_train, X2_train))
y_train = np.hstack((y1_train, y2_train))
return X_train, y_train
def split_test(X1, y1, X2, y2):
X1_test = X1[90:]
y1_test = y1[90:]
X2_test = X2[90:]
y2_test = y2[90:]
X_test = np.vstack((X1_test, X2_test))
y_test = np.hstack((y1_test, y2_test))
return X_test, y_test
X_train, y_train = split_train(X1, y1, X2, y2)
X_test, y_test = split_test(X1, y1, X2, y2)
print(X_train.shape, y_train.shape, X_test.shape, y_test.shape)
基于cvxopt库定义线性支持向量机的训练过程：
def fit(X, y, C):
n_samples, n_features = X.shape
# Gram matrix
K = np.zeros((n_samples, n_samples))
for i in range(n_samples):
for j in range(n_samples):
K[i, j] = linear_kernel(X[i], X[j])
P = cvxopt.matrix(np.outer(y, y) * K)
q = cvxopt.matrix(np.ones(n_samples) * -1)
A = cvxopt.matrix(y, (1, n_samples))
b = cvxopt.matrix(0.0)
if C is None:
G = cvxopt.matrix(np.diag(np.ones(n_samples) * -1))
h = cvxopt.matrix(np.zeros(n_samples))
else:
tmp1 = np.diag(np.ones(n_samples) * -1)
tmp2 = np.identity(n_samples)
G = cvxopt.matrix(np.vstack((tmp1, tmp2)))
tmp1 = np.zeros(n_samples)
tmp2 = np.ones(n_samples) * C
h = cvxopt.matrix(np.hstack((tmp1, tmp2)))
# solve QP problem
solution = cvxopt.solvers.qp(P, q, G, h, A, b)
# Lagrange multipliers
a = np.ravel(solution['x'])
# Support vectors have non zero lagrange multipliers
sv = a > 1e-5
ind = np.arange(len(a))[sv]
a = a[sv]
sv_x = X[sv]
sv_y = y[sv]
print("%d support vectors out of %d points" % (len(a), n_samples))
# Intercept
b = 0
for n in range(len(a)):
b += sv_y[n]
b -= np.sum(a * sv_y * K[ind[n], sv])
b /= len(a)
# Weight vector
w = np.zeros(n_features)
for n in range(len(a)):
w += a[n] * sv_y[n] * sv[n]
else:
w = None
软间隔支持向量机函数化封装
import numpy as np
from numpy import linalg
import cvxopt
import cvxopt.solvers
import pylab as pl
def linear_kernel(x1, x2):
return np.dot(x1, x2)
class soft_margin_svm(object):
def __init__(self, kernel=linear_kernel, C=None):
self.kernel = kernel
self.C = C
if self.C is not None:
self.C = float(self.C)
def fit(self, X, y):
n_samples, n_features = X.shape
# Gram matrix
K = np.zeros((n_samples, n_samples))
for i in range(n_samples):
for j in range(n_samples):
K[i, j] = self.kernel(X[i], X[j])
P = cvxopt.matrix(np.outer(y, y) * K)
q = cvxopt.matrix(np.ones(n_samples) * -1)
A = cvxopt.matrix(y, (1, n_samples))
b = cvxopt.matrix(0.0)
if self.C is None:
G = cvxopt.matrix(np.diag(np.ones(n_samples) * -1))
h = cvxopt.matrix(np.zeros(n_samples))
else:
tmp1 = np.diag(np.ones(n_samples) * -1)
tmp2 = np.identity(n_samples)
G = cvxopt.matrix(np.vstack((tmp1, tmp2)))
tmp1 = np.zeros(n_samples)
tmp2 = np.ones(n_samples) * self.C
h = cvxopt.matrix(np.hstack((tmp1, tmp2)))
# solve QP problem
solution = cvxopt.solvers.qp(P, q, G, h, A, b)
# Lagrange multipliers
a = np.ravel(solution['x'])
# Support vectors have non zero lagrange multipliers
sv = a > 1e-5
ind = np.arange(len(a))[sv]
self.a = a[sv]
self.sv = X[sv]
self.sv_y = y[sv]
print("%d support vectors out of %d points" % (len(self.a), n_samples))
# Intercept
self.b = 0
for n in range(len(self.a)):
self.b += self.sv_y[n]
self.b -= np.sum(self.a * self.sv_y * K[ind[n], sv])
self.b /= len(self.a)
# Weight vector
if self.kernel == linear_kernel:
self.w = np.zeros(n_features)
for n in range(len(self.a)):
self.w += self.a[n] * self.sv_y[n] * self.sv[n]
else:
self.w = None
def project(self, X):
if self.w is not None:
return np.dot(X, self.w) + self.b
else:
y_predict = np.zeros(len(X))
for i in range(len(X)):
s = 0
for a, sv_y, sv in zip(self.a, self.sv_y, self.sv):
s += a * sv_y * self.kernel(X[i], sv)
y_predict[i] = s
return y_predict + self.b
def predict(self, X):
return np.sign(self.project(X))
if __name__ == "__main__":
def gen_non_lin_separable_data():
mean1 = [-1, 2]
mean2 = [1, -1]
mean3 = [4, -4]
mean4 = [-4, 4]
cov = [[1.0, 0.8], [0.8, 1.0]]
X1 = np.random.multivariate_normal(mean1, cov, 50)
X1 = np.vstack((X1, np.random.multivariate_normal(mean3, cov, 50)))
y1 = np.ones(len(X1))
X2 = np.random.multivariate_normal(mean2, cov, 50)
X2 = np.vstack((X2, np.random.multivariate_normal(mean4, cov, 50)))
y2 = np.ones(len(X2)) * -1
return X1, y1, X2, y2
def gen_lin_separable_overlap_data():
# generate training data in the 2-d case
mean1 = np.array([0, 2])
mean2 = np.array([2, 0])
cov = np.array([[1.5, 1.0], [1.0, 1.5]])
X1 = np.random.multivariate_normal(mean1, cov, 100)
y1 = np.ones(len(X1))
X2 = np.random.multivariate_normal(mean2, cov, 100)
y2 = np.ones(len(X2)) * -1
return X1, y1, X2, y2
def split_train(X1, y1, X2, y2):
X1_train = X1[:90]
y1_train = y1[:90]
X2_train = X2[:90]
y2_train = y2[:90]
X_train = np.vstack((X1_train, X2_train))
y_train = np.hstack((y1_train, y2_train))
return X_train, y_train
def split_test(X1, y1, X2, y2):
X1_test = X1[90:]
y1_test = y1[90:]
X2_test = X2[90:]
y2_test = y2[90:]
X_test = np.vstack((X1_test, X2_test))
y_test = np.hstack((y1_test, y2_test))
return X_test, y_test
def plot_margin(X1_train, X2_train, clf):
def f(x, w, b, c=0):
# given x, return y such that [x,y] in on the line
# w.x + b = c
return (-w[0] * x - b + c) / w[1]
pl.plot(X1_train[:, 0], X1_train[:, 1], "ro")
pl.plot(X2_train[:, 0], X2_train[:, 1], "bo")
pl.scatter(clf.sv[:, 0], clf.sv[:, 1], s=100, c="g")
# w.x + b = 0
a0 = -4;
a1 = f(a0, clf.w, clf.b)
b0 = 4;
b1 = f(b0, clf.w, clf.b)
pl.plot([a0, b0], [a1, b1], "k")
# w.x + b = 1
a0 = -4;
a1 = f(a0, clf.w, clf.b, 1)
b0 = 4;
b1 = f(b0, clf.w, clf.b, 1)
pl.plot([a0, b0], [a1, b1], "k--")
# w.x + b = -1
a0 = -4;
a1 = f(a0, clf.w, clf.b, -1)
b0 = 4;
b1 = f(b0, clf.w, clf.b, -1)
pl.plot([a0, b0], [a1, b1], "k--")
pl.axis("tight")
pl.show()
def plot_contour(X1_train, X2_train, clf):
pl.plot(X1_train[:, 0], X1_train[:, 1], "ro")
pl.plot(X2_train[:, 0], X2_train[:, 1], "bo")
pl.scatter(clf.sv[:, 0], clf.sv[:, 1], s=100, c="g")
X1, X2 = np.meshgrid(np.linspace(-6, 6, 50), np.linspace(-6, 6, 50))
X = np.array([[x1, x2] for x1, x2 in zip(np.ravel(X1), np.ravel(X2))])
Z = clf.project(X).reshape(X1.shape)
pl.contour(X1, X2, Z, [0.0], colors='k', linewidths=1, origin='lower')
pl.contour(X1, X2, Z + 1, [0.0], colors='grey', linewidths=1, origin='lower')
pl.contour(X1, X2, Z - 1, [0.0], colors='grey', linewidths=1, origin='lower')
pl.axis("tight")
pl.show()
def test_soft():
X1, y1, X2, y2 = gen_lin_separable_overlap_data()
X_train, y_train = split_train(X1, y1, X2, y2)
X_test, y_test = split_test(X1, y1, X2, y2)
clf = soft_margin_svm(C=1000.1)
clf.fit(X_train, y_train)
y_predict = clf.predict(X_test)
correct = np.sum(y_predict == y_test)
print("%d out of %d predictions correct" % (correct, len(y_predict)))
plot_contour(X_train[y_train == 1], X_train[y_train == -1], clf)
test_soft()
以上就是本节内容，关于近似线性可分以及软间隔最大化问题，笔者将在下一篇推文中介绍。完整代码文件和数据可参考笔者GitHub地址：
https://github.com/luwill/machine-learning-code-writing
参考资料：
https://pythonprogramming.net/
https://github.com/SmirkCao/Lihang/tree/master/CH07
往期精彩：
数学推导+纯Python实现机器学习算法5：决策树之CART算法
数学推导+纯Python实现机器学习算法4：决策树之ID3算法
往期精彩回顾
适合初学者入门人工智能的路线及资料下载机器学习及深度学习笔记等资料打印机器学习在线手册深度学习笔记专辑《统计学习方法》的代码复现专辑
AI基础下载机器学习的数学基础专辑获取一折本站知识星球优惠券，复制链接直接打开：https://t.zsxq.com/yFQV7am本站qq群1003271085。加入微信群请扫码进群：
3667
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
