26备战秋招day17——机器学习基础

机器学习入门指南：常见算法详解与代码实现

机器学习（Machine Learning, ML）是人工智能（AI）的一个重要分支，旨在通过数据驱动的方法让计算机系统自动学习和改进。对于刚接触机器学习的朋友来说，了解各种算法的基本原理及其实现方法至关重要。本篇文章将通俗易懂地介绍几种常见的机器学习算法，解释其背后的数学原理，并提供简单的代码示例，帮助你更好地理解这些算法的工作机制。

什么是机器学习？
监督学习与无监督学习
常见机器学习算法详解
- 1. 线性回归（Linear Regression）
- 2. 逻辑回归（Logistic Regression）
- 3. 决策树（Decision Tree）
- 4. K近邻算法（K-Nearest Neighbors, KNN）
- 5. 支持向量机（Support Vector Machine, SVM）
- 6. 神经网络（Neural Networks）
结语

什么是机器学习？

机器学习是一种通过数据训练模型，使其能够从数据中学习规律并做出预测或决策的技术。与传统编程不同，机器学习不需要明确编写每一步的操作逻辑，而是通过大量的数据样本让模型自动发现和学习其中的模式。

机器学习的分类

机器学习主要分为以下几类：

监督学习（Supervised Learning）：模型在有标签的数据上进行训练，目标是学习输入与输出之间的映射关系。常见任务包括分类和回归。
无监督学习（Unsupervised Learning）：模型在无标签的数据上进行训练，目标是发现数据的内在结构。常见任务包括聚类和降维。
半监督学习（Semi-Supervised Learning）：结合有标签和无标签的数据进行训练。
强化学习（Reinforcement Learning）：模型通过与环境的互动，通过试错方式学习最优策略。

本文主要聚焦于监督学习中的几种常见算法。

监督学习与无监督学习

监督学习

监督学习依赖于标注的数据进行训练，每个训练样本都包含输入特征和对应的输出标签。模型的目标是学习输入与输出之间的关系，以便在新的、未见过的数据上进行预测。

常见应用：

分类：例如垃圾邮件检测（垃圾邮件 vs. 非垃圾邮件）、图像识别（猫 vs. 狗）。
回归：例如房价预测、股票价格预测。

无监督学习

无监督学习处理的是未标注的数据，模型需要自行发现数据中的结构或模式。

常见应用：

聚类：例如客户分群、图像分割。
降维：例如主成分分析（PCA）、t-SNE，用于数据可视化。

常见机器学习算法详解

下面，我们将详细介绍几种常见的监督学习算法，解释其基本原理，并通过简单的代码示例展示如何实现这些算法。

1. 线性回归（Linear Regression）

原理概述

线性回归是一种用于回归任务的算法，旨在找到输入特征与输出目标之间的线性关系。其目标是拟合一条直线，使得预测值与真实值之间的误差最小。

数学公式

假设我们有一个输入特征向量 $\mathbf{x} = [x_1, x_2, \dots, x_n]$ ，线性回归模型的预测输出 $\hat{y}$ 表示为：

$\hat{y} = \theta_0 + \theta_1 x_1 + \theta_2 x_2 + \dots + \theta_n x_n = \mathbf{\theta}^T \mathbf{x}$

其中， $\mathbf{\theta} = [\theta_0, \theta_1, \dots, \theta_n]$ 是模型参数。

损失函数

线性回归通常使用均方误差（Mean Squared Error, MSE）作为损失函数：

$\text{MSE} = \frac{1}{m} \sum_{i=1}^{m} (y^{(i)} - \hat{y}^{(i)})^2$

代码实现

下面是一个简单的线性回归实现，使用梯度下降法优化模型参数：

import numpy as np
import matplotlib.pyplot as plt# 生成模拟数据
np.random.seed(0)
X = 2 * np.random.rand(100, 1)
y = 4 + 3 * X + np.random.randn(100, 1)# 添加偏置项
X_b = np.c_[np.ones((100, 1)), X]# 初始化参数
theta = np.random.randn(2, 1)# 超参数
learning_rate = 0.1
n_iterations = 1000
m = 100# 梯度下降
for iteration in range(n_iterations):gradients = 2/m * X_b.T.dot(X_b.dot(theta) - y)theta -= learning_rate * gradientsprint(f"学习到的参数: {theta}")# 可视化结果
plt.scatter(X, y)
plt.plot(X, X_b.dot(theta), color='red')
plt.xlabel("X")
plt.ylabel("y")
plt.title("线性回归结果")
plt.show()

解释

数据生成：生成100个随机点，满足 $\displaystyle y = 4 + 3x + \epsilon$ ，其中 $\epsilon$ 为高斯噪声。
添加偏置项：在特征矩阵 $X$ 中添加一列1，用于表示偏置 $\theta_0$ 。
初始化参数：随机初始化模型参数 $\theta$ 。
梯度下降：通过迭代更新参数，逐步减小损失函数值。
可视化：绘制数据点和拟合的直线。

2. 逻辑回归（Logistic Regression）

原理概述

逻辑回归是一种用于分类任务的算法，尤其适用于二分类问题。与线性回归不同，逻辑回归的输出通过逻辑函数（Sigmoid函数）映射到0和1之间，表示属于某个类别的概率。

数学公式

逻辑回归模型的预测概率 $P(y=1|\mathbf{x})$ 表示为：

$P(y=1|\mathbf{x}) = \sigma(\mathbf{\theta}^T \mathbf{x}) = \frac{1}{1 + e^{-\mathbf{\theta}^T \mathbf{x}}}$

其中， $\sigma$ 是Sigmoid函数。

损失函数

逻辑回归使用对数损失（Log Loss）作为损失函数：

$\text{Log Loss} = -\frac{1}{m} \sum_{i=1}^{m} \left[ y^{(i)} \log(\hat{y}^{(i)}) + (1 - y^{(i)}) \log(1 - \hat{y}^{(i)}) \right]$

代码实现

以下是一个简单的逻辑回归实现，使用梯度下降法优化模型参数：

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification# 生成模拟数据
X, y = make_classification(n_samples=100, n_features=2, n_redundant=0, n_clusters_per_class=1, random_state=0)# 添加偏置项
X_b = np.c_[np.ones((100, 1)), X]# 初始化参数
theta = np.zeros(X_b.shape[1])# Sigmoid函数
def sigmoid(z):return 1 / (1 + np.exp(-z))# 超参数
learning_rate = 0.1
n_iterations = 1000
m = X_b.shape[0]# 梯度下降
for iteration in range(n_iterations):z = X_b.dot(theta)predictions = sigmoid(z)gradient = (1/m) * X_b.T.dot(predictions - y)theta -= learning_rate * gradientprint(f"学习到的参数: {theta}")# 可视化结果
plt.scatter(X[:, 0], X[:, 1], c=y, cmap='bwr', alpha=0.7)
x_values = [np.min(X[:, 0])-1, np.max(X[:, 0])+1]
y_values = -(theta[0] + np.array(x_values) * theta[1]) / theta[2]
plt.plot(x_values, y_values, label='决策边界')
plt.xlabel("特征1")
plt.ylabel("特征2")
plt.legend()
plt.title("逻辑回归分类结果")
plt.show()

解释

数据生成：使用 make_classification 生成100个二维特征的二分类数据。
添加偏置项：在特征矩阵 $X$ 中添加一列1，用于表示偏置 $\theta_0$ 。
初始化参数：初始化模型参数 $\theta$ 为零向量。
Sigmoid函数：将线性组合 $\mathbf{\theta}^T \mathbf{x}$ 映射到概率值。
梯度下降：通过迭代更新参数，最小化对数损失。
可视化：绘制数据点及决策边界。

3. 决策树（Decision Tree）

原理概述

决策树是一种用于分类和回归任务的非参数监督学习方法。它通过学习一系列的决策规则，从根节点到叶节点进行分类或预测。决策树的构建基于特征的选择，以最大化信息增益或基尼系数等标准。

信息增益

在分类任务中，决策树通常使用信息增益（Information Gain）或基尼系数（Gini Index）来选择最佳分裂特征。

信息增益公式：

$\text{信息增益} = \text{熵}(\text{父节点}) - \sum \left( \frac{N_i}{N} \times \text{熵}(\text{子节点}_i) \right)$

其中，熵（Entropy）衡量数据的不确定性：

$\text{熵} = - \sum_{i=1}^{c} p_i \log_2 p_i$

代码实现

以下是一个简单的决策树分类器的实现，使用ID3算法选择最佳分裂特征：

import numpy as np
from collections import Counter
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import matplotlib.pyplot as plt# 定义熵计算函数
def entropy(y):counts = Counter(y)probabilities = [count / len(y) for count in counts.values()]return -sum(p * np.log2(p) for p in probabilities if p > 0)# 定义信息增益计算函数
def information_gain(X, y, feature):parent_entropy = entropy(y)values, counts = np.unique(X[:, feature], return_counts=True)weighted_entropy = sum((counts[i]/sum(counts)) * entropy(y[X[:, feature] == v]) for i, v in enumerate(values))return parent_entropy - weighted_entropy# 决策树节点类
class DecisionNode:def __init__(self, feature=None, threshold=None, left=None, right=None, *, value=None):self.feature = featureself.threshold = thresholdself.left = leftself.right = rightself.value = value# 决策树分类器
class DecisionTreeClassifier:def __init__(self, max_depth=5):self.max_depth = max_depthself.root = Nonedef fit(self, X, y, depth=0):n_samples, n_features = X.shapenum_labels = len(set(y))# 终止条件if depth >= self.max_depth or num_labels == 1:leaf_value = self._most_common_label(y)return DecisionNode(value=leaf_value)# 寻找最佳分裂特征和阈值best_gain = -1best_feature = Nonebest_threshold = Nonefor feature in range(n_features):thresholds = np.unique(X[:, feature])for threshold in thresholds:left_idxs = X[:, feature] == thresholdright_idxs = X[:, feature] != thresholdif len(y[left_idxs]) == 0 or len(y[right_idxs]) == 0:continuegain = information_gain(X, y, feature)if gain > best_gain:best_gain = gainbest_feature = featurebest_threshold = thresholdif best_gain == -1:leaf_value = self._most_common_label(y)return DecisionNode(value=leaf_value)# 分裂数据left_idxs = X[:, best_feature] == best_thresholdright_idxs = X[:, best_feature] != best_thresholdleft = self.fit(X[left_idxs], y[left_idxs], depth + 1)right = self.fit(X[right_idxs], y[right_idxs], depth + 1)return DecisionNode(feature=best_feature, threshold=best_threshold, left=left, right=right)def _most_common_label(self, y):counter = Counter(y)return counter.most_common(1)[0][0]def predict(self, X):return np.array([self._traverse_tree(x, self.root) for x in X])def _traverse_tree(self, x, node):if node.value is not None:return node.valueif x[node.feature] == node.threshold:return self._traverse_tree(x, node.left)else:return self._traverse_tree(x, node.right)# 生成模拟数据
iris = load_iris()
X, y = iris.data, iris.target
# 仅选择前两类进行二分类
X, y = X[y != 2], y[y != 2]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)# 训练决策树
tree = DecisionTreeClassifier(max_depth=3)
tree.root = tree.fit(X_train, y_train)# 预测
y_pred = tree.predict(X_test)
print(f"准确率: {accuracy_score(y_test, y_pred)}")# 可视化决策边界（仅使用前两个特征）
def plot_decision_boundary(model, X, y):x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.1),np.arange(y_min, y_max, 0.1))Z = model.predict(np.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape)plt.contourf(xx, yy, Z, alpha=0.3, cmap='bwr')plt.scatter(X[:, 0], X[:, 1], c=y, cmap='bwr', edgecolor='k')plt.xlabel('特征1')plt.ylabel('特征2')plt.title('决策树决策边界')plt.show()plot_decision_boundary(tree, X_test, y_test)

解释

熵与信息增益：通过计算不同特征的熵和信息增益，选择最能减少数据不确定性的特征进行分裂。
决策树节点：DecisionNode类表示树的节点，可以是内部节点（包含分裂特征和阈值）或叶节点（包含预测值）。
构建树：DecisionTreeClassifier类通过递归分裂数据，直到达到最大深度或所有样本属于同一类。
预测：通过遍历决策树，根据样本特征进行分类。
可视化：绘制决策树的决策边界，展示模型的分类效果。

4. K近邻算法（K-Nearest Neighbors, KNN）

原理概述

K近邻算法是一种基于实例的学习方法，用于分类和回归任务。对于一个待分类样本，KNN算法通过计算其与训练集中所有样本的距离，选择最近的K个邻居，根据邻居的类别进行投票，决定待分类样本的类别。

数学公式

KNN算法不需要显式的训练过程，其核心是距离度量。常用的距离度量包括欧氏距离、曼哈顿距离等。

欧氏距离公式：

$d(\mathbf{x}, \mathbf{x'}) = \sqrt{\sum_{i=1}^{n} (x_i - x'_i)^2}$

代码实现

以下是一个简单的KNN分类器的实现，使用欧氏距离进行分类：

import numpy as np
from collections import Counter
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score# KNN分类器
class KNNClassifier:def __init__(self, k=3):self.k = kdef fit(self, X, y):self.X_train = Xself.y_train = ydef predict(self, X):return np.array([self._predict_single(x) for x in X])def _predict_single(self, x):# 计算所有训练样本的距离distances = np.linalg.norm(self.X_train - x, axis=1)# 获取最近的k个邻居k_idxs = distances.argsort()[:self.k]k_neighbor_labels = self.y_train[k_idxs]# 投票决定类别most_common = Counter(k_neighbor_labels).most_common(1)return most_common[0][0]# 载入数据
iris = load_iris()
X, y = iris.data, iris.target
# 仅选择前两类进行二分类
X, y = X[y != 2], y[y != 2]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)# 训练KNN
knn = KNNClassifier(k=3)
knn.fit(X_train, y_train)# 预测
y_pred = knn.predict(X_test)
print(f"准确率: {accuracy_score(y_test, y_pred)}")

解释

距离计算：通过欧氏距离计算待分类样本与训练样本的距离。
选择K个邻居：选择距离最近的K个训练样本。
投票决策：根据K个邻居的类别进行投票，选择票数最多的类别作为预测结果。
训练与预测：KNN不需要显式的训练过程，仅需存储训练数据，通过预测时计算距离进行分类。

5. 支持向量机（Support Vector Machine, SVM）

原理概述

支持向量机是一种用于分类和回归的监督学习模型。SVM的核心思想是找到一个最优超平面，将不同类别的数据分开，并且最大化两类之间的间隔（Margin）。在非线性可分的情况下，SVM通过核函数将数据映射到高维空间，使其线性可分。

数学公式

对于二分类问题，SVM的目标是找到一个超平面 $\mathbf{w}^T \mathbf{x} + b = 0$ ，使得满足以下条件：

$y_i (\mathbf{w}^T \mathbf{x}_i + b) \geq 1, \quad \forall i$

并最大化间隔 $\frac{2}{\|\mathbf{w}\|}$ 。

代码实现

以下是一个简单的线性SVM分类器的实现，使用梯度下降法优化模型参数：

import numpy as np
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score# SVM分类器
class SVMClassifier:def __init__(self, learning_rate=0.001, lambda_param=0.01, n_iters=1000):self.lr = learning_rateself.lambda_param = lambda_paramself.n_iters = n_itersself.w = Noneself.b = Nonedef fit(self, X, y):# 转换标签为 {-1, 1}y_ = np.where(y <= 0, -1, 1)n_samples, n_features = X.shape# 初始化参数self.w = np.zeros(n_features)self.b = 0# 梯度下降for _ in range(self.n_iters):for idx, x_i in enumerate(X):condition = y_[idx] * (np.dot(x_i, self.w) - self.b) >= 1if condition:self.w -= self.lr * (2 * self.lambda_param * self.w)else:self.w -= self.lr * (2 * self.lambda_param * self.w - np.dot(x_i, y_[idx]))self.b -= self.lr * y_[idx]def predict(self, X):approx = np.dot(X, self.w) - self.breturn np.sign(approx)# 生成模拟数据
X, y = make_classification(n_samples=100, n_features=2, n_redundant=0, n_clusters_per_class=1, flip_y=0, random_state=4)# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)# 训练SVM
svm = SVMClassifier()
svm.fit(X_train, y_train)# 预测
y_pred = svm.predict(X_test)
# 将预测标签从 {-1, 1} 转回 {0, 1}
y_pred = np.where(y_pred <= 0, 0, 1)
print(f"准确率: {accuracy_score(y_test, y_pred)}")

解释

标签转换：将标签转换为 ${-1, 1\}$ ，便于计算。
初始化参数：初始化权重向量 $\mathbf{w}$ 和偏置 $b$ 。
梯度下降：通过迭代更新参数，最大化间隔并最小化分类错误。
预测：通过计算 $\mathbf{w}^T \mathbf{x} - b$ 的符号，决定样本的类别。

6. 神经网络（Neural Networks）

原理概述

神经网络是一类模拟人脑神经元结构的机器学习模型，擅长处理复杂的非线性关系。基本的神经网络由输入层、隐藏层和输出层组成，每一层由若干神经元（节点）构成，神经元之间通过权重连接。

数学公式

一个简单的前馈神经网络的计算过程如下：

$\mathbf{z}^{(l)} = \mathbf{W}^{(l)} \mathbf{a}^{(l-1)} + \mathbf{b}^{(l)}$
$\mathbf{a}^{(l)} = \sigma(\mathbf{z}^{(l)})$

其中， $\mathbf{W}^{(l)}$ 和 $\mathbf{b}^{(l)}$ 是第 $l$ 层的权重和偏置， $\sigma$ 是激活函数（如ReLU、Sigmoid）， $\mathbf{a}^{(l)}$ 是第 $l$ 层的输出。

代码实现

以下是一个简单的单隐藏层神经网络，用于二分类任务的实现：

import numpy as np
from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import matplotlib.pyplot as plt# 激活函数及其导数
def sigmoid(z):return 1 / (1 + np.exp(-z))def sigmoid_derivative(a):return a * (1 - a)# 神经网络类
class NeuralNetwork:def __init__(self, input_size, hidden_size, output_size):# 初始化权重self.W1 = np.random.randn(hidden_size, input_size) * 0.01self.b1 = np.zeros((hidden_size, 1))self.W2 = np.random.randn(output_size, hidden_size) * 0.01self.b2 = np.zeros((output_size, 1))def forward(self, X):self.Z1 = np.dot(self.W1, X.T) + self.b1self.A1 = sigmoid(self.Z1)self.Z2 = np.dot(self.W2, self.A1) + self.b2self.A2 = sigmoid(self.Z2)return self.A2def compute_loss(self, Y, A2):m = Y.shape[0]loss = - (1/m) * np.sum(Y.T * np.log(A2) + (1 - Y.T) * np.log(1 - A2))return lossdef backward(self, X, Y):m = X.shape[0]Y = Y.reshape(1, m)dZ2 = self.A2 - YdW2 = (1/m) * np.dot(dZ2, self.A1.T)db2 = (1/m) * np.sum(dZ2, axis=1, keepdims=True)dA1 = np.dot(self.W2.T, dZ2)dZ1 = dA1 * sigmoid_derivative(self.A1)dW1 = (1/m) * np.dot(dZ1, X)db1 = (1/m) * np.sum(dZ1, axis=1, keepdims=True)# 更新参数self.W1 -= learning_rate * dW1self.b1 -= learning_rate * db1self.W2 -= learning_rate * dW2self.b2 -= learning_rate * db2def train(self, X, Y, epochs=10000, learning_rate=0.1):self.learning_rate = learning_ratefor epoch in range(epochs):A2 = self.forward(X)loss = self.compute_loss(Y, A2)self.backward(X, Y)if epoch % 1000 == 0:print(f"Epoch {epoch}, Loss: {loss}")def predict(self, X):A2 = self.forward(X)return (A2 > 0.5).astype(int).flatten()# 生成模拟数据
X, y = make_moons(n_samples=1000, noise=0.2, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)# 训练神经网络
nn = NeuralNetwork(input_size=2, hidden_size=5, output_size=1)
nn.train(X_train, y_train, epochs=10000, learning_rate=0.1)# 预测
y_pred = nn.predict(X_test)
print(f"准确率: {accuracy_score(y_test, y_pred)}")# 可视化决策边界
def plot_decision_boundary_nn(model, X, y):x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1xx, yy = np.meshgrid(np.linspace(x_min, x_max, 100),np.linspace(y_min, y_max, 100))grid = np.c_[xx.ravel(), yy.ravel()]Z = model.predict(grid).reshape(xx.shape)plt.contourf(xx, yy, Z, alpha=0.3, cmap='bwr')plt.scatter(X[:, 0], X[:, 1], c=y, cmap='bwr', edgecolor='k')plt.xlabel('特征1')plt.ylabel('特征2')plt.title('神经网络决策边界')plt.show()plot_decision_boundary_nn(nn, X_test, y_test)