PyTorch迴歸訓練

1. 創建用於迴歸的虛擬數據集

2. 劃分訓練集和測試集

3. 參數初始化比較

4 批訓練方法

---

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
__title__ = ''

"""
import torch
from torch import nn
import torch.nn.functional as F
import torch.utils.data as Data
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
import numpy as np
from torchvision import datasets, transforms
from torch.nn import init



#創建fake data
# torch.manual_seed(99)
# x = torch.unsqueeze(torch.linspace(-1, 1, 1000), dim=1)
# y = x.pow(2) + 0.1 * torch.normal(torch.zeros(x.size()))
# plt.scatter(x.numpy(), y.numpy())
# plt.show()

np.random.seed(666)
X = np.linspace(-1, 1, 1000)
y = np.power(X, 2) + 0.1 * np.random.normal(0, 1, X.size)
print(X.shape)
print(y.shape)
# plt.scatter(X, y)
# plt.show()

# 創建訓練集和測試集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1024)
X_train = torch.from_numpy(X_train).type(torch.FloatTensor)
X_train = torch.unsqueeze(X_train, dim=1)  #轉換成二維
y_train = torch.from_numpy(y_train).type(torch.FloatTensor)
y_train = torch.unsqueeze(y_train, dim=1)
print(X_train.type)
X_test = torch.from_numpy(X_test).type(torch.FloatTensor)
X_test = torch.unsqueeze(X_test, dim=1)  #轉換成二維

# train_size = int(0.7 * len(X))
# test_size = len(X) - train_size
# X_train, X_test = Data.random_split(X, [train_size, test_size])
# print(len(X_train), len(X_test))



BATCH_SIZE = 50
LR = 0.02
EPOCH = 5

#將數據裝載鏡data中, 對數據進行分批訓練
torch_data  = Data.TensorDataset(X_train, y_train)
loader = Data.DataLoader(dataset=torch_data, batch_size=BATCH_SIZE, shuffle=True)
#創建自己的nn
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.hidden = nn.Linear(1, 20)
        self.predict = nn.Linear(20, 1)

    def forward(self, x):
        x = F.relu(self.hidden(x))
        x = self.predict(x)
        return x
def weights_init(m):
    if isinstance(m, nn.Linear):
        init.kaiming_normal(m.weight.data)
        # init.xavier_normal(m.bias.data)

adam_net = Net()
# adam_net.apply(weights_init) # 對整個網絡層進行參數初始化
# 有初始化損失 xavier_normal  ：
#{1: tensor(0.0972, grad_fn=<MseLossBackward>), 2: tensor(0.0731, grad_fn=<MseLossBackward>),
# 3: tensor(0.0881, grad_fn=<MseLossBackward>), 4: tensor(0.1120, grad_fn=<MseLossBackward>),
# 5: tensor(0.1012, grad_fn=<MseLossBackward>)}
# 有初始化損失 kaiming_normal  ： 表現相對較好---
#{1: tensor(0.1476, grad_fn=<MseLossBackward>), 2: tensor(0.0234, grad_fn=<MseLossBackward>),
# 3: tensor(0.0162, grad_fn=<MseLossBackward>), 4: tensor(0.0170, grad_fn=<MseLossBackward>),
# 5: tensor(0.0218, grad_fn=<MseLossBackward>)}

# 沒有初始化損失
# {1: tensor(0.0265, grad_fn=<MseLossBackward>), 2: tensor(0.0121, grad_fn=<MseLossBackward>),
# 3: tensor(0.0096, grad_fn=<MseLossBackward>), 4: tensor(0.0109, grad_fn=<MseLossBackward>),
# 5: tensor(0.0104, grad_fn=<MseLossBackward>)}
#設置優化器和損失函數
opt_adam = torch.optim.Adam(adam_net.parameters(), lr=LR)
loss_func = nn.MSELoss()
#對數據進行分批訓練
# 在神經網絡中傳遞完整的數據集一次是不夠的，
# 而且我們需要將完整的數據集在同樣的神經網絡中傳遞多次。
# 但是請記住，我們使用的是有限的數據集，
# 並且我們使用一個迭代過程即梯度下降。因此僅僅更新權重一次或者說使用一個 epoch 是不夠的。
# 比如對於一個有 2000 個訓練樣本的數據集。將 2000 個樣本分成大小爲 500 的 batch，那麼完成一個 epoch 需要 4 個 iteration。
all_loss = {}
for epoch in range(EPOCH):
    print('epoch', epoch)
    for step, (b_x, b_y) in enumerate(loader):
        print('step', step)
        pre = adam_net(b_x)
        loss = loss_func(pre, b_y)
        opt_adam.zero_grad()
        loss.backward()
        opt_adam.step()
        # print(loss)
        all_loss[epoch+1] = loss
print(all_loss)

#對測試集進行預測
adam_net.eval()
predict = adam_net(X_test)
predict = predict.data.numpy()
plt.scatter(X_test.numpy(), y_test, label='origin')
plt.scatter(X_test.numpy(), predict, color='red', label='predict')
plt.legend()
plt.show()

沒有使用參數初始化的結果

使用參數初始化的結果