Python从入门到实战代码行行标注----线性回归试水

--------教程摘自b站【不愧是计算机博士唐宇迪128集课程一套搞定了我大学4年没学会的PyTorch】PyTorch从入门到实战全套课程（附带课程学习资料 )_哔哩哔哩_bilibili

x_values = [i for i in range(11)]  #i是取0-10的遍历
x_train = np.array(x_values, dtype=np.float32) # x_train是一个array的格式
x_train = x_train.reshape(-1, 1)   #将数据转换为一列的矩阵
x_train.shape

(11, 1)

y_values = [2*i + 1 for i in x_values]   #y=2*x+1
y_train = np.array(y_values, dtype=np.float32)
y_train = y_train.reshape(-1, 1)   #将数据转换为一列的矩阵
y_train.shape

(11, 1)

import torch
import torch.nn as nn

线性回归模型¶

• 其实线性回归就是一个不加激活函数的全连接层

class LinearRegressionModel(nn.Module): #定义一个类 继承nn模块下Module 下面只需要写网络需要的哪些层
    def __init__(self, input_dim, output_dim):
        super(LinearRegressionModel, self).__init__()
        self.linear = nn.Linear(input_dim, output_dim)   #nn模块下的全连接层（输入维度-1，输出维度-1）

    def forward(self, x):  #前向传播
        out = self.linear(x)   #直接走一个全连接层  输出
        return out

#建立一个例子

input_dim = 1
output_dim = 1

model = LinearRegressionModel(input_dim, output_dim) #输入输出维度都是1

epochs = 1000  #迭代1000次
learning_rate = 0.01  #学习率
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate) #指定优化器SGD，优化参数
criterion = nn.MSELoss()  #定义一个损失函数

训练模型

for epoch in range(epochs):  #遍历1000次
    epoch += 1   #每次+1
    # 注意转行成tensor
    inputs = torch.from_numpy(x_train)  #将array转换为tensor
    labels = torch.from_numpy(y_train)

    # 梯度要清零每一次迭代  做之前要清零
    optimizer.zero_grad()   

    # 前向传播
    outputs = model(inputs)   #前向传播的结果

    # 计算损失
    loss = criterion(outputs, labels)

    # 返向传播
    loss.backward()  #做完反向传播后梯度已经求出来了 但是没有更新

    # 然后更新权重参数 
    optimizer.step()
    if epoch % 50 == 0:  #每隔50次打印一下当前的损失值
        print('epoch {}, loss {}'.format(epoch, loss.item()))

测试模型预测结果

predicted = model(torch.from_numpy(x_train).requires_grad_()).data.numpy() #转换成了numpy的格式
predicted

array([[ 0.99918383],
       [ 2.9993014 ],
       [ 4.9994187 ],
       [ 6.9995365 ],
       [ 8.999654  ],
       [10.999771  ],
       [12.999889  ],
       [15.000007  ],
       [17.000124  ],
       [19.000242  ],
       [21.000359  ]], dtype=float32)

torch.save(model.state_dict(), 'model.pkl')   #保存模型 保存的是字典的文件, state_dict(),表示的是文件中的权重参数

model.load_state_dict(torch.load('model.pkl'))  #模型读取

使用GPU进行训练（将数据和模型传入到cuda中）

import torch
import torch.nn as nn
import numpy as np

class LinearRegressionModel(nn.Module):
    def __init__(self, input_dim, output_dim):
        super(LinearRegressionModel, self).__init__()
        self.linear = nn.Linear(input_dim, output_dim)  

    def forward(self, x):
        out = self.linear(x)
        return out

input_dim = 1
output_dim = 1

model = LinearRegressionModel(input_dim, output_dim)

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") #
model.to(device)  #模型放入GPU或CPU中

criterion = nn.MSELoss()

learning_rate = 0.01

optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)

epochs = 1000
for epoch in range(epochs):
    epoch += 1
    inputs = torch.from_numpy(x_train).to(device)  #需要将数据也传入到GPU中
    labels = torch.from_numpy(y_train).to(device)  #需要将数据也传入到GPU中

    optimizer.zero_grad() 

    outputs = model(inputs)

    loss = criterion(outputs, labels)

    loss.backward()

    optimizer.step()

    if epoch % 50 == 0:
        print('epoch {}, loss {}'.format(epoch, loss.item()))