支持向量机在高维或无限维空间中构造超平面或超平面集合，其可以用于分类、回归或其他任务。直观来说，分类边界距离最近的训练数据点越远越好，因为这样可以缩小分类器的泛化误差。
调用sklearn.svm的svc函数，将MNIST数据集进行分类，并将整体分类精度输出，这里用了两种预处理的方法（将特征值变成0或者1的数；将特征值变成0-1区间的数）效果不一样，并且分别调用了两种核函数（高斯核函数和多项式核函数）。在支持向量机实验中，将训练集和测试集都等分成10份，并求十份数据集整体分类精度的平均值，这样的结果较为准确客观。可以通过修改惩罚因子C的大小来看不同的效果，并画出图进行比较，C=100的时候效果较为好。
#任务：比较不同的kernel的结果差异，并画出相应的曲线来直观的表示
import struct
from numpy import *
import numpy as np
import time
from sklearn.svm import SVC#C-Support Vector Classification
def read_image(file_name):
#先用二进制方式把文件都读进来
file_handle=open(file_name,"rb") #以二进制打开文档
file_content=file_handle.read() #读取到缓冲区中
offset=0
head = struct.unpack_from('>IIII', file_content, offset) # 取前4个整数，返回一个元组
offset += struct.calcsize('>IIII')
imgNum = head[1] #图片数
rows = head[2] #宽度
cols = head[3] #高度
images=np.empty((imgNum , 784))#empty，是它所常见的数组内的所有元素均为空，没有实际意义，它是创建数组最快的方法
image_size=rows*cols#单个图片的大小
fmt='>' + str(image_size) + 'B'#单个图片的format
for i in range(imgNum):
images[i] = np.array(struct.unpack_from(fmt, file_content, offset))
# images[i] = np.array(struct.unpack_from(fmt, file_content, offset)).reshape((rows, cols))
offset += struct.calcsize(fmt)
return images
#读取标签
def read_label(file_name):
file_handle = open(file_name, "rb") # 以二进制打开文档
file_content = file_handle.read() # 读取到缓冲区中
head = struct.unpack_from('>II', file_content, 0) # 取前2个整数，返回一个元组
offset = struct.calcsize('>II')
labelNum = head[1] # label数
# print(labelNum)
bitsString = '>' + str(labelNum) + 'B' # fmt格式：'>47040000B'
label = struct.unpack_from(bitsString, file_content, offset) # 取data数据，返回一个元组
return np.array(label)
def normalize(data):#图片像素二值化，变成0-1分布
m=data.shape[0]
n=np.array(data).shape[1]
for i in range(m):
for j in range(n):
if data[i,j]!=0:
data[i,j]=1
else:
data[i,j]=0
return data
#另一种归一化的方法，就是将特征值变成[0,1]区间的数
def normalize_new(data):
m=data.shape[0]
n=np.array(data).shape[1]
for i in range(m):
for j in range(n):
data[i,j]=float(data[i,j])/255
return data
def loadDataSet():
train_x_filename="train-images-idx3-ubyte"
train_y_filename="train-labels-idx1-ubyte"
test_x_filename="t10k-images-idx3-ubyte"
test_y_filename="t10k-labels-idx1-ubyte"
train_x=read_image(train_x_filename)#60000*784 的矩阵
train_y=read_label(train_y_filename)#60000*1的矩阵
test_x=read_image(test_x_filename)#10000*784
test_y=read_label(test_y_filename)#10000*1
#可以比较这两种预处理的方式最后得到的结果
# train_x=normalize(train_x)
# test_x=normalize(test_x)
# train_x=normalize_new(train_x)
# test_x=normalize_new(test_x)
return train_x, test_x, train_y, test_y
if __name__=='__main__':
classNum=10
score_train=0.0
score=0.0
temp=0.0
temp_train=0.0
print("Start reading data...")
time1=time.time()
train_x, test_x, train_y, test_y=loadDataSet()
time2=time.time()
print("read data cost",time2-time1,"second")
print("Start training data...")
# clf=SVC(C=1.0,kernel='poly')#多项式核函数
clf = SVC(C=0.01,kernel='rbf')#高斯核函数
#由于每6000个中的每个类的数量都差不多相等，所以直接按照整批划分的方法
for i in range(classNum):
clf.fit(train_x[i*6000:(i+1)*6000,:],train_y[i*6000:(i+1)*6000])
temp=clf.score(test_x[i*1000:(i+1)*1000,:], test_y[i*1000:(i+1)*1000])
# print(temp)
temp_train=clf.score(train_x[i*6000:(i+1)*6000,:],train_y[i*6000:(i+1)*6000])
print(temp_train)
score+=(clf.score(test_x[i*1000:(i+1)*1000,:], test_y[i*1000:(i+1)*1000])/classNum)
score_train+=(temp_train/classNum)
time3 = time.time()
print("score:{:.6f}".format(score))
print("score:{:.6f}".format(score_train))
print("train data cost", time3 - time2, "second")
实验结果：对二值化（normalize）后的不同核函数和C的结果进行了统计和分析。结果如下表所示：
| Parameter |
二值化 |
| { "C":1," " kernel": "poly"} |
{"accuarcy":0.4312,"train time":558.61} |
| {"C":1, "kernel": "rbf"} |
{"accuarcy":0.9212,"train time":163.15} |
| {"C":10, "kernel": "poly"} |
{"accuarcy":0.8802,"train time":277.78} |
| {"C":10, "kernel": "rbf"} |
{"accuarcy":0.9354,"train time":96.07} |
| {"C":100, "kernel": "poly"} |
{"accuarcy":0.9427,"train time":146.43} |
| {"C":100, "kernel": "rbf"} |
{"accuarcy":0.9324,"train time":163.99} |
| {"C":1000,"kernel":"poly"} |
{"accuarcy":0.9519,"train time":132.59} |
| {"C":1000,"kernel":"rbf"} |
{"accuarcy":0.9325,"train time":97.54} |
| {"C":10000,"kernel":"poly"} |
{"accuarcy":0.9518,"train time":115.35} |
| {"C":10000,"kernel":"rbf"} |
{"accuarcy":0.9325,"train time":115.77} |
对于实验的优化方法，可以采用pca主成分分析方法，准确率和速度都有提升，代码如下：
结果截屏：