十大分类算法
1、引言
小屌丝：鱼哥，分类算法是不是还有没告诉我的？
小鱼：没有啊？
小屌丝：那你才跟我说了5个分类算法
小鱼：不少了
小屌丝：明明是有10个，
小鱼：没有啊
小屌丝：你还骗我
小鱼：没有啊
小屌丝：咱俩为啥没坦诚相待吗
小鱼：没有啊
小屌丝： 你还说没有， 不准说没有
小鱼：…
小屌丝：… 那你在帮我讲一讲：梯度提升机、AdaBoost等等呗
小鱼：好吧，反正现在还有点时间。
2、分类算法总结
2.1 K近邻算法
2.1.1 核心原理
K近邻算法是一种基本分类与回归方法。
它的工作原理非常简单：对于一个新的实例，根据距离度量找出训练集中与该实例最近的K个实例，然后基于这K个实例的信息来进行预测。
2.1.2 算法公式
没有固定的算法公式，但常用的距离度量是欧氏距离，计算公式为 d ( x , y ) = ∑ i = 1 n ( x i − y i ) 2 d(x, y) = \sqrt{\sum_{i=1}^{n} (x_i - y_i)^2} d(x,y)=∑i=1n(xi−yi)2。
2.1.3 代码实例
代码实例
# -*- coding:utf-8 -*-
# @Time : 2024-04-04
# @Author : Carl_DJ
from sklearn.neighbors import KNeighborsClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
# 加载数据集
iris = load_iris()
X = iris.data
y = iris.target
# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
# 创建KNN模型并训练
model = KNeighborsClassifier(n_neighbors=3)
model.fit(X_train, y_train)
# 进行预测
predictions = model.predict(X_test)
print(predictions)
2.2 神经网络
2.2.1 核心原理
神经网络受人脑结构的启发，由大量的节点（或称“神经元”）互相连接构成。
每个神经元接收输入，进行加权求和，然后通过一个非线性激活函数产生输出。
2.2.2 算法公式
节点输出 o = σ ( ∑ i = 1 n w i x i + b ) o = \sigma(\sum_{i=1}^{n}w_ix_i + b) o=σ(∑i=1nwixi+b)，其中 σ \sigma σ是激活函数， w i w_i wi是权重， x i x_i xi是输入， b b b是偏置项。
2.2.3 代码实例
代码实例
# -*- coding:utf-8 -*-
# @Time : 2024-04-04
# @Author : Carl_DJ
from sklearn.neural_network import MLPClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
iris = load_iris()
X = iris.data
y = iris.target
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
model = MLPClassifier(hidden_layer_sizes=(100,), max_iter=300)
model.fit(X_train, y_train)
predictions = model.predict(X_test)
print(predictions)
2.3 梯度提升机
2.3.1 核心原理
梯度提升机是一种集成学习方法，通过逐步添加模型（通常是决策树）来纠正前一步的错误。每一步都在减少模型的损失函数。
2.3.2 算法公式
更新步骤为 F m ( x ) = F m − 1 ( x ) + ρ m h m ( x ) F_{m}(x) = F_{m-1}(x) + \rho_m h_m(x) Fm(x)=Fm−1(x)+ρmhm(x)，其中 h m ( x ) h_m(x) hm(x)是本轮学习到的模型， ρ m \rho_m ρm是学习率。
2.3.3 代码实例
代码实例
# -*- coding:utf-8 -*-
# @Time : 2024-04-04
# @Author : Carl_DJ
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
iris = load_iris()
X = iris.data
y = iris.target
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
model = GradientBoostingClassifier()
model.fit(X_train, y_train)
predictions = model.predict(X_test)
print(predictions)
2.4 AdaBoost
2.4.1 核心原理
AdaBoost是一种自适应的集成学习算法，通过增加之前分类器错误分类的样本的权重，来让新的分类器更加关注这些样本。
2.4.2 算法公式
权重更新公式为 w i ( t + 1 ) = w i ( t ) e α t y i h t ( x i ) w_{i}^{(t+1)} = w_i^{(t)}e^{\alpha_t y_i h_t(x_i)} wi(t+1)=wi(t)eαtyiht(xi)，其中 y i y_i yi是真实标签， h t ( x i ) h_t(x_i) ht(xi)是分类器的预测， α t \alpha_t αt是分类器的权重。
2.4.3 代码实例
代码实例
# -*- coding:utf-8 -*-
# @Time : 2024-04-04
# @Author : Carl_DJ
from sklearn.ensemble import AdaBoostClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
iris = load_iris()
X = iris.data
y = iris.target
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
model = AdaBoostClassifier(n_estimators=100)
model.fit(X_train, y_train)
predictions = model.predict(X_test)
print(predictions)
2.5 深度学习
2.5.1 核心原理
深度学习是机器学习的一个子领域，它使用由多层处理单元组成的深度神经网络对大量数据进行特征学习。
2.5.2 计算公式
神经网络的输出计算是通过前向传播过程实现的，其中包含多个层次的计算。
每一层的输出可以作为下一层的输入。在最简单的情况下，即一个单层感知器（单层神经网络）中，输出的计算公式如下：
[ o = σ ( ∑ i = 1 n w i x i + b ) ] [o = \sigma(\sum_{i=1}^{n}w_ix_i + b)] [o=σ(i=1∑nwixi+b)]
其中：
- ( o ) (o) (o) 是输出，
- ( σ ) (\sigma) (σ) 是激活函数，常见的激活函数包括 S i g m o i d Sigmoid Sigmoid、 R e L U ReLU ReLU、 T a n h Tanh Tanh等，
- ( w i ) (w_i) (wi) 是权重，
- ( x i ) (x_i) (xi) 是输入值，
- ( b ) (b) (b) 是偏置项，
- ( n ) (n) (n) 是输入的数量。
2.5.3 代码实例
代码实例
# -*- coding:utf-8 -*-
# @Time : 2024-01-21
# @Author : Carl_DJ
import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
# 定义神经网络模型
class NeuralNetwork(nn.Module):
def __init__(self):
super(NeuralNetwork, self).__init__()
self.fc1 = nn.Linear(28 * 28, 128)
self.relu = nn.ReLU()
self.fc2 = nn.Linear(128, 64)
self.fc3 = nn.Linear(64, 10)
def forward(self, x):
x = x.view(-1, 28 * 28)
x = self.relu(self.fc1(x))
x = self.relu(self.fc2(x))
x = self.fc3(x)
return x
# 加载MNIST数据集并进行预处理
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5,), (0.5,))
])
trainset = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform)
trainloader = DataLoader(trainset, batch_size=32, shuffle=True)
# 实例化神经网络模型、损失函数和优化器
model = NeuralNetwork()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
# 训练神经网络模型
for epoch in range(5): # 假设训练5个epoch
running_loss = 0.0
for i, data in enumerate(trainloader, 0):
inputs, labels = data
optimizer.zero_grad()
outputs = model(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
running_loss += loss.item()
if i % 1000 == 999:
print('[%d, %5d] loss: %.3f' %
(epoch + 1, i + 1, running_loss / 1000))
running_loss = 0.0
print('Finished Training')
# 绘制神经网络结构图
import torchviz
x = torch.randn(1, 1, 28, 28) # 创建一个虚拟输入张量
torchviz.make_dot(model(x), params=dict(model.named_parameters())).render("model_plot", format="png", cleanup=True)
# 测试神经网络模型
testset = torchvision.datasets.MNIST(root='./data', train=False, download=True, transform=transform)
testloader = DataLoader(testset, batch_size=32, shuffle=False)
correct = 0
total = 0
with torch.no_grad():
for data in testloader:
inputs, labels = data
outputs = model(inputs)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
print('Accuracy on the test set: %d %%' % (100 * correct / total))
3、总结
K近邻算法、神经网络、梯度提升机、AdaBoost和深度学习各有优势和应用场景。
选择合适的分类算法需要根据具体问题、数据量、特征维度以及性能要求等因素综合考虑。
- 敲黑板：
十大分类算法上，则点击此处即可到达：《【机器学习】一文掌握机器学习十大分类算法(上)。》
我是小鱼：
- CSDN 博客专家；
- 阿里云 专家博主；
- 51CTO博客专家；
- 企业认证金牌面试官；
- 多个名企认证&特邀讲师等；
- 名企签约职场面试培训、职场规划师；
- 多个国内主流技术社区的认证专家博主；
- 多款主流产品(阿里云等)测评一、二等奖获得者；
关注小鱼，学习【机器学习】&【深度学习】领域的知识。
