• Python | 机器学习之SVM支持向量机

    ​🌈个人主页：Sarapines Programmer
    🔥 系列专栏：《人工智能奇遇记》
    🔖少年有梦不应止于心动，更要付诸行动。

    目录结构

    1. 机器学习之SVM支持向量机概念

    1.1 机器学习

    1.2 SVM支持向量机

    2. SVM支持向量机算法

    2.1 实验目的

    2.2 实验准备

    2.3 实验原理

    2.4 实验内容

    2.5 实验心得

    致读者

    1. 机器学习之SVM支持向量机概念

    1.1 机器学习

    传统编程要求开发者明晰规定计算机执行任务的逻辑和条条框框的规则。然而，在机器学习的魔法领域，我们向计算机系统灌输了海量数据，让它在数据的奔流中领悟模式与法则，自主演绎未来，不再需要手把手的指点迷津。

    机器学习，犹如三千世界的奇幻之旅，分为监督学习、无监督学习和强化学习等多种类型，各具神奇魅力。监督学习如大师传道授业，算法接收标签的训练数据，探索输入与输出的神秘奥秘，以精准预测未知之境。无监督学习则是数据丛林的探险者，勇闯没有标签的领域，寻找隐藏在数据深处的秘密花园。强化学习则是一场与环境的心灵对话，智能体通过交互掌握决策之术，追求最大化的累积奖赏。

    机器学习，如涓涓细流，渗透各行各业。在图像和语音识别、自然语言处理、医疗诊断、金融预测等领域，它在智慧的浪潮中焕发生机，将未来的可能性绘制得更加丰富多彩。

    1.2 SVM支持向量机

    支持向量机（Support Vector Machine，简称SVM）是一种广泛应用于分类和回归分析的监督学习算法。其基本原理是通过在特征空间中找到一个最优的超平面，将不同类别的数据点分隔开。

    在二分类问题中，SVM的目标是找到一个能够将两类数据点分隔开的超平面，使得两侧距离最近的数据点到超平面的距离（即间隔）最大。这些最靠近超平面的数据点被称为支持向量。超平面的选择不仅要使得间隔最大，还要满足不同类别的数据点被正确分类，即位于超平面两侧的点应被分到不同的类别。

    SVM可以通过核函数来处理非线性问题，将数据映射到高维空间，从而找到一个在高维空间中的超平面来完成分类。常用的核函数有线性核、多项式核、径向基核等。

    SVM在实际应用中表现出色，尤其在数据维度较高、样本数量不是很大的情况下。它对于处理线性和非线性问题都有很好的效果，是一个强大而灵活的分类算法。

    机器学习源文件icon-default.png?t=N7T8https://download.csdn.net/download/m0_57532432/88521177?spm=1001.2014.3001.5503

    2. SVM支持向量机算法

    2.1 实验目的

    （1）加深对监督学习的理解和认识；

    （2）掌握SVM分类器的设计方法；

    （3）通过鸢尾花的花萼（sepal）和花瓣（petal）的长和宽，建立SVM分类器来判断样本属于山鸢尾（Iris Setosa）、变色鸢尾（Iris Versicolor）还是维吉尼亚鸢尾（Iris Virginica）。

    2.2 实验准备

    （1）安装机器学习必要库，如NumPy、Pandas、Scikit-learn等；

    （2）配置环境用来运行 Python、Jupyter Notebook和相关库等内容。

    2.3 实验原理

    SVM（支持向量机）的实验原理基于其在特征空间中找到一个最优的超平面，以有效地对数据进行分类。以下是SVM实验的基本原理：

    1. 数据准备： 首先，需要一个带标签的训练数据集，其中包含了输入特征和相应的类别标签。

    2. 超平面的选择： SVM的目标是找到一个超平面，能够将不同类别的数据点分隔开，并使得两侧最靠近超平面的数据点到超平面的距离最大。这个最优的超平面可以通过求解一个凸优化问题来得到。

    3. 间隔最大化： SVM的关键思想是通过间隔最大化来确保分类的鲁棒性。间隔是指超平面两侧距离最近的数据点到超平面的距离。最优的超平面是使得间隔最大的超平面。

    4. 支持向量： 在最优超平面的两侧，存在一些被称为支持向量的数据点。这些支持向量是离超平面最近的数据点，它们对于定义最优超平面至关重要。

    5. 核函数： SVM可以通过核函数来处理非线性问题。核函数能够将数据映射到更高维的空间，使得在这个高维空间中存在一个线性超平面，从而在原始空间中完成非线性分类。

    6. 训练和预测： 通过解决优化问题，找到最优超平面的参数。在训练阶段，算法学习如何调整超平面的参数以实现最佳的分类。在预测阶段，新的数据点通过超平面的位置来进行分类。

    SVM的实验原理主要依赖于数学优化的方法，通过数学模型和凸优化理论来找到一个最优的决策边界，以实现对数据的有效分类。

    2.4 实验内容

    使用Python手动实现SVM支持向量机代码如下：

    1. import numpy as np
    2. from sklearn.model_selection import train_test_split
    3. from sklearn.metrics import confusion_matrix, precision_score, recall_score
    4. from sklearn.preprocessing import StandardScaler
    5. from sklearn.datasets import load_iris
    6.  
    7. class SVM:
    8.     def __init__(self, learning_rate=0.0001, lambda_param=0.1, num_iterations=2000):
    9.         self.learning_rate = learning_rate
    10.         self.lambda_param = lambda_param
    11.         self.num_iterations = num_iterations
    12.         self.W = None
    13.         self.b = None
    14.  
    15.     def fit(self, X, y):
    16.         y = np.where(y <= 0, -1, 1)
    17.         n_samples, n_features = X.shape
    18.         self.W = np.zeros(n_features)
    19.         self.b = 0
    20.  
    21.         for _ in range(self.num_iterations):
    22.             for idx, x_i in enumerate(X):
    23.                 condition = y[idx] * (np.dot(x_i, self.W) - self.b) >= 1
    24.                 if condition:
    25.                     self.W -= self.learning_rate * (2 * self.lambda_param * self.W)
    26.                 else:
    27.                     self.W -= self.learning_rate * (2 * self.lambda_param * self.W - np.dot(x_i, y[idx]))
    28.                     self.b -= self.learning_rate * y[idx]
    29.  
    30.     def predict(self, X):
    31.         linear_output = np.dot(X, self.W) - self.b
    32.         return np.sign(linear_output)

    1. 导入鸢尾花数据集;

    1. # Step 1: 导入鸢尾花数据集
    2. iris = load_iris()
    3. X = iris.data
    4. y = iris.target

    2. 数据归一化

    1. # Step 2: 数据归一化
    2. scaler = StandardScaler()
    3. X = scaler.fit_transform(X)

    3. 训练集和测试数据集划分;

    1. # Step 3: 训练集和测试数据集划分
    2. X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=2022)

    4. 评价分类结果TP、FN、FP、TN以及精确率和召回率;

    1. # Step 4: 评价分类结果
    2. def evaluate_results(y_true, y_pred):
    3.     confusion = confusion_matrix(y_true, y_pred)
    4.     tp = confusion[1, 1]
    5.     fn = confusion[1, 0]
    6.     fp = confusion[0, 1]
    7.     tn = confusion[0, 0]
    8.     
    9.     precision = precision_score(y_true, y_pred, average='weighted')
    10.     recall = recall_score(y_true, y_pred, average='weighted')
    11.     
    12.     print("Confusion Matrix:")
    13.     print(confusion)
    14.     print("True Positives:", tp)
    15.     print("False Negatives:", fn)
    16.     print("False Positives:", fp)
    17.     print("True Negatives:", tn)
    18.     print("Precision:", precision)
    19.     print("Recall:", recall)
    20.  
    21. # 创建SVM对象
    22. svm = SVM()

    5. 加入松弛因子后，与未加松弛因子之前效果做对比。

    1. # Step 5: 加入松弛因子后的对比
    2. svm_no_slack = SVM(lambda_param=0.0)  # 未加入松弛因子
    3. svm_slack = SVM(lambda_param=101)     # 加入松弛因子
    4.  
    5.  
    6. # 训练模型（未加入松弛因子）
    7. svm_no_slack.fit(X_train, y_train)
    8.  
    9. # 预测（未加入松弛因子）
    10. y_pred_slack = svm_no_slack.predict(X_test)
    11.  
    12. # 评价分类结果（未加入松弛因子）
    13. print("=====未加入松弛因子=====")
    14. evaluate_results(y_test, y_pred_slack)
    15.  
    16.  
    17. # 训练模型（加入松弛因子）
    18. svm_slack.fit(X_train, y_train)
    19.  
    20. # 预测（加入松弛因子）
    21. y_pred_slack = svm_slack.predict(X_test)
    22.  
    23. # 评价分类结果（加入松弛因子）
    24. print("=====加入松弛因子后=====")
    25. evaluate_results(y_test, y_pred_slack)

    实验结果

    未加入松弛因子：

    图5-1

    加入松弛因子：

    图5-2

    完整代码如下：

    1. import numpy as np
    2. from sklearn.model_selection import train_test_split
    3. from sklearn.metrics import confusion_matrix, precision_score, recall_score
    4. from sklearn.preprocessing import StandardScaler
    5. from sklearn.datasets import load_iris
    6.  
    7.  
    8. class SVM:
    9.     def __init__(self, learning_rate=0.0001, lambda_param=0.1, num_iterations=2000):
    10.         self.learning_rate = learning_rate
    11.         self.lambda_param = lambda_param
    12.         self.num_iterations = num_iterations
    13.         self.W = None
    14.         self.b = None
    15.  
    16.     def fit(self, X, y):
    17.         y = np.where(y <= 0, -1, 1)
    18.         n_samples, n_features = X.shape
    19.  
    20.         self.W = np.zeros(n_features)
    21.         self.b = 0
    22.  
    23.         for _ in range(self.num_iterations):
    24.             for idx, x_i in enumerate(X):
    25.                 condition = y[idx] * (np.dot(x_i, self.W) - self.b) >= 1
    26.                 if condition:
    27.                     self.W -= self.learning_rate * (2 * self.lambda_param * self.W)
    28.                 else:
    29.                     self.W -= self.learning_rate * (2 * self.lambda_param * self.W - np.dot(x_i, y[idx]))
    30.                     self.b -= self.learning_rate * y[idx]
    31.  
    32.     def predict(self, X):
    33.         linear_output = np.dot(X, self.W) - self.b
    34.         return np.sign(linear_output)
    35.  
    36. # Step 1: 导入鸢尾花数据集
    37. iris = load_iris()
    38. X = iris.data
    39. y = iris.target
    40.  
    41. # Step 2: 数据归一化
    42. scaler = StandardScaler()
    43. X = scaler.fit_transform(X)
    44.  
    45. # Step 3: 训练集和测试数据集划分
    46. X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=2022)
    47.  
    48. # Step 4: 评价分类结果
    49. def evaluate_results(y_true, y_pred):
    50.     confusion = confusion_matrix(y_true, y_pred)
    51.     tp = confusion[1, 1]
    52.     fn = confusion[1, 0]
    53.     fp = confusion[0, 1]
    54.     tn = confusion[0, 0]
    55.     
    56.     precision = precision_score(y_true, y_pred, average='weighted')
    57.     recall = recall_score(y_true, y_pred, average='weighted')
    58.     
    59.     print("Confusion Matrix:")
    60.     print(confusion)
    61.     print("True Positives:", tp)
    62.     print("False Negatives:", fn)
    63.     print("False Positives:", fp)
    64.     print("True Negatives:", tn)
    65.     print("Precision:", precision)
    66.     print("Recall:", recall)
    67.  
    68. # 创建SVM对象
    69. svm = SVM()
    70.  
    71. # Step 5: 加入松弛因子后的对比
    72. svm_no_slack = SVM(lambda_param=0.0)  # 未加入松弛因子
    73. svm_slack = SVM(lambda_param=101)     # 加入松弛因子
    74.  
    75. # 训练模型（未加入松弛因子）
    76. svm_no_slack.fit(X_train, y_train)
    77.  
    78. # 预测（未加入松弛因子）
    79. y_pred_slack = svm_no_slack.predict(X_test)
    80.  
    81. # 评价分类结果（未加入松弛因子）
    82. print("=====未加入松弛因子=====")
    83. evaluate_results(y_test, y_pred_slack)
    84.  
    85.  
    86. # 训练模型（加入松弛因子）
    87. svm_slack.fit(X_train, y_train)
    88.  
    89. # 预测（加入松弛因子）
    90. y_pred_slack = svm_slack.predict(X_test)
    91.  
    92. # 评价分类结果（加入松弛因子）
    93. print("=====加入松弛因子后=====")
    94. evaluate_results(y_test, y_pred_slack)

    代码分析：

    1.导入必要的库和模块

    1. numpy：用于数值计算的Python库。
    2. train_test_split：用于将数据集划分为训练集和测试集的函数。
    3. confusion_matrix、precision_score、recall_score：用于评估分类结果的指标。
    4. StandardScaler：用于数据归一化的类。
    5. load_iris：用于加载鸢尾花数据集的函数。

    2.定义支持向量机类（SVM）

    1. __init__方法：初始化SVM对象的学习率（learning_rate）、正则化参数（lambda_param）和迭代次数（num_iterations）等属性。
    2. fit方法：用于训练SVM模型。接受特征数据（X）和标签（y）作为输入。该方法使用梯度下降法更新模型的权重（W）和偏置（b）。
    3. predict方法：用于预测新的样本。接受特征数据（X）作为输入，通过计算线性输出（linear_output）并对其进行符号化处理，返回预测结果。

    3.加载鸢尾花数据集

    1. 使用load_iris函数加载鸢尾花数据集，将特征数据存储在X中，将标签存储在y中。

    4.数据归一化

    1. 使用StandardScaler类创建一个归一化器对象（scaler）。
    2. 调用fit_transform方法对特征数据进行归一化，将归一化后的数据保存回X中。

    5.训练集和测试数据集划分

    1. 使用train_test_split函数将数据集按照指定的比例划分为训练集和测试集。将训练集特征数据存储在X_train中，训练集标签存储在y_train中，测试集特征数据存储在X_test中，测试集标签存储在y_test中。

    6.评价分类结果的函数

    1. 定义了一个名为evaluate_results的函数，用于评估分类结果。接受真实标签（y_true）和预测标签（y_pred）作为输入。
    2. 使用confusion_matrix函数计算混淆矩阵，并从中提取真阳性（tp）、假阴性（fn）、假阳性（fp）和真阴性（tn）的数量。
    3. 使用precision_score和recall_score函数计算精确率（precision）和召回率（recall）。

    7.输出混淆矩阵、真阳性、假阴性、假阳性、真阴性、精确率和召回率的结果。

    8.创建SVM对象

    1. 使用默认参数创建一个SVM对象（svm）。

    9.加入松弛因子后的对比

    1. 创建两个SVM对象：一个没有加入松弛因子（svm_no_slack）的对象，另一个加入了松弛因子（svm_slack）的对象。
    2. lambda_param参数控制松弛因子的大小，0.0表示没有松弛因子，101表示加入了较大的松弛因子。

    10.训练模型（未加入松弛因子）

    1. 使用训练集数据（X_train和y_train）调用fit方法训练未加入松弛因子的SVM模型。

    11.预测（未加入松弛因子）

    1. 使用测试集数据（X_test）调用predict方法进行预测，将预测结果存储在y_pred_slack中。

    12.评价分类结果（未加入松弛因子）

    1. 调用evaluate_results函数，传入真实标签（y_test）和预测标签（y_pred_slack），输出评价结果。

    13.训练模型（加入松弛因子）

    1. 使用训练集数据（X_train和y_train）调用fit方法训练加入松弛因子的SVM模型。

    14.预测（加入松弛因子）

    1. 使用测试集数据（X_test）调用predict方法进行预测，将预测结果存储在y_pred_slack中。

    15.评价分类结果（加入松弛因子）

    1. 调用evaluate_results函数，传入真实标签（y_test）和预测标签（y_pred_slack），输出评价结果。

    2.5 实验心得

    通过本次支持向量机（SVM）算法实验，我在鸢尾花数据集上进行了分类任务，着重比较了加入松弛因子和未加入松弛因子情况下的分类结果，并深入研究了支持向量机的原理和参数设置。

    支持向量机是用于分类和回归任务的强大算法，其核心思想是寻找最优的超平面，将不同类别的样本分隔开。在实验中，我分别训练了一个未加入松弛因子的SVM模型和一个引入了松弛因子的模型。

    松弛因子的引入允许一些样本存在于超平面错误的一侧，从而提供一定的容错能力。这种机制使模型更具鲁棒性，能够容忍噪声或异常值的存在。通过设置不同的松弛因子参数，我探讨了模型的容错程度，实验中分别使用了松弛因子参数为0（未加入松弛因子）和101（加入较大松弛因子），并采用默认的学习率和迭代次数（0.0001和2000），对数据进行了归一化处理，确保特征具有相似的尺度，避免了某些特征对模型训练的主导影响。

    在训练集和测试集划分方面，我采用了train_test_split函数，将数据集按照70%的训练集和30%的测试集进行划分，以确保模型在训练和测试阶段具有足够的数据支持。

    实验结果显示，适度引入松弛因子可以提高模型的鲁棒性，使其更好地适应噪声或异常值。选择合适的松弛因子参数根据数据集的特点和任务要求，较小的参数适用于清晰数据，而较大的参数适用于复杂数据和存在噪声的情况。这次实验使我更深入了解了支持向量机的应用和参数调优。

    致读者

    风自火出，家人；君子以言有物而行有恒

  • 相关阅读:
    JAVA-JDBC 原理及使用
    蓝桥杯算法赛 第 6 场 小白入门赛 解题报告 | 珂学家 | 简单场 + 元宵节日快乐
    线性代数的本质(六)——线性空间
    自认为最好的rule_of_five
    我的创作纪念日-第256天
    4.4 审计
    [6]辨析云计算交付模型IaaS PaaS SaaS和云部署模型
    Python 实现http server接收mutipart/form-data文件 方法1
    题目：2833.距离原点最远的点
    使用邻接表实现图的创建以及深度遍历、广度遍历、dijkstra算法（C语言）
  • 原文地址：https://blog.csdn.net/m0_57532432/article/details/134326490