hardline | Python Fiddle

import numpy as np
import math
import matplotlib.pyplot as plt
import cvxopt
from cvxopt import solvers,matrix

class SVM:
     def __init__(self):
        pass

def lin_Data(self, size, feature, std_dev):
        w0 = np.zeros(1)
        w = 0.5 * np.ones(shape=(feature,1))
        data = np.append((np.random.randn((size/2),feature)+std_dev),(np.random.randn((size/2),feature)-std_dev),axis =0)
        clabel = []

for i in range(0,data.shape[0]):
            if(w0 + np.dot(w.T,data[i].T))> 0:
                clabel.append([1.0])
            else:
                clabel.append([-1.0])
        clabel = np.array(clabel)
        return data,clabel

def gen_graph(self, data, clabel):
        xp = []
        xn = []
        xpo = []
        ypo = []
        xne = []
        yne = []
        for i in range(0,clabel.shape[0]):
            if clabel[i]==1:
              xp.append(data[i])
            else:
              xn.append(data[i])
        for j in range(0,len(xp)):
            xpo.append(xp[j][0])
            ypo.append(xp[j][1])
        for k in range(0,len(xn)):
            xne.append(xn[j][0])
            yne.append(xn[j][1])

plt.plot(xne,yne,'ro')
        plt.plot(xpo,ypo,'bo'),
        plt.xlabel("X")
        plt.ylabel("Y")
        plt.show()

def alpha_solver(self, x, y):
        W = 0
        W0 = 0
        var = x.shape[0]

p = cvxopt.base.matrix(np.ndarray.tolist(np.dot(y.T,y) * np.dot(x,x.T)))
        #print p
        q = cvxopt.base.matrix([-1.0] * var)
        #print q
        g0 = np.zeros((var, var), float)

np.fill_diagonal(g0, -1.0)
        g = cvxopt.base.matrix(np.ndarray.tolist(g0)).T
        h = cvxopt.base.matrix([0.0] * var)
        a = cvxopt.base.matrix(np.ndarray.tolist(y))
        b = cvxopt.base.matrix(0.0)
        ld = solvers.qp(p,q,g,h,a,b)['x']
        alpha_val = cvxopt.base.matrix(ld)

#print alpha_val
        support_vector = []
        for i in range(len(alpha_val)):
            if alpha_val[i] > 0:
                support_vector.append(x[i])

support_vector = np.matrix(support_vector)

#print len(support_vector1)

for j in range(var):
            W += (alpha_val[j] * y[j] * x[j])

for k in range(len(support_vector)):
           W0 += (y[k] - np.dot(W,x[k]))
        #print W, W0
        W0 = W0 / len(support_vector)

pass

if __name__ == '__main__':
    obj = SVM()
    size = 100
    feature = 2
    std_dev = 2.5
    data, clabel = obj.lin_Data(100,2,0.5)
    obj.gen_graph(data,clabel)
    obj.alpha_solver(data,clabel)

Python Fiddle

Python Cloud IDE