python支持向量机分类器怎么用_python支持向量机分类MNIST数据集

支持向量机在高维或无限维空间中构造超平面或超平面集合，其可以用于分类、回归或其他任务。直观来说，分类边界距离最近的训练数据点越远越好，因为这样可以缩小分类器的泛化误差。

调用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主成分分析方法，准确率和速度都有提升，代码如下：

结果截屏：

原文地址：https://www.cnblogs.com/BlueBlue-Sky/p/9382702.html