pytorch4-全卷积神经网络

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("OK?", "boston_X.shape", boston_X.shape)

# plt.figure()
# plt.hist(boston_y, bins=20)  # 绘制boston_y这个变量，总共绘制20条条状图
# plt.show()

# 数据标准化处理
ss = StandardScaler(with_mean=True, with_std=True)  # 创建标准化数据加载器
boston_Xs = ss.fit_transform(boston_X)  # 转化数据为可用pytorch进行批量训练的形式

# 训练集X,y转化为张量
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=1,  # 使用两个进程
)


# 定义全连接网络模型
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


if __name__ == "__main__":
    mlp1 = MLPmodel()  # 实例化一个全连接神经网络，输出网络
    print(mlp1)

    # 对回归模型mlp1进行训练并输出损失函数的变化情况，定义优化器和损失函数
    optimizer = SGD(mlp1.parameters(), lr=0.001)
    loss_func = nn.MSELoss()  # 最小均方根误差-----定义损失函数
    train_loss_all = []  # 输出每个批次训练的损失函数

    #  进行训练，并输出每次迭代的损失函数--------30次迭代，每次迭代分成4个batch进行，所以共有120次
    for epoch in range(30):
        print("epoch times", epoch)

        # 对训练数据的加载器进行迭代计算
        for step, (b_x, b_y) in enumerate(train_loader):  # 从train_loader提取步数，特征值和标签
            # 理解 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())  # 保存损失

            print("step", step)
            print("b_x.shape", b_x.shape)
            print("b_y.shape", b_y.shape)

    plt.figure()
    plt.plot(train_loss_all, "r-")  # 绘制损失函数
    plt.title("Train loss per iterion")
    plt.show()