Pytorch之波士顿房价预测

Pytorch之波士顿房价预测

一、包库准备

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 numpy as np
import matplotlib.pyplot as plt		#用于制图

1. torch.optim.SGD参数说明

   torch.optim.SGD(params, lr=, momentum=0, dampening=0, weight_decay=0, nesterov=False)[source]

   • params (iterable) – 待优化参数的iterable或者是定义了参数组的dict
   • lr ( float) –学习率
   • momentum ( float,可选) –动量因子（默认：0）
   • weight_decay ( float,可选) –权重衰减（L2 惩罚）（默认：0）
   • dampening ( float,可选) –动量的抑制因子（默认：0）
   • nesterov ( bool,可选) –使用Nesterov动量（默认：False）

2. 为了使用torch.optim，你需要构建一个optimizer对象。这个对象能够保持当前参数状态并基于计算得到的梯度进行参数更新。为了构建一个Optimizer，你需要给它一个包含了需要优化的参数（必须都是Variable对象）的iterable。然后，你可以设置optimizer的参 数选项，比如学习率，权重衰减，等等。

二、读取数据

boston_x, boston_y = load_boston(return_X_y=True)	#读入boston数据的x,y
print("boston_x.shape:", boston_x.shape)			#输出x的shape
print("boston_y.shape:", boston_y.shape)			#输出y的shape
plt.hist(boston_y, bins=20)							#对应y轴，输出盒子为20个
plt.show()											#输出绘制结果

三、数据标准化处理

ss = StandardScaler(with_mean=True, with_std=True)	#数据标准化处理
boston_xs = ss.fit_transform(boston_x)	# 将数据预处理为可以使用pytorch进行批量训练的形式
train_xt = torch.from_numpy(boston_xs.astype(np.float32))	# 将训练集x转化为张量，对象类型为tensor
train_yt = torch.from_numpy(boston_y.astype(np.float32))	# 将训练集y转化为张量，对象类型为tensor
train_data = Data.TensorDataset(train_xt, train_yt)	## 将训练集转化为张量后，使用TensorDataset将x y整理到一块

# 定义一个数据加载器，将训练数据集进行批量处理
train_loader = Data.DataLoader(
    dataset=train_data,  # 使用的数据集
    batch_size=128,  # 批处理样本大小
    shuffle=True,  # 每次迭代前打乱数据
    num_workers=0,  # 使用一个进程
)

四、使用集成Module的方式定义全连接神经网络

class MLPmodel(nn.Module):				# 使用集成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)
        return output	

五、使用定义网络时使用nn.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

六、输出网络结构

mlp1 = MLPmodel()
print(mlp1)
mlp2 = MLPmodel2()
print(mlp2)

七、对回归模型mlp1进行训练并输出损失函数的变化情况，定义优化器和损失函数

optimizer = SGD(mlp1.parameters(), lr=0.001)	# 随机梯度
loss_func = nn.MSELoss()  # 最小均方根误差
train_loss_all = []  # 输出每个批次训练的损失函数
# 进行训练,并输出每次迭代的损失函数
for epoch in range(30):
    # 对训练数据的加载器进行迭代计算
    for step, (b_x, b_y) in enumerate(train_loader):
        output = mlp1(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())
plt.figure()		# 创建一个新的画板
plt.plot(train_loss_all, "r-")	
plt.title("Train loss per iteration")
plt.show()

八、对回归模型mlp2进行训练并输出损失函数的变化情况，定义优化器和损失函数

optimizer = SGD(mlp2.parameters(), lr=0.001)	# 随机梯度
loss_func = nn.MSELoss()  # 最小均方根误差
train_loss_all = []  # 输出每个批次训练的损失函数
# 进行训练,并输出每次迭代的损失函数
for epoch in range(30):
    # 对训练数据的加载器进行迭代计算
    for step, (b_x, b_y) in enumerate(train_loader):
        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())
plt.figure()
plt.plot(train_loss_all, "r-")
plt.title("Train loss per iteration")
plt.show()