PyTorch中定义网络的2种方式--Module和Sequential

#全连接神经网络
import torch
import torch.nn as nn
from torch.optim import SGD
import torch.utils.data as 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

#读取数据
boston_X,boston_y=load_boston(return_X_y=True)
print("boston_X.shape:",boston_X.shape)
print(boston_X.dtype)
print("boston_y.shape:",boston_y.shape)
print(boston_y.dtype)
# print(boston_X)
plt.figure(figsize=(20,8))
plt.hist(boston_y,bins=20)
plt.show()

#数据预处理
#标准化
ss=StandardScaler(with_mean=True,with_std=True)
boston_Xs=ss.fit_transform(boston_X)
#将训练集转化为可以使用pytorch进行批量训练的方式
#numpy->张量
train_xt=torch.from_numpy(boston_Xs.astype(np.float32))
train_yt=torch.from_numpy(boston_y.astype(np.float32))
#将x y整合在一起
train_data=Data.TensorDataset(train_xt,train_yt)
#定义数据加载器 将训练数据集进行批量处理
train_loader=Data.DataLoader(
    dataset=train_data,
    batch_size=128,
    shuffle=True,
    num_workers=0,
)
# #检查训练数据集的一个batch的样本的维度是否正确
for step,(b_x,b_y) in enumerate(train_loader):
    if step>0:
        break
print("b_x.shape:",b_x.shape)
print("b_y.shape:",b_y.shape)
print("b_x.dtype:",b_x.dtype)
print("b_y.dtype:",b_y.dtype)

# #方式一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)#输入10 输出10
#         # 激活函数
#         self.active2=nn.ReLU()
#         #定义预测回归层
#         self.regression=nn.Linear(10,1)#输入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)
#         return output
# #输出网络结构
# mlpl=MLPmodel()
# print(mlpl)
# #训练
# #对回归模型mlpl进行训练并输出损失函数的变化情况，定义优化器和损失函数
# #优化器 随机梯度下降 mlpl.parameters()需要优化的参数 lr学习率
# optimizer=SGD(mlpl.parameters(),lr=0.001)
# #损失函数 最小均方根误差
# loss_func=nn.MSELoss()
# train_loss_all=[]#输出每个批次训练的损失函数
# #进行训练并输出每次迭代的损失函数
# for epoch in range(30):#对整个数据集训练的次数30次
#     for step,(b_x,b_y) in enumerate(train_loader):#循环利用数据加载器train_loader中的每一个batch对模型参数进行优化
#         output=mlpl(b_x).flatten()#MLP在训练batch上的输出
#         train_loss=loss_func(output,b_y)#均方根误差
#         optimizer.zero_grad()#每个迭代步的梯度初始化为0
#         train_loss.backward()#损失的后向传播 计算梯度
#         optimizer.step()#使用梯度进行优化
#         train_loss_all.append(train_loss.item())#把每个batch的损失函数追加到list里
# #绘制损失函数图像
# plt.figure()
# plt.plot(train_loss_all,"r-")
# plt.title("train loss per iteration")
# plt.show()




#方式二Sequential
class MLPmodel2(nn.Module):
    def __init__(self):
        super(MLPmodel2,self).__init__()
        #定义隐藏层
        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)
        output=self.regression(x)
        return output
mlp2=MLPmodel2()
print(mlp2)
#训练
#对回归模型mlp2进行训练并输出损失函数的变化情况，定义优化器和损失函数
#优化器 随机梯度下降 mlp2.parameters()需要优化的参数 lr学习率
optimizer=SGD(mlp2.parameters(),lr=0.001)
#损失函数 最小均方根误差
loss_func=nn.MSELoss()
train_loss_all=[]#输出每个批次训练的损失函数
#进行训练并输出每次迭代的损失函数
for epoch in range(30):#对整个数据集训练的次数30次
    for step,(b_x,b_y) in enumerate(train_loader):#循环利用数据加载器train_loader中的每一个batch对模型参数进行优化
        output=mlp2(b_x).flatten()#MLP在训练batch上的输出
        train_loss=loss_func(output,b_y)#均方根误差
        optimizer.zero_grad()#每个迭代步的梯度初始化为0
        train_loss.backward()#损失的后向传播 计算梯度
        optimizer.step()#使用梯度进行优化
        train_loss_all.append(train_loss.item())#把每个batch的损失函数追加到list里
#绘制损失函数图像
plt.figure()
plt.plot(train_loss_all,"r-")
plt.title("train loss per iteration")
plt.show()