请你在不调用python支持向量机的库的情况下帮我用python编写一个支持向量机分类的程序

好的，下面是一个简单的支持向量机分类程序，使用的是Python和NumPy库：

import numpy as np

class SVM:
    def __init__(self, C=1.0, kernel='linear', degree=3, gamma='auto', coef0=0.0):
        self.C = C
        self.kernel = kernel
        self.degree = degree
        self.gamma = gamma
        self.coef0 = coef0
        self.alpha = None
        self.b = None
        
    def fit(self, X, y):
        n_samples, n_features = X.shape
        
        if self.gamma == 'auto':
            self.gamma = 1 / n_features
        
        if self.kernel == 'linear':
            K = np.dot(X, X.T)
        elif self.kernel == 'poly':
            K = (self.gamma * np.dot(X, X.T) + self.coef0) ** self.degree
        elif self.kernel == 'rbf':
            K = np.zeros((n_samples, n_samples))
            for i in range(n_samples):
                for j in range(n_samples):
                    K[i,j] = np.exp(-self.gamma * np.linalg.norm(X[i]-X[j])**2)
        else:
            raise ValueError('Unsupported kernel function')
        
        P = np.outer(y, y) * K
        q = -np.ones(n_samples)
        G = np.vstack((-np.eye(n_samples), np.eye(n_samples)))
        h = np.hstack((np.zeros(n_samples), np.ones(n_samples) * self.C))
        A = y.reshape(1, -1)
        b = np.zeros(1)
        
        from cvxopt import solvers
        solvers.options['show_progress'] = False
        sol = solvers.qp(matrix(P), matrix(q), matrix(G), matrix(h), matrix(A), matrix(b))
        alpha = np.array(sol['x']).flatten()
        
        support_vectors = alpha > 1e-5
        self.alpha = alpha[support_vectors]
        self.b = y[support_vectors] - np.dot(K[support_vectors][:,support_vectors], self.alpha * y[support_vectors])
        self.b = np.mean(self.b)
        self.support_vectors = X[support_vectors]
        self.support_vectors_y = y[support_vectors]
        
    def predict(self, X):
        if self.kernel == 'linear':
            scores = np.dot(X, self.support_vectors.T)
        elif self.kernel == 'poly':
            scores = (self.gamma * np.dot(X, self.support_vectors.T) + self.coef0) ** self.degree
        elif self.kernel == 'rbf':
            scores = np.zeros((X.shape[0], self.support_vectors.shape[0]))
            for i in range(X.shape[0]):
                for j in range(self.support_vectors.shape[0]):
                    scores[i,j] = np.exp(-self.gamma * np.linalg.norm(X[i]-self.support_vectors[j])**2)
        else:
            raise ValueError('Unsupported kernel function')
        
        return np.sign(np.dot(scores, self.alpha * self.support_vectors_y) + self.b)

这个程序实现了一个简单的支持向量机分类器，包含了线性、多项式和高斯核函数三种不同的核函数。使用的是凸优化库cvxopt来求解支持向量机的优化问题。可以通过调用SVM类的fit方法来训练模型，然后通过调用predict方法来进行预测。