使用支持向量机训练mnist数据

 # encoding: utf-8
 import numpy as np
 import matplotlib.pyplot as plt
 import cPickle
 import gzip

 class SVC(object):
     def __init__(self, c=1.0, delta=0.001):  # 初始化
         self.N = 0
         self.delta = delta
         self.X = None
         self.y = None
         self.w = None
         self.wn = 0
         self.K = np.zeros((self.N, self.N))
         self.a = np.zeros((self.N, 1))
         self.b = 0
         self.C = c
         self.stop=1
         self.k=0
         self.cls=0
         self.train_result=[]

     def kernel_function(self,x1, x2):  # 核函数
         return np.dot(x1, x2)

     def kernel_matrix(self, x):  # 核矩阵
         for i in range(0, len(x)):
             for j in range(i, len(x)):
                 self.K[j][i] = self.K[i][j] = self.kernel_function(self.X[i], self.X[j])

     def get_w(self):  # 计算更新w
         ay = self.a * self.y
         w = np.zeros((1, self.wn))
         for i in range(0, self.N):
             w += self.X[i] * ay[i]
         return w

     def get_b(self, a1, a2, a1_old, a2_old):  # 计算更新B
         y1 = self.y[a1]
         y2 = self.y[a2]
         a1_new = self.a[a1]
         a2_new = self.a[a2]
         b1_new = -self.E[a1] - y1 * self.K[a1][a1] * (a1_new - a1_old) - y2 * self.K[a2][a1] * (
             a2_new - a2_old) + self.b
         b2_new = -self.E[a2] - y1 * self.K[a1][a2] * (a1_new - a1_old) - y2 * self.K[a2][a2] * (
             a2_new - a2_old) + self.b
         if (0 < a1_new) and (a1_new < self.C) and (0 < a2_new) and (a2_new < self.C):
             return b1_new[0]
         else:
             return (b1_new[0] + b2_new[0]) / 2.0

     def gx(self, x):  # 判别函数g(x)
         return np.dot(self.w, x) + self.b

     def satisfy_kkt(self, a):  # 判断样本点是否满足kkt条件
         index = a[1]
         if a[0] == 0 and self.y[index] * self.gx(self.X[index]) > 1:
             return 1
         elif a[0] < self.C and self.y[index] * self.gx(self.X[index]) == 1:
             return 1
         elif a[0] == self.C and self.y[index] * self.gx(self.X[index]) < 1:
             return 1
         return 0

     def clip_func(self, a_new, a1_old, a2_old, y1, y2):  # 拉格朗日乘子的裁剪函数
         if (y1 == y2):
             L = max(0, a1_old + a2_old - self.C)
             H = min(self.C, a1_old + a2_old)
         else:
             L = max(0, a2_old - a1_old)
             H = min(self.C, self.C + a2_old - a1_old)
         if a_new < L:
             a_new = L
         if a_new > H:
             a_new = H
         return a_new

     def update_a(self, a1, a2):  # 更新a1,a2
         partial_a2 = self.K[a1][a1] + self.K[a2][a2] - 2 * self.K[a1][a2]
         if partial_a2 <= 1e-9:
             print "error:", partial_a2
         a2_new_unc = self.a[a2] + (self.y[a2] * ((self.E[a1] - self.E[a2]) / partial_a2))
         a2_new = self.clip_func(a2_new_unc, self.a[a1], self.a[a2], self.y[a1], self.y[a2])
         a1_new = self.a[a1] + self.y[a1] * self.y[a2] * (self.a[a2] - a2_new)
         if abs(a1_new - self.a[a1]) < self.delta:
             return 0
         self.a[a1] = a1_new
         self.a[a2] = a2_new
         self.is_update = 1
         return 1

     def update(self, first_a):  # 更新拉格朗日乘子
         for second_a in range(0, self.N):
             if second_a == first_a:
                 continue
             a1_old = self.a[first_a]
             a2_old = self.a[second_a]
             if self.update_a(first_a, second_a) == 0:
                 return
             self.b= self.get_b(first_a, second_a, a1_old, a2_old)
             self.w = self.get_w()
             self.E = [self.gx(self.X[i]) - self.y[i] for i in range(0, self.N)]
             self.stop=0

     def train(self, x, y, max_iternum=100):  # SMO算法
         x_len = len(x)
         self.X = x
         self.N = x_len
         self.wn = len(x[0])
         self.y = np.array(y).reshape((self.N, 1))
         self.K = np.zeros((self.N, self.N))
         self.kernel_matrix(self.X)
         self.b = 0
         self.a = np.zeros((self.N, 1))
         self.w = self.get_w()
         self.E = [self.gx(self.X[i]) - self.y[i] for i in range(0, self.N)]
         self.is_update = 0
         for i in range(0, max_iternum):
             self.stop=1
             data_on_bound = [[x,y] for x,y in zip(self.a, range(0, len(self.a))) if x > 0 and x< self.C]
             if len(data_on_bound) == 0:
                 data_on_bound = [[x,y] for x,y in zip(self.a, range(0, len(self.a)))]
             for data in data_on_bound:
                 if self.satisfy_kkt(data) != 1:
                     self.update(data[1])
             if self.is_update == 0:
                 for data in [[x,y] for x,y in zip(self.a, range(0, len(self.a)))]:
                     if self.satisfy_kkt(data) != 1:
                         self.update(data[1])
             if self.stop:
                 break
         return self.w, self.b

     def fit(self,x, y):  # 训练模型, 一对一法k(k-1)/2个SVM进行多类分类
         self.cls, y = np.unique(y, return_inverse=True)
         self.k=len(self.cls)
         for i in range(self.k):
             for j in range(i):
                 a,b=self.sub_data(x,y,i,j)
                 self.train_result.append([i,j,self.train(a,b)])

     def predict(self,x_new):  # 预测
          p=np.zeros(self.k)
          for i,j,w in self.train_result:
              self.w=w[0]
              self.b=w[1]
              if self.classfy(x_new)==1:
                  p[j]+=1
              else:
                  p[i]+=1
          return self.cls[np.argmax(p)]

     def sub_data(self,x,y,i,j):  # 数据分类
         subx=[]
         suby=[]
         for a,b in zip(x,y):
             if b==i:
                  subx.append(a)
                  suby.append(-1)
             elif b==j:
                  subx.append(a)
                  suby.append(1)
         return subx,suby

     def classfy(self,x_new):  # 预测
         y_new=self.gx(x_new)
         cl = int(np.sign(y_new))
         if cl == 0:
             cl = 1
         return cl

 def load_data():
     f = gzip.open('../data/mnist.pkl.gz', 'rb')
     training_data, validation_data, test_data = cPickle.load(f)
     f.close()
     return (training_data, validation_data, test_data)

 if __name__ == "__main__":
     svc = SVC()
     np.random.seed(0)
     l=1000
     training_data, validation_data, test_data = load_data()
     svc.fit(training_data[0][:l],training_data[1][:l])
     predictions = [svc.predict(a) for a in test_data[0][:l]]
     num_correct = sum(int(a == y) for a, y in zip(predictions, test_data[1][:l]))
     print "%s of %s values correct." % (num_correct, len(test_data[1][:l]))  #72/100  #808/1000  #8194/10000(较慢）