Python：线性SVM（LinearSVM）

import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.metrics import accuracy_score
from sklearn.model_selection import StratifiedKFold

"""极大梯度下降法"""
class LinearSVM_maxGD():
    def __init__(self):
        self._w = self._b = None

    def fit(self, X, y, C=1, lr=0.01, epoch=10000):
        X = np.asarray(X, np.float)
        y = np.asarray(y, np.float)
        self._w = np.zeros(X.shape[1])
        self._b = 0.

        for _ in range(epoch):
            self._w *= 1 - lr
            err = 1 - y * self.predict(X,True)
            idx = np.argmax(err)
            if err[idx] <= 0:
                continue
                # 当wx+b >=1时，只更新w
                # 当wx+b <1时，更新w和b
            delta = lr * C * y[idx]
            self._w += delta * X[idx]
            self._b += delta


    def predict(self, X, raw=False):
        X = np.asarray(X, np.float)
        y_pred = X.dot(self._w) + self._b
        if raw:
            return y_pred
        return np.sign(y_pred).astype(np.float)


'''Mini-Batch-Gradient-Descent'''
class LinearSVM_MBGD():
    def __init__(self):
        self._w = self._b = None

    def fit(self, X, y, C=1, lr=0.01, batch_size=128 , epoch=10000):
        X = np.asarray(X, np.float)
        y = np.asarray(y, np.float)
        batch_size = min(batch_size, len(y))
        self._w = np.zeros(X.shape[1])
        self._b = 0.

        for _ in range(epoch):
            self._w *= 1 - lr
            err = 1 - y * self.predict(X,True)
            batch = np.argsort(err)[-batch_size:][::-1]
            err = err[batch]
            if err[0] <= 0:
                continue
            mask = err > 0
            batch = batch[mask]
            delta = lr * C * y[batch]
            self._w += np.mean(delta[...,None] * X[batch], axis=0)
            self._b += np.mean(delta)


    def predict(self, X, raw=False):
        X = np.asarray(X, np.float)
        y_pred = X.dot(self._w) + self._b
        if raw:
            return y_pred
        return np.sign(y_pred).astype(np.float)



if __name__ == '__main__':
    X,y = datasets.make_blobs(n_samples=1000, n_features=2, centers=2, cluster_std=[3.0,3.0],random_state=13)
    y[y==0] = -1
    plt.scatter(X[:,0],X[:,1],c=y)
    plt.show()
    Acc_List = []
    SKF = StratifiedKFold(n_splits=5, shuffle=True)
    for train_idx, test_idx in SKF.split(X=X,y=y):
        X_train = X[train_idx]
        y_train = y[train_idx]
        X_test = X[test_idx]
        y_test = y[test_idx]
        model = LinearSVM_MBGD()
        model.fit(X=X_train, y=y_train)
        y_pred = model.predict(X=X_test)
        Acc_List.append(accuracy_score(y_true=y_test, y_pred=y_pred))
    print("平均精度={}".format(np.mean(Acc_List)))
    print("标准差={}".format(np.std(Acc_List)))