PyTorch学习笔记：用Module和Sequential两种方式搭建网络

'''搭建网络：用Module和Sequential两种不同的网络定义方式'''
import torch
import torch.nn as nn  # nn模块方便用户对网络中的层的使用
from torch.optim import SGD
import torch.utils.data as Data  # Data模块用于对使用数据的预处理
from sklearn.datasets import load_boston  # 用于导入数据
from sklearn.preprocessing import StandardScaler  # 对数据进行标准化
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt


# 使用继承Module的方式定义一个包含层的全连接神经网络
class MLPmodel(nn.Module):
    def __init__(self):
        super(MLPmodel, self).__init__()
        # 定义第一个隐藏层
        self.hidden1 = nn.Linear(
            in_features=13,  # 第一个隐藏层的输入，数据的特征数
            out_features=10,  # 第一个隐藏层的输出，神经元的数量
            bias=True,  # 默认会有偏置
        )
        self.active1 = nn.ReLU()
        # 定义第二个隐层
        self.hidden2 = nn.Linear(10, 10)
        self.active2 = nn.ReLU()
        # 定义预测回归层
        self.regression = nn.Linear(10, 1)

    # 定义网络的前向传播路径
    def forward(self, x):
        x = self.hidden1(x)
        x = self.active1(x)
        x = self.hidden2(x)
        x = self.active2(x)
        output = self.regression(x)
        # 输出为output
        return output


# 使用定义网络时使用nn.Sequential的形式
class MLPmodel2(nn.Module):
    def __init__(self):
        super(MLPmodel2, self).__init__()
        # 定义隐藏层
        # nn.Sequential()可以简化定义网络的结构和前向传播函数
        self.hidden = nn.Sequential(
            nn.Linear(13, 10),
            nn.ReLU(),
            nn.Linear(10, 10),
            nn.ReLU(),
        )
        # 预测回归层
        self.regression = nn.Linear(10, 1)

    # 定义网络的前向传播路径
    def forward(self, x):
        x = self.hidden(x)
        output2 = self.regression(x)

        return output2


def init_weights(m):
    '''
    对不同类型层的参数使用不同的方法进行初始化
    :param m: 网络的某一层
    :return:
    '''
    # 如果是卷积层
    if type(m) == nn.Conv2d:
        torch.nn.init.normal_(m.weight, mean=0, std=0.5)
        # UserWarning: nn.init.normal is now deprecated in favor of nn.init.normal_.
    # 如果是全连接层
    if type(m) == nn.Linear:
        torch.nn.init.uniform_(m.weight, a=-0.1, b=0.1)
        m.bias.data.fill_(0.01)


if __name__ == '__main__':
    # 读取数据
    boston_X, boston_y = load_boston(return_X_y=True)
    print("boston_X.shape:", boston_X.shape)
    plt.figure()
    plt.hist(boston_y, bins=20)
    plt.show()

    # 数据标准化处理
    ss = StandardScaler(with_mean=True, with_std=True)
    boston_Xs = ss.fit_transform(boston_X)
    # 将数据预处理为可以使用pytorch进行批量训练的形式
    # 训练集X转化为张量
    train_xt = torch.from_numpy(boston_Xs.astype(np.float32))
    # 训练集y转化为张量
    train_yt = torch.from_numpy(boston_y.astype(np.float32))
    # 将训练集转化为张量后，使用TensorDataset将X和y整理到一起
    train_data = Data.TensorDataset(train_xt, train_yt)
    # 定义一个数据加载器，将训练数据集进行批量处理
    train_loader = Data.DataLoader(
        dataset=train_data,  # 使用的数据集
        batch_size=128,  # 批处理样本大小
        shuffle=True,  # 每次迭代前打乱数据
        num_workers=1,  # 使用两个进程
    )

    ###################### 网络定义与训练方式1 ##################################
    # 输出网络结构
    mlp1 = MLPmodel()
    print(mlp1)

    # # 使用网络的apply方法进行权重初始化
    # torch.manual_seed(13)
    # mlp1.apply(init_weights)

    # 对回归模型mlp1进行训练并输出损失函数的变化情况，定义优化器和损失函数
    optimizer = SGD(mlp1.parameters(), lr=0.001)  # 使用SGD优化方法对网络进行优化，需要优化的参数可以使用mlp1.parameters()获得
    loss_function = nn.MSELoss()  # 使用MSELoss()函数作为损失函数：最小均方根误差
    train_loss_all = []  # 保存每个批次训练的损失函数值，用来可视化
    # 进行训练，并保存每次迭代的损失函数值
    for epoch in range(30):  # 定义了对整个数据集训练的次数
        # 对训练数据的加载器进行迭代计算
        for step, (b_x, b_y) in enumerate(train_loader):  # 利用train_loader中的每一个batch对模型参数进行优化
            output = mlp1(b_x).flatten()  # MLP在训练本轮batch上的输出，返回值为一个一维数组
            train_loss = loss_function(output, b_y)
            #
            optimizer.zero_grad()  # 每个迭代步的梯度初始化为0
            train_loss.backward()  # 损失的后向传播，计算梯度
            optimizer.step()  # 使用梯度进行优化
            #
            train_loss_all.append(train_loss.item())
            # train_loss_all里面包括120个点，因为506个样本，128/batch，共4batch；
            # 4batch * 30epoch = 120

    plt.figure()
    plt.plot(train_loss_all, "r-")
    plt.title("Train loss per iteration")
    plt.show()

    ###################### 网络定义与训练方式2 ##################################
    # 输出网络结构
    mlp2 = MLPmodel2()
    print(mlp2)

    # 使用以上同样的优化方式对mlp2进行训练并输出损失函数的变化情况