pytorch（1）線性迴歸

import torch
from torch.autograd import Variable
import numpy as np
import random
import matplotlib.pyplot as plt
from torch import nn
 
 
x = torch.unsqueeze(torch.linspace(-1, 1, 100), dim=1)
#[1,2,3,4]這樣的矩陣是一維的，[[1,2,3,4]]是二維的，unsqueeze()可以將一維矩陣變成二維矩陣，因爲torch只處理2維數據
y = 3*x + 10 + torch.rand(x.size())
# 上面這行代碼是製造出接近y=3x+10的數據集，後面加上torch.rand()函數製造噪音
if torch.cuda.is_available():
    print('yes')
    inputs = Variable(x).cuda()#要把x，y都變成variable，因爲神經網絡只能處理variable
    target = Variable(y).cuda()
else:
    inputs = Variable(x)
    target = Variable(y) 
# 畫圖
# plt.scatter(x.data.numpy(), y.data.numpy())
# plt.show()

################################搭建神經層

class LinearRegression(nn.Module):#神經網絡結構（官方步驟）
    def __init__(self):#神經網絡層信息（官方步驟）
        super(LinearRegression, self).__init__()#（官方步驟）
        self.linear = nn.Linear(1, 1) # 輸入和輸出的維度都是1，輸入是x，輸出是y的預測值
    def forward(self, x):#向前傳遞結構
        out = self.linear(x)
        return out

if torch.cuda.is_available():
    net = LinearRegression().cuda()
else:
    net = LinearRegression()
    
####################################
 
criterion = nn.MSELoss()#計算預測值和實際值 均方差
optimizer = torch.optim.SGD(net.parameters(), lr=0.005)#優化器，隨機梯度下降算法
 
num_epochs = 1000
for epoch in range(num_epochs):

 
    # 向前傳播
    out = net(inputs)
    loss = criterion(out, target)
 
    # 向後傳播
    optimizer.zero_grad() # 注意每次迭代都需要清零
    loss.backward()
    optimizer.step()
 
    if (epoch+1) %20 == 0:
        print('Epoch[{}/{}], loss:{:.6f}'.format(epoch+1, num_epochs, loss.item()))
net.eval()
if torch.cuda.is_available():
    predict = net(Variable(x).cuda())
    predict = predict.data.cpu().numpy()
else:
    predict = net(Variable(x))
    predict = predict.data.numpy()
plt.plot(x.numpy(), y.numpy(), 'ro', label='Original Data')
plt.plot(x.numpy(), predict, label='Fitting Line')
plt.show()

神經網絡第二種寫法

class Net(torch.nn.Module):  # 繼承 torch 的 Module
    def __init__(self, n_feature, n_hidden, n_output):
        super(Net, self).__init__()     # 繼承 __init__ 功能
        # 定義每層用什麼樣的形式
        self.hidden = torch.nn.Linear(n_feature, n_hidden)   # 隱藏層線性輸出
        self.predict = torch.nn.Linear(n_hidden, n_output)   # 輸出層線性輸出

    def forward(self, x):   # 這同時也是 Module 中的 forward 功能
        # 正向傳播輸入值, 神經網絡分析出輸出值
        x = F.relu(self.hidden(x))      # 激勵函數(隱藏層的線性值)
        x = self.predict(x)             # 輸出值
        return x

net = Net(n_feature=1, n_hidden=10, n_output=1)