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)