感知机的对偶形式——python3实现

　　运用对偶的（对应原始）感知机算法实现线性分类。

　　参考书目：《统计学习方法》(李航)

　　算法原理：

　　代码实现：

　　环境：win7 32bit + Anaconda3 +spyder

　　和原始算法的实现基本框架是类似的，只是判断和权值的更新算法有点变化。

# -*- coding: utf-8 -*-
"""
Created on Fri Nov 18 01:29:35 2016

@author: Administrator
"""

import numpy as np
from matplotlib import pyplot as plt


# train matrix
def get_train_data():        
    M1 = np.random.random((100,2))
    # 将label加到最后，方便后面操作
    M11 = np.column_stack((M1,np.ones(100)))
    
    M2 = np.random.random((100,2)) - 0.7
    M22 = np.column_stack((M2,np.ones(100)*(-1)))
    # 合并两类，并将位置索引加到最后
    MA = np.vstack((M11,M22))
    MA = np.column_stack((MA,range(0,200)))
    
    # 作图操作
    plt.plot(M1[:,0],M1[:,1], 'ro')
    plt.plot(M2[:,0],M2[:,1], 'go')
    # 为了美观，根据数据点限制之后分类线的范围    
    min_x = np.min(M2)
    max_x = np.max(M1)
    # 分隔x,方便作图
    x = np.linspace(min_x, max_x, 100)
    # 此处返回 x 是为了之后作图方便
    return MA,x

# GRAM计算
def get_gram(MA):
    GRAM = np.empty(shape=(200,200))
    for i in range(len(MA)):
        for j in range(len(MA)):
            GRAM[i,j] = np.dot(MA[i,][:2], MA[j,][:2])
    return GRAM

# 方便在train函数中识别误分类点
def func(alpha,b,xi,yi,yN,index,GRAM):
    pa1 = alpha*yN
    pa2 = GRAM[:,index]
    num = yi*(np.dot(pa1,pa2)+b)
    return num

# 训练training data
def train(MA, alpha, b, GRAM, yN):
    # M 存储每次处理后依旧处于误分类的原始数据
    M = []
    for sample in MA:
        xi = sample[0:2]
        yi = sample[-2]
        index = int(sample[-1])
        # 如果为误分类，改变alpha,b
        # n 为学习率
        if func(alpha,b,xi,yi,yN,index,GRAM) <= 0:
            alpha[index] += n
            b += n*yi
            M.append(sample)
    if len(M) > 0:
        # print('迭代...')
        train(M,  alpha, b, GRAM, yN)
    return alpha,b

# 作出分类线的图
def plot_classify(w,b,x, rate0):
    y = (w[0]*x+b)/((-1)*w[1])
    plt.plot(x,y)
    plt.title('Accuracy = '+str(rate0))

# 随机生成testing data 并作图
def get_test_data():
    M = np.random.random((50,2))
    plt.plot(M[:,0],M[:,1],'*y')
    return M
# 对传入的testing data 的单个样本进行分类
def classify(w,b,test_i):
    if np.sign(np.dot(w,test_i)+b) == 1:
        return 1
    else:
        return 0

# 测试数据，返回正确率
def test(w,b,test_data):
    right_count = 0
    for test_i in test_data:
        classx = classify(w,b,test_i)
        if classx == 1:
            right_count += 1
    rate  = right_count/len(test_data)
    return rate


if __name__=="__main__":
    MA,x= get_train_data()
    test_data = get_test_data()
    GRAM = get_gram(MA)
    yN = MA[:,2]
    xN = MA[:,0:2]
    # 定义初始值
    alpha = [0]*200
    b = 0
    n = 1
    # 初始化最优的正确率
    rate0 = 0


#    print(alpha,b)
#    循环不同的学习率n,寻求最优的学习率，即最终的rate0
#    w0,b0为对应的最优参数
    for i in np.linspace(0.01,1,100):
        n = i
        alpha,b = train(MA, alpha, b, GRAM, yN)
        alphap = np.column_stack((alpha*yN,alpha*yN))
        w = sum(alphap*xN)
        rate = test(w,b,test_data)
        # print(w,b)
        rate = test(w,b,test_data)
        if rate > rate0:
            rate0 = rate
            w0 = w
            b0 = b
            print('Until now, the best result of the accuracy on test data is '+str(rate))
            print('with w='+str(w0)+' b='+str(b0))
            print('---------------------------------------------')
#     在选定最优的学习率后，作图
    plot_classify(w0,b0,x,rate0)
    plt.show()

　　输出：