深度神经网络（DNN）

 #jupyter notebook

    
  
    
 import torch
    
 import torch.nn as nn
    
 import matplotlib.pyplot as plt
    
 %matplotlib inline
    
  
    
 # 展示高清图
    
 from matplotlib_inline import backend_inline
    
 backend_inline.set_matplotlib_formats('svg')
    
  
    
 '''在训练之前，要准备好训练集的样本。
    
 这里生成 10000 个样本，设定 3 个输入特征与 3 个输出特征，其中
    
 ⚫ 每个输入特征相互独立，均服从均匀分布；
    
 ⚫ 当(X1+X2+X3)< 1 时，Y1 为 1，否则 Y1 为 0；
    
 ⚫ 当 1<(X1+X2+X3)<2 时，Y2 为 1，否则 Y2 为 0；
    
 ⚫ 当(X1+X2+X3)>2 时，Y3 为 1，否则 Y3 为 0；
    
 ⚫ .float()将布尔型张量转化为浮点型张量。'''
    
  
    
 # 生成数据集
    
 X1 = torch.rand(10000,1) # 输入特征 1
    
 X2 = torch.rand(10000,1) # 输入特征 2
    
 X3 = torch.rand(10000,1) # 输入特征 3
    
 Y1 = ( (X1+X2+X3)<1 ).float() # 输出特征 1
    
 Y2 = ( (1<(X1+X2+X3)) & ((X1+X2+X3)<2) ).float() # 输出特征 2
    
 Y3 = ( (X1+X2+X3)>2 ).float() # 输出特征 3
    
 Data = torch.cat([X1,X2,X3,Y1,Y2,Y3],axis=1) # 整合数据集
    
 Data = Data.to('cuda:0') # 把数据集搬到 GPU 上
    
 Data.shape
    
  
    
 # 划分训练集与测试集
    
 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 : , : ] # 测试集样本
    
 train_Data.shape, test_Data.shape
    
  
    
 class DNN(nn.Module):
    
 def __init__(self):
    
 ''' 搭建神经网络各层 '''
    
 super(DNN,self).__init__()
    
 self.net = nn.Sequential( # 按顺序搭建各层
    
 nn.Linear(3, 5), nn.ReLU(), # 第 1 层：全连接层
    
 nn.Linear(5, 5), nn.ReLU(), # 第 2 层：全连接层
    
 nn.Linear(5, 5), nn.ReLU(), # 第 3 层：全连接层
    
 nn.Linear(5, 3) # 第 4 层：全连接层
    
 )
    
 def forward(self, x):
    
 ''' 前向传播 '''
    
 y = self.net(x) # x 即输入数据
    
 return y # y 即输出数据
    
  
    
 model = DNN().to('cuda:0') # 创建子类的实例，并搬到 GPU 上
    
 model # 查看该实例的各层

 # 训练网络

    
 epochs = 1000
    
 losses = [] # 记录损失函数变化的列表
    
 # 给训练集划分输入与输出
    
 X = train_Data[ : , :3 ] # 前 3 列为输入特征
    
 Y = train_Data[ : , -3: ] # 后 3 列为输出特征
    
 for epoch in range(epochs):
    
 Pred = model(X) # 一次前向传播（批量）
    
 loss = loss_fn(Pred, Y) # 计算损失函数
    
 losses.append(loss.item()) # 记录损失函数的变化，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] # 前 3 列为输入特征
    
 Y = test_Data[:, -3:] # 后 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} %')