Pytorch实现线性回归

从0开始

1、导入需要的函数库

import torch
import numpy as np
import random
from matplotlib import pyplot as plt

import os
os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"#解决jupyter运行时挂掉的问题。

2、生成数据

#生成数据 y = w*x+b+c 其中 b是偏置值，c是噪声。 
num_input = 2
num_example = 1000
w = np.array([2,-3.4])
b = 4.2
# 生成输入值X
arr_x = np.random.normal(loc = 0,scale = 1,size = (num_example,num_input))
arr_x = torch.from_numpy(arr_x) 
#生成的噪声符合均值为loc，方差为scale的正态分布。size描述了生成噪声的维度。
labels = w[0]*arr_x[:,0]+w[1]*arr_x[:,1]+b
noise = torch.from_numpy(np.random.normal(loc = 0,scale = 0.01,size = (1000)))
labels = labels + noise
plt.scatter(arr_x[:,1].numpy(),labels.numpy())
# arr_x[0,:]获取第0行的数据
# arr_x[:,0]获取第0列的数据

3、加载数据

#数据生成完毕，接下来分批加载数据
def data_iter(batch_size,arr_x,labels):
    num_example = len(arr_x)
#     生成一个包含0到num_example-1的list
    indice = list(range(num_example))
#     打乱list
    random.shuffle(indice)
    
    for i in range(0,num_example,batch_size):
#         Tensor默认是32位float，而LongTensor默认是64位整型。
        j = torch.LongTensor(indice[i:min(i+batch_size,num_example)])
#     
        yield arr_x.index_select(0,j),labels.index_select(0,j)
        #yield相当于一个迭代器。
# 随机生成w 和 b 
w = torch.from_numpy(np.random.normal(loc = 0,scale = 0.01,size = (num_input,1)))
w.requires_grad_(requires_grad=True)
b = torch.zeros(1,dtype = float)
b.requires_grad_(requires_grad=True)        

5、定义损失函数，优化器，以及训练模型

#X*w + b
def linreg(X,w,b):
    return torch.mm(X,w)+b
#定义损失函数
def squard_loss(y_hat,y):
    return (y_hat-y.view(y_hat.size()))**2 / 2
# 定义优化算法
def sgd(params , lr , batch_size):
    for param in params:
        param.data =param.data - lr*param.grad / batch_size 

6、定义超参数并进行训练

# 训练
lr = 0.03
num_epoch = 3
net = linreg
loss = squard_loss
for epoch in range (num_epoch):
    for X,y in data_iter(batch_size,arr_x,labels):
        l = loss(net(X,w,b),y).sum()
        l.backward()
        sgd([w,b],lr,batch_size)
        w.grad.data.zero_()
        b.grad.data.zero_()
    train_1 = loss(net(arr_x,w,b),labels)
    print('epoch %d,loss %f' % (epoch+1,train_1.mean().item()))
print(w,b)

简洁实现

主要是使用一些封装好的函数来代替具体的函数过程

1、导入需要的函数包

#导入必要的函数包
import torch
from matplotlib import pyplot as plt
import numpy as np
import os 
os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"#解决jupyter运行时挂掉的问题。
import random
import torch.nn as nn
import torch.optim as optim
import torch.utils.data as Data
import torch.nn.init as init
torch.set_default_tensor_type(torch.DoubleTensor)

2、生成数据集

#生成数据
#模型 y = w * x + b + noise
w = [2,3.2]
b = -4.1
arr_x = torch.from_numpy(np.random.normal(loc = 0,scale = 1,size = [1000,2]))
noise = torch.from_numpy(np.random.normal(loc = 0,scale = 0.001,size = [1000]))
labels = w[0]*arr_x[:,0]+w[1]*arr_x[:,1]+b+noise

3、分批加载数据

#分批加载数据
batch_size = 10
# 对arr_x和labels进行打包，使一个arr_x对应一个labels
dataset = Data.TensorDataset(arr_x,labels)  
data_iter = Data.DataLoader(dataset,batch_size,shuffle = True) 

4、定义模型

#定义模型
class moudle(nn.Module):
    def __init__(self,n_features):
        super().__init__()
        self.Linear = nn.Linear(n_features,1,bias = 1)
    def forward(self,x):
        y = self.Linear(x)
        return y
net = moudle(2)
device = torch.device('cuda')
net = net.to(device)
# 查看需要训练的参数。
# for param in net.parameters():
#     print(param)

5、定义损失函数和优化器

#定义损失函数
loss = nn.MSELoss()
optimizer = optim.SGD(net.parameters(),lr = 0.03)

6、训练过程

num_epochs = 3
for epoch in range(1,num_epochs + 1):
    for x,y in data_iter:
        x = x.to(device)
        y = y.to(device)
        output = net(x) 
        l = loss(output,y.view(output.shape))
        optimizer.zero_grad()
        l.backward()
        optimizer.step()
    print("epoch:{},loss：{}".format(epoch,l.item()))
#for param in net.parameters(): #可以查看训练后的参数，与真实的参数进行比较。
#   print(param)