【大数据】机器学习------支持向量机（SVM)

支持向量机的基本概念和数学公式：

1. 线性可分的支持向量机

对于线性可分的数据集在这里插入图片描述
，其中(x_i \in R^d) 是特征向量
是类别标签，目标是找到一个超平面

，使得对于所有
的样本

，对于所有(y_i = -1) 的样本，(w^T x_i + b \leq -1)。

间隔(M)定义为：在这里插入图片描述

目标是最大化间隔，即最小化(\frac{1}{2}|w|^2)，同时满足![在这里插入图片描述

2. 对偶问题

通过引入拉格朗日乘子(\alpha_i\geq 0)，原问题的拉格朗日函数为：
在这里插入图片描述

对偶问题通过对(L)求(w)和(b)的偏导数并令其为(0)得到：
在这里插入图片描述

对偶问题是最大化
在这里插入图片描述
约束条件为

3. 核函数

核函数在这里插入图片描述
，将数据映射到高维空间。常见的核函数有：

线性核：
多项式核：
径向基函数（RBF）核：

4. 软间隔与正则化

引入松弛变量(\xi_i\geq 0)，目标函数变为：

在这里插入图片描述
约束条件为

在这里插入图片描述

5. 支持向量回归（SVR）

对于回归问题，引入(\epsilon)-不敏感损失函数，目标是找到(w) 和(b) 使得：
在这里插入图片描述

约束条件为
在这里插入图片描述

代码示例（使用 Python 和 `scikit-learn` 库）：

from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC, SVR
from sklearn.metrics import accuracy_score, mean_squared_error
import numpy as np

# 生成示例数据集
X, y = datasets.make_classification(n_samples=100, n_features=2, n_informative=2, n_redundant=0, random_state=42)
y[y == 0] = -1  # 将类别标签转换为 -1 和 1

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 线性 SVM 分类器
svm_classifier = SVC(kernel='linear', C=1.0)
svm_classifier.fit(X_train, y_train)
y_pred = svm_classifier.predict(X_test)
print("线性 SVM 分类准确率:", accuracy_score(y_test, y_pred))

# 多项式核 SVM 分类器
svm_poly_classifier = SVC(kernel='poly', degree=3, C=1.0)
svm_poly_classifier.fit(X_train, y_train)
y_pred_poly = svm_poly_classifier.predict(X_test)
print("多项式核 SVM 分类准确率:", accuracy_score(y_test, y_pred_poly))

# RBF 核 SVM 分类器
svm_rbf_classifier = SVC(kernel='rbf', gamma=0.7, C=1.0)
svm_rbf_classifier.fit(X_train, y_train)
y_pred_rbf = svm_rbf_classifier.predict(X_test)
print("RBF 核 SVM 分类准确率:", accuracy_score(y_test, y_pred_rbf))


# 生成回归数据集
X_reg, y_reg = datasets.make_regression(n_samples=100, n_features=1, noise=0.1, random_state=42)
X_train_reg, X_test_reg, y_train_reg, y_test_reg = train_test_split(X_reg, y_reg, test_size=0.3, random_state=42)

# 支持向量回归
svr = SVR(kernel='rbf', C=1.0, epsilon=0.2)
svr.fit(X_train_reg, y_train_reg)
y_pred_reg = svr.predict(X_test_reg)
print("SVR 均方误差:", mean_squared_error(y_test_reg, y_pred_reg))

在这里插入图片描述

代码解释：

datasets.make_classification：生成分类数据集。

train_test_split：将数据集划分为训练集和测试集。
SVC：支持向量分类器，可指定不同的核函数（linear、poly、rbf 等）和正则化参数 C。
accuracy_score：计算分类准确率。
datasets.make_regression：生成回归数据集。
SVR：支持向量回归，可指定核函数、正则化参数 C 和(\epsilon) 参数。
mean_squared_error：计算均方误差。

手动实现 SVM 分类器（简化版）：

import numpy as np


def linear_kernel(x1, x2):
    return np.dot(x1, x2)


def train_svm(X, y, C=1.0, max_iter=1000, tol=1e-3, kernel=linear_kernel):
    n_samples, n_features = X.shape
    alpha = np.zeros(n_samples)
    b = 0
    eta = 0
    L = 0
    H = 0
    for iteration in range(max_iter):
        num_changed_alphas = 0
        for i in range(n_samples):
            Ei = np.sum(alpha * y * kernel(X, X[i])) + b - y[i]
            if (y[i] * Ei < -tol and alpha[i] < C) or (y[i] * Ei > tol and alpha[i] > 0):
                j = np.random.choice([k for k in range(n_samples) if k!= i])
                Ej = np.sum(alpha * y * kernel(X, X[j])) + b - y[j]
                alpha_i_old = alpha[i]
                alpha_j_old = alpha[j]
                if y[i] == y[j]:
                    L = max(0, alpha[j] + alpha[i] - C)
                    H = min(C, alpha[j] + alpha[i])
                else:
                    L = max(0, alpha[j] - alpha[i])
                    H = min(C, C + alpha[j] - alpha[i])
                if L == H:
                    continue
                eta = 2 * kernel(X[i], X[j]) - kernel(X[i], X[i]) - kernel(X[j], X[j])
                if eta >= 0:
                    continue
                alpha[j] -= y[j] * (Ei - Ej) / eta
                alpha[j] = np.clip(alpha[j], L, H)
                if abs(alpha[j] - alpha_j_old) < tol:
                    continue
                alpha[i] += y[i] * y[j] * (alpha_j_old - alpha[j])
                b1 = b - Ei - y[i] * (alpha[i] - alpha_i_old) * kernel(X[i], X[i]) - y[j] * (alpha[j] - alpha_j_old) * kernel(X[i], X[j])
                b2 = b - Ej - y[i] * (alpha[i] - alpha_i_old) * kernel(X[i], X[j]) - y[j] * (alpha[j] - alpha_j_old) * kernel(X[j], X[j])
                if 0 < alpha[i] < C:
                    b = b1
                elif 0 < alpha[j] < C:
                    b = b2
                else:
                    b = (b1 + b2) / 2
                num_changed_alphas += 1
        if num_changed_alphas == 0:
            break
    return alpha, b


def predict_svm(X, alpha, b, X_train, y_train, kernel=linear_kernel):
    n_samples = X.shape[0]
    y_pred = []
    for i in range(n_samples):
        pred = np.sum(alpha * y_train * kernel(X_train, X[i])) + b
        y_pred.append(np.sign(pred))
    return np.array(y_pred)


# 示例使用
X = np.array([[1, 2], [2, 3], [3, 4], [6, 7], [7, 8], [8, 9]])
y = np.array([1, 1, 1, -1, -1, -1])
alpha, b = train_svm(X, y, C=1.0)
y_pred = predict_svm(X, alpha, b, X, y)
print("手动实现 SVM 预测结果:", y_pred)

在这里插入图片描述

代码解释：

linear_kernel：定义线性核函数。

train_svm：使用 SMO（Sequential Minimal Optimization）算法训练 SVM，更新拉格朗日乘子(\alpha) 和偏置(b)。
predict_svm：使用训练好的(\alpha) 和(b) 进行预测。

在这里插入图片描述