DNN代码实战

DNN的原理

神经网络通过学习大量样本的输入与输出特征之间的关系，以拟合出输入与输出之间的方程，学习完成后，只给它输入特征，它便会可以给出输出特征。神经网络可以分为这么几步：划分数据集、训练网络、测试网络、使用网络。

划分数据集

数据集里每个样本必须包含输入与输出，将数据集按一定的比例划分为训练集与测试集，分别用于训练网络与测试网络

# 生成数据集
X1 = torch.rand(10000, 1)
X2 = torch.rand(10000, 1)
X3 = torch.rand(10000, 1)
Y1 = ((X1 + X2 + X3) < 1).float()
Y2 = ((1 < (X1 + X2 + X3)) & ((X1 + X2 + X3) < 2))
Y3 = ((X1 + X2 + X3) > 2).float()
# 整合数据集
Data = torch.cat([X1, X2, X3, Y1, Y1, Y2, Y3], axis=1)
# Data = Data.to('cuda: 0 ')
# 划分训练集和测试集
train_size = int(len(Data) * 0.7)
test_size = len(Data) - train_size
Data = Data[torch.randperm(Data.size(0)), :]
train_Data = Data[:train_size, :]
test_Data = Data[train_size:, :]

训练网络

神经网络的训练过程，就是经过很多次前向传播与反向传播的轮回，最终不断调整其内部参数（权重 ω 与偏置 b），以拟合任意复杂函数的过程。内部参数一开始是随机的（如 Xavier 初始值、He 初始值），最终会不断优化到最佳。还有一些训练网络前就要设好的外部参数：网络的层数、每个隐藏层的节点数、每个节点的激活函数类型、学习率、轮回次数、每次轮回的样本数等等。

业界习惯把内部参数称为参数，外部参数称为超参数。

# 定义DNN类
class DNN(nn.Module):
    def __init__(self):
        super(DNN, self).__init__()
        self.net = nn.Sequential(
            nn.Linear(3, 5), nn.ReLU(),
            nn.Linear(5, 5), nn.ReLU(),
            nn.Linear(5, 5), nn.ReLU(),
            nn.Linear(5, 3)
        )
    def forward(self, x):
        y = self.net(x)
        return y
# 创建子类的实例
model = DNN()
# 损失函数
loss_fn = nn.MSELoss()
# 优化算法
learning_rate = 0.01
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)

# 训练网络
epochs = 100
losses = []
# 给训练集划分输入和输出
X = train_Data[:, :3]
Y = train_Data[:, -3:]
for epoch in range(epochs):
    Pred = model(X)
    loss = loss_fn(Pred, Y)
    losses.append(loss.item())
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
Fig = plt.figure()
plt.plot(range(epochs),losses)
plt.ylabel('loss')
plt.xlabel('epoch')
plt.show()

测试网络

为了防止训练的网络过拟合，因此需要拿出少量的样本进行测试。过拟合的意思是：网络优化好的内部参数只能对训练样本有效，换成其它就寄。当网络训练好后，拿出测试集的输入，进行 1 次前向传播后，将预测的输出与测试集的真实输出进行对比，查看准确率。

# 测试网络
X = test_Data[:, :3]
Y = test_Data[:, -3:]
with torch.no_grad():
    Pred = model(X)
    Pred[:, torch.argmax(Pred, axis=1)] = 1
    Pred[Pred != 1] = 0
    correct = torch.sum((Pred == Y).all(1))
    total = Y.size(0)
    print(f'测试集准确度:{100*correct/total}%')

使用网络

真正使用网络进行预测时，样本只知输入，不知输出。直接将样本的输入进行 1 次前向传播，即可得到预测的输出。

# 保存网络
torch.save(model, 'DNN.path')
new_model = torch.load('DNN.path')

完整代码

import torch
import torch.nn as nn
import matplotlib.pyplot as plt

# 生成数据集
X1 = torch.rand(10000, 1)
X2 = torch.rand(10000, 1)
X3 = torch.rand(10000, 1)
Y1 = ((X1 + X2 + X3) < 1).float()
Y2 = ((1 < (X1 + X2 + X3)) & ((X1 + X2 + X3) < 2))
Y3 = ((X1 + X2 + X3) > 2).float()
# 整合数据集
Data = torch.cat([X1, X2, X3, Y1, Y1, Y2, Y3], axis=1)
# Data = Data.to('cuda: 0 ')
# 划分训练集和测试集
train_size = int(len(Data) * 0.7)
test_size = len(Data) - train_size
Data = Data[torch.randperm(Data.size(0)), :]
train_Data = Data[:train_size, :]
test_Data = Data[train_size:, :]

# 定义DNN类
class DNN(nn.Module):
    def __init__(self):
        super(DNN, self).__init__()
        self.net = nn.Sequential(
            nn.Linear(3, 5), nn.ReLU(),
            nn.Linear(5, 5), nn.ReLU(),
            nn.Linear(5, 5), nn.ReLU(),
            nn.Linear(5, 3)
        )
    def forward(self, x):
        y = self.net(x)
        return y
# 创建子类的实例
model = DNN()
# 损失函数
loss_fn = nn.MSELoss()
# 优化算法
learning_rate = 0.01
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)

# 训练网络
epochs = 100
losses = []
# 给训练集划分输入和输出
X = train_Data[:, :3]
Y = train_Data[:, -3:]
for epoch in range(epochs):
    Pred = model(X)
    loss = loss_fn(Pred, Y)
    losses.append(loss.item())
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
Fig = plt.figure()
plt.plot(range(epochs),losses)
plt.ylabel('loss')
plt.xlabel('epoch')
plt.show()

# 测试网络
X = test_Data[:, :3]
Y = test_Data[:, -3:]
with torch.no_grad():
    Pred = model(X)
    Pred[:, torch.argmax(Pred, axis=1)] = 1
    Pred[Pred != 1] = 0
    correct = torch.sum((Pred == Y).all(1))
    total = Y.size(0)
    print(f'测试集准确度:{100*correct/total}%')

# 保存网络
torch.save(model, 'DNN.path')
new_model = torch.load('DNN.path')

运行截图