深度学习02-神经网络和反向传播算法-pytorch实现多层感知机的神经网络算法_利用pytorch实现多层感知器模型对由两个带噪声的同心圆组成的数据进行以sigmoid为

算法详解

1、导入数据
（1）使用np的方式将数据进行导入

print("读取数据")
    train_drug_targets = np.loadtxt('/Users/fengxiaolin/Desktop/data/train_DPI.txt')
    train_drug_fps = np.loadtxt('/Users/fengxiaolin/Desktop/data/train_fps.txt')
1
2
3

（2）将数据转为Tensor类型并转为float类型

print("numpy 转 tensor")
    train_x = torch.from_numpy(train_drug_fps).float()
    train_y = torch.from_numpy(train_drug_targets).float()
1
2
3

2、初始化模型
（1）使用TensorDataset将数据进行打包，打包成[x,y]的形式

train_set = TensorDataset(train_x, train_y)# 将训练数据打包
1

（2）使用DataLoader将数据多线程进行批量载入并将其顺序打乱

    train_loader = DataLoader(dataset=train_set, batch_size=BATCH_SIZE, shuffle=True, num_workers=6)      # 传入Dataloader，设置批大小、打乱顺序、6线程工作
1

pytorch 的数据加载到模型的操作顺序是这样的：
① 创建一个 Dataset 对象
② 创建一个 DataLoader 对象
③ 循环这个 DataLoader 对象，将img, label加载到模型中进行训练
该接口的目的：将自定义的Dataset根据batch size大小、是否shuffle(打乱顺序)等封装成一个Batch Size大小的Tensor，用于后面的训练。
详细参考：参考文档

3、实例化MLP(多层感知机)

FC = MLP(drug_feature, protein_num) # 实例化MLP
1

5、使用Adam优化器对MLP进行优化

optimizer = torch.optim.Adam(FC.parameters(), lr=LR) # 选择Adam为优化器
1

lr为调整步长，学习率，FC.parameters为调整参数

神经网络优化器，主要是为了优化我们的神经网络，使他在我们的训练过程中快起来，节省社交网络训练的时间。在pytorch中提供了torch.optim方法优化我们的神经网络，torch.optim是实现各种优化算法的包。
用来更新和计算影响模型训练和模型输出的网络参数，使其逼近或达到最优值，从而最小化(或最大化)损失函数E(x)

常用优化器：SGD、Momentum、Momentum、RMSProp、Adam

6、损失函数算法

loss_func = nn.MSELoss() # 选择均方差函数为损失函数
1

均方损失函数：

loss 函数都有 size_average 和 reduce 两个布尔类型的参数
(1)如果 reduce = False，那么 size_average 参数失效，直接返回向量形式的 loss
(2)如果 reduce = True，那么 loss 返回的是标量
a)如果 size_average = True，返回 loss.mean();
b)如果 size_average = False，返回 loss.sum();

7、进行优化调整

    for epoch in range(EPOCH):
        for i, data in enumerate(train_loader):
            batch_x, batch_y = data
            pre = FC(batch_x)
            loss = loss_func(pre, batch_y)  # 计算损失
            optimizer.zero_grad()           # 梯度清0
            loss.backward()                 # 反向传播
            optimizer.step()                # 更新
1
2
3
4
5
6
7
8

注意：使用enumerate进行遍历iteration会自动在每个数据前面加一个标号
使用多层感知器进行拟合，将得到的结果和预期结果进行计算误差，然后使用反向传播算法进行计算梯度，使用最优算法进行调整使得误差最小，不断调整，最终得到最优的权值
注意，每次梯度计算完成之后要清零，否则会累加

8、MLP(多层感知器)类内部代码分析：

class MLP(nn.Module):
    def __init__(self, size_x, size_y):
        super(MLP, self).__init__()
        self.fc1 = nn.Sequential(
            nn.Linear(size_x, 2048),   # 线性层， 维度从1024 变为2048
            nn.Dropout(0.2),           # Dropout防止过拟合，参数是扔掉的比例
            nn.GELU(),                 # Gelu() 激活函数
            nn.BatchNorm1d(2048),      # BN层防止过拟合（可以略过）
            nn.Linear(2048, 2048),
            nn.Dropout(0.2),
            nn.GELU(),
            nn.BatchNorm1d(2048),
            nn.Linear(2048, protein_num),
            nn.Dropout(0.2),
        )

    def forward(self, x):
        e0 = self.fc1(x)
        e1 = F.softmax(e0, dim=1)
        return e1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

使用nn.module+nn.Sequential快速构建神经网络
1、首先需要学习nn.module的相关概念
详解nn.module
(1)nn.module是用来自定义网络层的
(2)使用module的类必须继承自nn.module
(3)在类中必须实现一个含有继承父类init方法的init函数
(4)类中需要有一个前向传播算法

2、了解nn.Sequential的使用
详解nn.Sequential

torch.nn.Sequential是一个Sequential容器，模块将按照构造函数中传递的顺序添加到模块中。另外，也可以传入一个有序模块。

(1)使用目的：使用普通的方法构建神经网络，需要在forward函数中手动调用激活函数，而使用nn.Sequential可以自动的调用激活函数

3、nn.dropout()

详解dropout如何防止过拟合

Dropout就是在不同的训练过程中随机扔掉一部分神经元。也就是让某个神经元的激活值以一定的概率p，让其停止工作，这次训练过程中不更新权值，也不参加神经网络的计算。但是它的权重得保留下来（只是暂时不更新而已），因为下次样本输入时它可能又得工作了

4、GeLU激活函数
几个激活函数：
1、sigmoid函数

sigmoid,在远离0点的地方,梯度变得非常微小,所以求导以后也很难指导我们的梯度下降

2、ReLU函数

它的主要问题有两个,一个是0点附近不可微,所以通常在0点只求右导数;另一个问题是:它会“谋杀”一些神经元。怎么讲“谋杀”呢，就是说它在反向传播的过程中很快让一些神经元的导数永远是0,导致一些神经元失效

3、leakyReLU

在小于0的一边有一个很小的梯度，解决了ReLU的问题，常在NLP、图像识别中使用

4、GeLU函数

效果很好

5、Softmax：
进行归一化处理？
dim为维度，dim=1说明按行进行归一化
参考：参考链接

总结：

这个模型相当于使用线性拟合的方法，从输入层的1024个神经元，映射到隐藏层的2048个神经元然后又经过一次线性拟合，保持维度不变，但拟合了一次，然后最后经过映射到输出层的1996维度
在中间使用了dropout、BN等方法防止过拟合