【机器学习】一文掌握机器学习十大分类算法(下)。-分类算法总结

2.1 K近邻算法

2.1.1 核心原理

K近邻算法是一种基本分类与回归方法。

它的工作原理非常简单：对于一个新的实例，根据距离度量找出训练集中与该实例最近的K个实例，然后基于这K个实例的信息来进行预测。

2.1.2 算法公式

没有固定的算法公式，但常用的距离度量是欧氏距离，计算公式为 $d(x,y)=\sqrt{{\sum }_{i=1}^n(x_i-y_i{)}^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=\sigma ({\sum }_{i=1}^n{w}_i{x}_i+b)$，其中$\sigma$是激活函数，$w_i$是权重，$x_i$是输入，$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)+{\rho }_m{h}_m(x)$，其中$h_m(x)$是本轮学习到的模型，${\rho }_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}^{{\alpha }_t{y}_i{h}_t(x_i)}$，其中$y_i$是真实标签，$h_t(x_i)$是分类器的预测，${\alpha }_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=\sigma (\sum _{i=1}^n{w}_i{x}_i+b)]$$

其中：

• $(o)$ 是输出，
• $(\sigma )$ 是激活函数，常见的激活函数包括$Sigmoid$、$ReLU$、$Tanh$等，
• $(w_i)$ 是权重，
• $(x_i)$ 是输入值，
• $(b)$ 是偏置项，
• $(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))