机器学习实战(第六章-支持向量机-所有代码与详细注解-python3.7)

于 2020-12-18 09:10:38 发布
阅读量1.1k 收藏 11
点赞数 3
分类专栏： 机器学习 文章标签： 支持向量机 机器学习实战 python3.7 代码与注解 第六章
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37738114/article/details/111352198
版权

感谢：

{

数据可视化参考自：

https://blog.csdn.net/kt513226724/article/details/80413018

}

本次代码修改了原书中的个别bug，增加了原书中没有展示的数据可视化代码

那么，正文就从这里开始啦！（我的代码都是可直接运行的，只要环境正确）

1、svm01_SMO_base.py

'''
简化版的Platt SMO算法
100个测试点，训练需要数秒
数据可视化参考自：
https://blog.csdn.net/kt513226724/article/details/80413018
'''
from numpy import *
import matplotlib.pyplot as plt


# 处理数据
def loadData(filename):
    dataMat = []
    labelMat = []
    fr = open(filename)
    for line in fr.readlines():
        lineArr = line.strip().split('\t')
        dataMat.append([float(lineArr[0]), float(lineArr[1])])
        labelMat.append(float(lineArr[2]))
    return dataMat, labelMat


# 在已选中一个alpha的情况下再随机选择一个不一样的alpha
# m 是可选下标长度，i，j皆为下标
def selectJrand(i, m):
    j = i
    while (j == i):
        j = int(random.uniform(0, m))
    return j


# 调整大于H，或小于L的alpha值
def clipAlpha(aj, H, L):
    if aj > H:
        aj = H
    if aj < L:
        aj = L
    return aj


'''
参数：数据集，类别标签，松弛变量C，容错率， 退出前最大的循环次数
C表示不同优化问题的权重，如果C很大，分类器会力图通过分离超平面将样例都正确区分，如果C很小又很难很好的分类，C值需要平衡两者
'''
def smoSimple(dataMatIn, classLabels, C, toler, maxIter):
    dataMatrix = mat(dataMatIn)
    labelMat = mat(classLabels).transpose()
    b = 0
    m, n = shape(dataMatrix)
    alphas = mat(zeros((m, 1)))
    iter = 0
    while (iter < maxIter):  # 外循环
        alphaPairsChanged = 0
        for i in range(m):  # 内循环
            fXi = float(multiply(alphas, labelMat).T *
                        (dataMatrix * dataMatrix[i, :].T)) + b  # 预测类别，multiply：矩阵对应元素相乘
            Ei = fXi - float(labelMat[i])  # 预测误差 = 预测类别 - 实际类别，如果误差很大就要进行优化，如果在0-C之外，则已在边界，没有优化空间了，无需优化
            # 如果该数据向量可以被优化，则随机选择另一个数据向量，同时进行优化
            if ((labelMat[i] * Ei < -toler) and (alphas[i] < C)) or \
                    ((labelMat[i] * Ei > toler) and (alphas[i] > 0)):
                # 随机选择另一个数据向量
                j = selectJrand(i, m)
                fXj = float(multiply(alphas, labelMat).T *
                            (dataMatrix * dataMatrix[j, :].T)) + b  # 预测类别
                Ej = fXj - float(labelMat[j])  # 预测误差 = 预测类别 - 实际类别
                # 进行深拷贝，便于之后的新旧值比较
                alphaIold = alphas[i].copy()
                alphaJold = alphas[j].copy()
                # 保证alpha在0-C之间
                if labelMat[i] != labelMat[j]:
                    L = max(0, alphas[j] - alphas[i])
                    H = min(C, C + alphas[j] - alphas[i])
                else:
                    '''
                    sum = alphas[i] + alphas[j]
                    如果 sum > C , 则 H = C，L = sum - C
                    如果 sum < C , 则 H = sum, L = 0
                    '''
                    L = max(0, alphas[i] + alphas[j] - C)
                    H = min(C, alphas[i] + alphas[j])
                if L == H:
                    print("L == H")
                    continue
                # eta是alpha[j]的最优修改量
                eta = 2.0 * dataMatrix[i, :] * dataMatrix[j, :].T - \
                      dataMatrix[i, :] * dataMatrix[i, :].T - \
                      dataMatrix[j, :] * dataMatrix[j, :].T
                # eta >= 0的情况比较少，并且优化过程计算复杂，所以此处做了简化处理，直接跳过了
                if eta >= 0:
                    print("eta >= 0")
                    continue
                # 获取alphas[j]的优化值
                alphas[j] -= labelMat[j] * (Ei - Ej) / eta
                alphas[j] = clipAlpha(alphas[j], H, L)
                # 比对原值，看变化是否明显，如果优化并不明显则退出
                if abs(alphas[j] - alphaJold) < 1e-5:
                    print("j not moving enough")
                    continue
                # 对alphas[i]进行和alphas[j]量相同、方向相反的优化
                alphas[i] += labelMat[j] * labelMat[i] * (alphaJold - alphas[j])
                b1 = b - Ei - labelMat[i] * (alphas[i] - alphaIold) * dataMatrix[i, :] * dataMatrix[i, :].T \
                     - labelMat[j] * (alphas[j] - alphaJold) * dataMatrix[i, :] * dataMatrix[j, :].T
                b2 = b - Ej - labelMat[i] * (alphas[i] - alphaIold) * dataMatrix[i, :] * dataMatrix[j, :].T \
                     - labelMat[j] * (alphas[j] - alphaJold) * dataMatrix[j, :] * dataMatrix[j, :].T
                if (0 < alphas[i]) and (C > alphas[i]):
                    b = b1
                elif (0 < alphas[j]) and (C > alphas[j]):
                    b = b2
                else:
                    b = (b1 + b2) / 2.0
                alphaPairsChanged += 1
                print("iter:", iter, "i:", i, ", pairs changed", alphaPairsChanged)

        '''
        如果所有向量都没有优化，则增加迭代数目，继续下一次循环
        当所有的向量都不再优化，并且达到最大迭代次数才退出，一旦有向量优化，iter都要归零
        所以iter存储的是在没有任何alpha改变的情况下遍历数据集的次数
        '''
        if alphaPairsChanged == 0:
            iter += 1
        else:
            iter = 0
        print("iteration number:", iter)
    return b, alphas


# 分析数据，数据可视化
def plot(dataMat, labelMat):
    dataArr = array(dataMat)
    num = shape(dataArr)[0]
    xcord1 = []
    ycord1 = []  # 标签为1的数据点坐标
    xcord0 = []
    ycord0 = []  # 标签为0的数据点坐标
    for i in range(num):
        if int(labelMat[i]) == 1:
            xcord1.append(dataArr[i, 0])
            ycord1.append(dataArr[i, 1])
        else:
            xcord0.append(dataArr[i, 0])
            ycord0.append(dataArr[i, 1])
    fig = plt.figure()
    fig.set_size_inches(18.5, 18.5)
    ax = fig.add_subplot(111)
    ax.scatter(xcord1, ycord1, s=30, c='red', marker='s')
    ax.scatter(xcord0, ycord0, s=30, c='green', marker='o')
    plt.show()

def calcWs(alphas, dataArr, classLabels):
    X = mat(dataArr)
    labelMat = mat(classLabels).transpose()
    m, n = shape(X)
    w = zeros((n, 1))
    for i in range(m):
        # 大部分的alpha为0，少数几个是值不为0的支持向量
        w += multiply(alphas[i] * labelMat[i], X[i, :].T)
    return w

# 画图并圈出支持向量的数据点
def plot_support(dataMat, labelMat, support_points, ws, b):
    dataArr = array(dataMat)
    num = shape(dataArr)[0]
    xcord1 = []
    ycord1 = []  # 标签为1的数据点坐标
    xcord0 = []
    ycord0 = []  # 标签为0的数据点坐标
    for i in range(num):
        if int(labelMat[i]) == 1:
            xcord1.append(dataArr[i, 0])
            ycord1.append(dataArr[i, 1])
        else:
            xcord0.append(dataArr[i, 0])
            ycord0.append(dataArr[i, 1])
    fig = plt.figure()
    fig.set_size_inches(18.5, 18.5)
    ax = fig.add_subplot(111)
    ax.scatter(xcord1, ycord1, s=30, c='red', marker='s')
    ax.scatter(xcord0, ycord0, s=30, c='green', marker='o')

    # 圈出支持向量
    for i in range(len(support_points)):
        x, y = support_points[i][0]
        plt.scatter([x], [y], s=150, c='none', alpha=.5, linewidth=1.5, edgecolor='red')

    # 绘制分离超平面
    x1 = max(dataMat)[0]
    x2 = min(dataMat)[0]
    b = float(b)
    a1 = float(ws[0][0])
    a2 = float(ws[1][0])
    y1, y2 = (-b - a1 * x1) / a2, (-b - a1 * x2) / a2
    plt.plot([x1, x2], [y1, y2])

    ax.grid(True)
    plt.show()


if __name__ == "__main__":
    dataArr, labelArr = loadData("data/testSet.txt")
    # 分析数据，画图
    # plot(dataArr, labelArr)

    b, alphas = smoSimple(dataArr, labelArr, 0.6, 0.001, 40)
    print(b)  # [[-3.84798638]]、[[-3.8362795]]
    # numpy 特有的 "数组过滤"语法，输出大于零的元素组成的矩阵

    ws = calcWs(alphas, dataArr, labelArr)

    print(alphas[alphas > 0])
    # 支持向量的个数
    print(shape(alphas[alphas > 0]))
    # 输出为支持向量的数据点
    support_points = []
    for i in range(100):
        if alphas[i] > 0.0:
            support_points.append([dataArr[i], labelArr[i]])
    print(support_points)
    # 画图并圈出支持向量，画出分离超平面
    plot_support(dataArr, labelArr, support_points, ws, b)

运行结果：

2、svm02_SMO_full.py

'''
Platt SMO 算法完整版
相比简化版，不同在于alpha的选择方式上
应用了一些能够提速的启发式方法
'''
from numpy import *
import matplotlib.pyplot as plt
from svm01_SMO_base import *


# 采用仅包含一个init方法的类来存储各个重要值，方便输入和调用（调用起来比字典还要方便一点）
class Entity:

    def __init__(self, dataMatIn, classLabels, C, toler):
        self.X = dataMatIn
        self.labelMat = classLabels
        self.C = C
        self.toler = toler
        self.m = shape(dataMatIn)[0]
        self.alphas = mat(zeros((self.m, 1)))
        self.b = 0
        # eCache用于缓存误差，第一列是是否有效的标志位，第二列是实际的E值
        self.eCache = mat(zeros((self.m, 2)))


# 计算E值并返回，由于该过程出现频繁，因此单独立为函数
def calcEk(ent, k):
    fXk = float(multiply(ent.alphas, ent.labelMat).T *
                (ent.X * ent.X[k, :].T)) + ent.b
    Ek = fXk - float(ent.labelMat[k])
    return Ek


# 用于选择第二个alpha值，返回索引和误差值
def selectJ(i, ent, Ei):
    maxK = -1
    maxDeltaE = 0
    Ej = 0
    ent.eCache[i] = [1, Ei]
    validEcacheList = nonzero(ent.eCache[:, 0].A)[0]  # 获取有效值的行索引
    # 从现有的有效误差中寻找第二个alpha
    if len(validEcacheList) > 1:
        # 如果现有的有效误差至少两个（除了第一个alpha以外至少还有一个有效值），遍历所有有效误差，寻找步长最大化的那个alpha
        for k in validEcacheList:
            if k == i:
                continue
            Ek = calcEk(ent, k)
            deltaE = abs(Ei - Ek)
            if deltaE > maxDeltaE:
                maxK = k
                maxDeltaE = deltaE
                Ej = Ek
        return maxK, Ej
    else:
        # 如果现有有效误差只有1个（即第一个alpha），则说明这是第一次循环，直接在所有数据里面进行随机选择
        j = selectJrand(i, ent.m)
        Ej = calcEk(ent, j)
    return j, Ej


# 计算误差值，并存入缓存
def updateEk(ent, k):
    Ek = calcEk(ent, k)
    ent.eCache[k] = [1, Ek]


# 内循环
def innerL(i, ent):
    Ei = calcEk(ent, i)
    if ((ent.labelMat[i] * Ei < -ent.toler) and (ent.alphas[i] < ent.C)) or \
            ((ent.labelMat[i] * Ei > ent.toler) and (ent.alphas[i] > 0)):
        j, Ej = selectJ(i, ent, Ei)
        alphaIold = ent.alphas[i].copy()
        alphaJold = ent.alphas[j].copy()
        if ent.labelMat[i] != ent.labelMat[j]:
            L = max(0, ent.alphas[j] - ent.alphas[i])
            H = min(ent.C, ent.C + ent.alphas[j] - ent.alphas[i])
        else:
            L = max(0, ent.alphas[i] + ent.alphas[j] - ent.C)
            H = min(ent.C, ent.alphas[i] + ent.alphas[j])
        if L == H:
            print("L == H")
            return 0
        # eta是alpha[j]的最优修改量
        eta = 2.0 * ent.X[i, :] * ent.X[j, :].T - \
              ent.X[i, :] * ent.X[i, :].T - \
              ent.X[j, :] * ent.X[j, :].T
        # eta >= 0的情况比较少，并且优化过程计算复杂，所以此处做了简化处理，直接跳过了
        if eta >= 0:
            print("eta >= 0")
            return 0
        ent.alphas[j] -= ent.labelMat[j] * (Ei - Ej) / eta
        ent.alphas[j] = clipAlpha(ent.alphas[j], H, L)
        updateEk(ent, j)
        # 比对原值，看变化是否明显，如果优化并不明显则退出
        if abs(ent.alphas[j] - alphaJold) < 1e-5:
            print("j not moving enough")
            return 0
        ent.alphas[i] += ent.labelMat[j] * ent.labelMat[i] * (alphaJold - ent.alphas[j])
        updateEk(ent, i)
        b1 = ent.b - Ei - ent.labelMat[i] * (ent.alphas[i] - alphaIold) * ent.X[i, :] * ent.X[i, :].T \
             - ent.labelMat[j] * (ent.alphas[j] - alphaJold) * ent.X[i, :] * ent.X[j, :].T
        b2 = ent.b - Ej - ent.labelMat[i] * (ent.alphas[i] - alphaIold) * ent.X[i, :] * ent.X[j, :].T \
             - ent.labelMat[j] * (ent.alphas[j] - alphaJold) * ent.X[j, :] * ent.X[j, :].T
        if (0 < ent.alphas[i]) and (ent.C > ent.alphas[i]):
            ent.b = b1
        elif (0 < ent.alphas[j]) and (ent.C > ent.alphas[j]):
            ent.b = b2
        else:
            ent.b = (b1 + b2) / 2.0
        return 1
    else:
        return 0

'''
外循环函数
参数：数据集，类别标签，松弛变量C，容错率， 总共最大的循环次数，核函数
C表示不同优化问题的权重，如果C很大，分类器会力图通过分离超平面将样例都正确区分，如果C很小又很难很好的分类，C值需要平衡两者
'''
def smop(dataMatIn, classLabels, C, toler, maxIter):
    ent = Entity(mat(dataMatIn), mat(classLabels).transpose(), C, toler)
    iter = 0
    entireSet = True
    alphaPairsChanged = 0
    # 循环条件1：iter未超过最大迭代次数 && 循环条件2：上次循环有收获或者遍历方式为遍历所有值
    # 因为最终的遍历方式是趋向于遍历非边界值，如果仍在遍历所有值说明还需要更多的训练
    while iter < maxIter and ((alphaPairsChanged > 0) or entireSet):
        alphaPairsChanged = 0
        # 遍历所有的值
        if entireSet:
            for i in range(ent.m):
                alphaPairsChanged += innerL(i, ent)
            print("fullSet, iter:", iter, ", i:", i, ", pairs changed:", alphaPairsChanged)
            iter += 1
        # 遍历非边界值
        else:
            # 取出非边界值的行索引
            nonBoundIs = nonzero((ent.alphas.A > 0) * (ent.alphas.A < ent.C))[0]
            for i in nonBoundIs:
                alphaPairsChanged += innerL(i, ent)
            print("non-bound, iter:", iter, ", i:", i, ", pairs changed: ", alphaPairsChanged)
            iter += 1
        # 如果上次循环是遍历所有值，那么下次循环改为遍历非边界值
        if entireSet:
            entireSet = False
        # 如果上次循环是遍历非边界值但没有收获，则改为遍历所有值
        elif alphaPairsChanged == 0:
            entireSet = True
        print("iteration number: ", iter)

    return ent.b, ent.alphas


def calcWs(alphas, dataArr, classLabels):
    X = mat(dataArr)
    labelMat = mat(classLabels).transpose()
    m, n = shape(X)
    w = zeros((n, 1))
    for i in range(m):
        # 大部分的alpha为0，少数几个是值不为0的支持向量
        w += multiply(alphas[i] * labelMat[i], X[i, :].T)
    return w


if __name__ == "__main__":
    dataArr, labelArr = loadData("data/testSet.txt")
    # 此处取70%的数据作为训练数据
    trainArr = dataArr[0:70]
    trainLabel = labelArr[0: 70]
    # C表示不同优化问题的权重，如果C很大，分类器会力图通过分离超平面将样例都正确区分，如果C很小又很难很好的分类，C值需要平衡两者
    b, alphas = smop(trainArr, trainLabel, 0.6, 0.001, 30)
    # print(b, alphas) # [[-2.89901748]]

    # 计算w值
    ws = calcWs(alphas, trainArr, trainLabel)
    # print(ws) # [[ 0.7929368 ],[-0.16014993]]
    dataMat = mat(dataArr)
    # 此处将后面的30%数据作为测试数据（因为数据点本身分布得就很均匀，所以准确率很高）
    errorCount = 0.0
    testMat = dataMat[70: 100]
    testLabel = labelArr[70: 100]
    for i in range(len(testMat)):
        predict_label = (testMat[i] * mat(ws) + b)[0][0]
        # print(predict_label)
        if sign(predict_label) != sign(testLabel[i]):
            print("预测错误")
            errorCount += 1.0

    print("错误率为：", (errorCount / len(dataMat)))

 运行结果：

3、svm03_radial_basis_func.py

'''
引入径向基函数（一种常见的核函数）来将低维空间的数据映射到高维空间，从而解决低维空间中的非线性问题
note1：smop函数第一行代码需要改变，是书中没有提及的
note2：如果支持向量太少会得到很差的决策边界，如果支持向量太多也相当于每次都利用整个数据集进行分类，这种分类方法接近于k近邻
'''
from svm02_SMO_full import *

'''
核转换函数
kTup是一个元组，第一个参数是核函数类型，第二个参数是核函数可能需要的可选参数
'''
def kernelTrans(X, A, kTup):
    m, n = shape(X)
    K = mat(zeros((m, 1)))
    if kTup[0] == 'lin':
        K = X * A.T
    elif kTup[0] == 'rbf':
        for j in range(m):
            deltaRow = X[j, :] - A
            K[j] = deltaRow * deltaRow.T
        K = exp(K / (-1 * kTup[1] ** 2))
    else:
        raise NameError('Houston We Have a Problem -- That Kernel is not recognized')
    return K


class Entity:

    def __init__(self, dataMatIn, classLabels, C, toler, kTup):
        self.X = dataMatIn
        self.labelMat = classLabels
        self.C = C
        self.toler = toler
        self.m = shape(dataMatIn)[0]
        self.alphas = mat(zeros((self.m, 1)))
        self.b = 0
        # eCache用于缓存误差，第一列是是否有效的标志位，第二列是实际的E值
        self.eCache = mat(zeros((self.m, 2)))
        self.K = mat(zeros((self.m, self.m)))
        for i in range(self.m):
            self.K[:, i] = kernelTrans(self.X, self.X[i, :], kTup)


# 计算E值并返回，由于该过程出现频繁，因此单独立为函数
def calcEk(ent, k):
    fXk = float(multiply(ent.alphas, ent.labelMat).T * ent.K[:, k] + ent.b)
    Ek = fXk - float(ent.labelMat[k])
    return Ek


# 内循环
# 原来的ent.X[i, :] * ent.X[j, :].T改成了 ent.K[j, j]，只有类似格式进行了变动，其他没变
def innerL(i, ent):
    Ei = calcEk(ent, i)
    if ((ent.labelMat[i] * Ei < -ent.toler) and (ent.alphas[i] < ent.C)) or \
            ((ent.labelMat[i] * Ei > ent.toler) and (ent.alphas[i] > 0)):
        j, Ej = selectJ(i, ent, Ei)
        alphaIold = ent.alphas[i].copy()
        alphaJold = ent.alphas[j].copy()
        if ent.labelMat[i] != ent.labelMat[j]:
            L = max(0, ent.alphas[j] - ent.alphas[i])
            H = min(ent.C, ent.C + ent.alphas[j] - ent.alphas[i])
        else:
            L = max(0, ent.alphas[i] + ent.alphas[j] - ent.C)
            H = min(ent.C, ent.alphas[i] + ent.alphas[j])
        if L == H:
            print("L == H")
            return 0
        # eta是alpha[j]的最优修改量
        eta = 2.0 * ent.K[i, j] - ent.K[i, i] - ent.K[j, j]
        # eta >= 0的情况比较少，并且优化过程计算复杂，所以此处做了简化处理，直接跳过了
        if eta >= 0:
            print("eta >= 0")
            return 0
        ent.alphas[j] -= ent.labelMat[j] * (Ei - Ej) / eta
        ent.alphas[j] = clipAlpha(ent.alphas[j], H, L)
        updateEk(ent, j)
        # 比对原值，看变化是否明显，如果优化并不明显则退出
        if abs(ent.alphas[j] - alphaJold) < 1e-5:
            print("j not moving enough")
            return 0
        ent.alphas[i] += ent.labelMat[j] * ent.labelMat[i] * (alphaJold - ent.alphas[j])
        updateEk(ent, i)
        b1 = ent.b - Ei - ent.labelMat[i] * (ent.alphas[i] - alphaIold) * ent.K[i, i] \
             - ent.labelMat[j] * (ent.alphas[j] - alphaJold) * ent.K[i, j]
        b2 = ent.b - Ej - ent.labelMat[i] * (ent.alphas[i] - alphaIold) * ent.K[i, j] \
             - ent.labelMat[j] * (ent.alphas[j] - alphaJold) * ent.K[j, j]
        if (0 < ent.alphas[i]) and (ent.C > ent.alphas[i]):
            ent.b = b1
        elif (0 < ent.alphas[j]) and (ent.C > ent.alphas[j]):
            ent.b = b2
        else:
            ent.b = (b1 + b2) / 2.0
        return 1
    else:
        return 0


'''
外循环函数
参数：数据集，类别标签，松弛变量C，容错率， 总共最大的循环次数，核函数
C表示不同优化问题的权重，如果C很大，分类器会力图通过分离超平面将样例都正确区分，如果C很小又很难很好的分类，C值需要平衡两者
'''
def smop(dataMatIn, classLabels, C, toler, maxIter, kTup=('lin', 0)):
    ent = Entity(mat(dataMatIn), mat(classLabels).transpose(), C, toler, kTup)
    iter = 0
    entireSet = True
    alphaPairsChanged = 0
    # 循环条件1：iter未超过最大迭代次数 && 循环条件2：上次循环有收获或者遍历方式为遍历所有值
    # 因为最终的遍历方式是趋向于遍历非边界值，如果仍在遍历所有值说明还需要更多的训练
    while iter < maxIter and ((alphaPairsChanged > 0) or entireSet):
        alphaPairsChanged = 0
        # 遍历所有的值
        if entireSet:
            for i in range(ent.m):
                alphaPairsChanged += innerL(i, ent)
            print("fullSet, iter:", iter, ", i:", i, ", pairs changed:", alphaPairsChanged)
            iter += 1
        # 遍历非边界值
        else:
            # 取出非边界值的行索引
            nonBoundIs = nonzero((ent.alphas.A > 0) * (ent.alphas.A < ent.C))[0]
            for i in nonBoundIs:
                alphaPairsChanged += innerL(i, ent)
            print("non-bound, iter:", iter, ", i:", i, ", pairs changed: ", alphaPairsChanged)
            iter += 1
        # 如果上次循环是遍历所有值，那么下次循环改为遍历非边界值
        if entireSet:
            entireSet = False
        # 如果上次循环是遍历非边界值但没有收获，则改为遍历所有值
        elif alphaPairsChanged == 0:
            entireSet = True
        print("iteration number: ", iter)

    return ent.b, ent.alphas


def testRbf(k1=1.3):
    dataArr, labelArr = loadData('data/testSetRBF.txt')
    # 参数：数据集，类别标签，松弛变量C，容错率， 总共最大的循环次数，核函数
    b, alphas = smop(dataArr, labelArr, 200, 0.0001, 10000, ('rbf', k1))
    dataMat = mat(dataArr)
    labelMat = mat(labelArr).transpose()
    svInd = nonzero(alphas.A > 0)[0]  # 支持向量的行索引
    sVs = dataMat[svInd]  # 支持向量的数据点
    labelSV = labelMat[svInd]  # 支持向量的类别标签
    print("There are", shape(sVs)[0], "support vectors")
    m, n = shape(dataMat)
    errorCount = 0
    for i in range(m):
        kernelEval = kernelTrans(sVs, dataMat[i, :], ('rbf', k1))
        predict = kernelEval.T * multiply(labelSV, alphas[svInd]) + b
        if sign(predict) != sign(labelArr[i]):
            errorCount += 1
    print("the training error rate is", (float(errorCount) / m))

    dataArr, labelArr = loadData('data/testSetRBF2.txt')
    dataMat = mat(dataArr)
    m, n = shape(dataMat)
    errorCount = 0
    for i in range(m):
        kernelEval = kernelTrans(sVs, dataMat[i, :], ('rbf', k1))
        predict = kernelEval.T * multiply(labelSV, alphas[svInd]) + b
        if sign(predict) != sign(labelArr[i]):
            errorCount += 1
    print("the test error rate is", (float(errorCount) / m))


if __name__ == "__main__":
    testRbf()

运行结果：

4、svm04_handwriting_recognition.py

'''
基于SVM的数字识别
1、收集数据
2、准备数据：基于二值图像构造向量
3、分析数据：对图像向量进行目测
4、训练算法：采用两种不同的核函数，并对径向基核函数采用不同的设置来运行SMO算法
5、测试算法：测试，计算错误率
6、使用算法：要求一些图像处理的知识
note: 书中最大迭代次数设置为10000，实际运行要很久，此处改小为10。
'''
from svm03_radial_basis_func import *


# 将数字图像信息转换为矩阵
def img2vector(filename):
    returnVect = zeros((1, 1024))
    fr = open(filename)
    for i in range(32):
        lineStr = fr.readline()
        for j in range(32):
            returnVect[0, 32 * i + j] = int(lineStr[j])
    # 将所有数据排在一行存储到 returnVect 矩阵
    return returnVect


'''
将手写识别问题转换为二分类问题，9类别为-1，非9类别为1
'''
def loadImage(dirName):
    from os import listdir
    hwLabels = []
    # 获取所有文件
    trainingFileList = listdir(dirName)
    m = len(trainingFileList)
    trainingMat = zeros((m, 1024))
    for i in range(m):
        fileFullName = trainingFileList[i]
        fileName = fileFullName.split('.')[0]
        # 文件名的前缀表示类别标签
        classNumStr = int(fileName.split('_')[0])
        if classNumStr == 9:
            hwLabels.append(-1)
        else:
            hwLabels.append(1)
        trainingMat[i, :] = img2vector(dirName + '/' + fileFullName)

    return trainingMat, hwLabels


def testDigits(kTup=('rbf', 10)):
    dataArr, labelArr = loadImage('handwriting_image_data2/trainingDigits')
    b, alphas = smop(dataArr, labelArr, 200, 0.0001, 10, kTup)
    dataMat = mat(dataArr)
    labelMat = mat(labelArr).transpose()
    svInd = nonzero(alphas.A > 0)[0]
    sVs = dataMat[svInd]
    labelSV = labelMat[svInd]
    print("There are", shape(sVs)[0], "support vectors")
    m, n = shape(dataMat)
    errorCount = 0
    for i in range(m):
        kernelEval = kernelTrans(sVs, dataMat[i, :], kTup)
        predict = kernelEval.T * multiply(labelSV, alphas[svInd]) + b
        if sign(predict) != sign(labelArr[i]):
            errorCount += 1
    print("the training error rate is", (float(errorCount) / m))

    dataArr, labelArr = loadImage('handwriting_image_data2/testDigits')
    dataMat = mat(dataArr)
    m, n = shape(dataMat)
    errorCount = 0
    for i in range(m):
        kernelEval = kernelTrans(sVs, dataMat[i, :], kTup)
        predict = kernelEval.T * multiply(labelSV, alphas[svInd]) + b
        if sign(predict) != sign(labelArr[i]):
            errorCount += 1
    print("the test error rate is", (float(errorCount) / m))


if __name__ == "__main__":
    testDigits() # training error rate：0.08706467661691543，test error rate：0.05913978494623656

运行结果：（运行稍久）

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

我有明珠一颗
关注
专栏目录
机器学习实战第六章
SinkingStone的博客
08-17 317
支持向量机 说明：本章节所有代码使用版本为Python3 优点：泛化错误率低，计算开销不大，结果易解释 缺点：对参数调节和核函数的选择敏感，原始分类器不加修改仅适用于处理二类问题 适用数据类型：数值型和标称型数据   （有人说）SVM是最好的现成的分类器，“现成”是指分类器不加修饰即可直接使用。这也就意味着数据上应用基本的SVM分类器就可以得到低错误率的结果。SVM对训练集之外的数据点做出很好的分类决策。 基于最大间隔的分隔数据   两组数据分隔的足够开，很容易用一条直线将两组数据点分开，这组数据被
《机器学习实战》第六章学习笔记（SVM）
LZH_12345的博客
04-26 1074
一、支持向量机原理1.1 间隔和支持向量1.2 对偶问题对式6.6，利用拉格朗日乘子法得到其对偶问题：首先得拉格朗日函数：最后利用式6.9消去6.8中的w和b，得对偶问题：二、 SMO算法(Sequential Minimal Optimization)2.1 SMO原理SMO是一个二次规划算法，能高效的解决上述问题。其思路：2.2 简化版SMO算法代码实现:# -*- coding: utf-8...
python 支持向量机代码实例-支持向量机算法及其代码实现
weixin_39792803的博客
11-11 1092
[(转载请注明出处：http://blog.csdn.net/buptgshengod)1.背景知识 前面我们提到的数据集都是线性可分的，这样我们可以用SMO等方法找到支持向量的集合。然而当我们遇到线支持向量机算法及其代码实现支持向量机（SVM），起初由vapnik提出时，是作为寻求最优（在一定程度上）二分类器的一种技术。後来它又被拓展到回归和聚类应用。SVM是一种基于核函数的方法，它通过某些...
[机器学习实战] 阅读第六章
枪枪枪的博客
05-12 544
文章目录决策树CRAT 训练算法公式6-2：CART分类成本函数基尼不纯度、信息熵公式6-3：信息熵回归公式6-4：CART回归成本函数 决策树 决策树模型：https://blog.csdn.net/az9996/article/details/86555029 CRAT 训练算法 公式6-2：CART分类成本函数 基尼不纯度、信息熵 默认使用的是基尼不纯度来进行测量，但是，你可以将超参数cr...
机器学习实战——第六章：支持向量机
mmc2015的专栏
06-24 1420
本系列目的在于总结每一个分类器的特点（优点、缺点、使用数据类型、使用时的注意事项等）。相关代码自己搜。 python：建议使用2.7 python常用函数库：NumPy、scikit-learn等 python集成环境：anaconda 毕业季，玩了20天。 优点： 1、泛化错误率低，计算开销小，结果易解释。
机器学习实战(第四章-朴素贝叶斯-所有代码与详细注解及相关数据文件-python3.7)
12-09
在本资源包中，我们聚焦于机器学习领域中的一个经典算法——朴素贝叶斯（Naive Bayes）的实战应用，特别关注如何使用Python 3.7进行编程实现。朴素贝叶斯是一种基于概率理论的分类方法，因其简单且效率高而在实际...
自己构建的g2p-seq2seq tensorflow2.0.0,python3.7
04-29
**Python 3.7** 是Python编程语言的最新稳定版本，提供了许多改进和新特性，如更好的类型注解支持、数据类（data classes）、异步io改进等。Python因其简洁的语法、丰富的库支持和广泛的应用场景，尤其在科学计算和...
树莓派arrch64 python3.7 dlib dlib-19.19.0-cp37-cp37m-linux-aarch64
最新发布
05-17
dlib库还提供了一套完整的机器学习算法，包括支持向量机、决策树、随机森林等。 **知识点四：aarch64架构** aarch64是ARM公司为64位计算设计的指令集架构。树莓派的某些型号采用这种架构，它提供了更高的性能和内存...
《机器学习实战》 第六章 SVM 学习总结
wanty_chen的博客
04-12 384
SVM：支持向量机,是一种二分类的分类器，通过求解二次优化问题来解决最大化分类间隔。既支持线性分类，又支持非线性分类。线性分类不需要样本数据，非线性分类需要部分样本数据（支持向量）。                                            分隔超平面：将数据集分隔开来的直线。支持向量：离分隔超平面最近的那些点。SVM的核心思想：与逻辑回归类似，使用一组训练集求出一组权...
【读书笔记】【机器学习实战】第六章：决策树
MJ_Lee的博客
03-06 372
阅读书籍为《Hands-On Machine Learning with Scikit-Learn &amp;amp; TensorFlow》王静源等翻译的中文译版《机器学习实战，基于 Scikit-Learn 和 TensorFlow》 本章主要内容有： 代码实现决策树分类和回归 代码决策树可视化 决策树分类和回归的原理 sklearn中的CART训练算法 决策树（DecisionTree）：是一种...
《机器学习实战》 第六章【支持向量机】
十二月未央未眠
10-19 284
支持向量机（Support Vector Machine, SVM）是一类按监督学习（supervised learning）方式对数据进行二元分类的广义线性分类器（generalized linear classifier），其决策边界是对学习样本求解的最大边距超平面（maximum-margin hyperplane） [1-3] 。 这一知识点我花了零零散散的时间看了三天，在理论上还是...
第六章（1.6）机器学习实战——打造属于自己的贝叶斯分类器
两只橙的博客
03-13 1918
github项目地址：https://github.com/liangzhicheng120/bayes 一、简介 项目使用SpringBoot做了一层web封装 项目使用的分词工具hanlp 项目使用JDK8 贝叶斯法则 事件A在事件B(发生)的条件下的概率，与事件B在事件A的条件下的概率是不一样的；然而，这两者是有确定的关系,贝叶斯法则就是这种关系的陈述。 贝叶斯术语 其中L(A...
机器学习实战第六章--支持向量机
qq_34354951的博客
12-04 317
机器学习实战第六章--支持向量机特点SVM 开发流程SMO 伪代码大致如下： 特点 优点：泛化（由具体的、个别的扩大为一般的，就是说：模型训练完后的新样本）错误率低，计算开销不大，结果易理解。 缺点：对参数调节和核函数的选择敏感，原始分类器不加修改仅适合于处理二分类问题。 使用数据类型：数值型和标称型数据。 支持向量(Support Vector)就是离分隔超平面最近的那些点。 SVM 开发流程...
《机器学习实战》第六章 支持向量机
大美mixer的博客
12-22 346
支持向量机 优点： 泛化错误率低，计算开销不大，结果易解释。 缺点： 对参数调节和核函数的选择敏感，原始分类器不加修改仅适用于处理二类问题。 适用数据类型： 数值型和标称型数据。 一般流程： ⑴收集数据：可以使用任意方法。 (2)准备数据：需要数值型数据。 (3)分析数据：有助于可视化分隔超平面。 (4)训练算法：SVM的大部分时间都源自训练，该过程主要...
从示例中了解svm(支持向量机)算法（以及代码）
蓝图的博客
02-14 1483
介绍 掌握机器学习算法根本不是一个神话。大多数初学者都是从学习回归开始的。它易于学习和使用，但这是否能解决我们的目的？当然不是！因为，你可以做的不仅仅是回归！ 把机器学习算法想象成一个装有轴，剑，刀片，弓，匕首等的军械库。你有各种工具，但你应该学会在正确的时间使用它们。作为类比，将“回归”想象成能够有效切割和切割数据的剑，但无法处理高度复杂的数据。相反，“支持向量机”就像一把锋利的刀 - 它适用于...
机器学习实战 支持向量机SVM 代码解析
qq_26879821的博客
04-10 2108
机器学习实战 支持向量机SVM 代码解析 《机器学习实战》用代码实现了算法，理解源代码更有助于我们掌握算法，但是比较适合有一定基础的小伙伴。svm这章代码看起来风轻云淡，实则对于新手来说有（shi）点(fen)晦涩，必须先搞清楚svm原理和具体推导优化步骤。这里推荐一个知乎的回答，支持向量机 SVM（非常详细）。这篇文章只推到了优化目标公式，最后的优化过程用的是序列最小最优化（SMO）算法。具体过...
支持向量机——SVM算法及例子（代码）
chqb89的专栏
04-30 9097
终于拖到最后一天交机器学习作业，选择了SVM算法，之前一直听说过，现在终于有了初步的了解，顺便post到这里分享一下，不足地方请大家指出 本文内容有来自《统计学习算法》（李航 著）第7章——支持向量机 同时也看了Stanford机器学习公开课 概要 支持向量机属于监督学习，是一种二类分类模型，它的基本模型是定义在特征空间上的间隔最大的线性分类器，支持向量机包括核心技巧，这使它成为实
【统计学习方法.李航】SVM支持向量机
heimu24的博客
04-13 648
线性可分支持向量机 定义函数间隔， 定义几何间隔 目标，几何间隔最大化？ 令函数间隔=1，将原问题转为凸二次规划问题 怎么求解凸二次规划呢？原问题不好求？ 所以，拉格朗日，得到对偶问题。求解了对偶问题，得到拉格朗日乘子，利用KKT，得到w,b 所以接下来的目标，求解对偶问题的最优化 怎么求呢？SMO 后来呢，遇到线性不可分的问题怎么办？加松弛变量 再后来，遇到非线性咋整？映射，将实例空间映射到线...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

我有明珠一颗

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值