pytorch 学习线性回归与⾮线性回归，以及理解nn.linear （）和ReLU 激活函数参考书⽬：Pytorch深度学习⼊门，作者：曾芃壹
⽂章⽬录
线性回归
线性模型与⽬标函数
这次我们使⽤直线KaTeX parse error: \tag works only in display equations来拟合⼏个离散点，个点的 值如下
优化
损失函数（均⽅误差）：
的梯度
将看做向量则梯度下降可以写为：
可以由⾃动微分autograd技术得到。
批量输⼊x (i )
y (i )y (i )1.4
14.414.4w +1w 05
29.65w +1w 011
6211w +1w 016
85.516w +1w 021113.421w +1w )
L (w ,w )=10(w x +i =1∑51(i )w −0y )(i )2(1-2)
L ∇L =(,)∂w 1∂L ∂w 0∂L
(1-3)
(w ,w )01=w t +1−w t ∇L ()×w t δ
(1-4)
∇L ()w t
把式(1-1)写成向量形式，把看做其中，则
损失函数也可写为：
代码实践
import  torch
import  matplotlib .pyplot as  plt
#产⽣输⼊X ，X 有两个维度n ⾏2列，2列对应x1w1+x0w0，x0=1
def  Produce_X (x ):
x0=torch .ones (x .numpy ().size )#x.numpy()将Tensor 转化为numpy
X =torch .stack ((x ,x0),dim =1)#将x 与x0在第⼆个维度进⾏连接组合成n ⾏2列的矩阵
return  X
x =torch .Tensor ([1.4,5,11,16,21])
Y =torch .Tensor ([14.4,29.6,62,85.5,113.4])
X =Produce_X (x )
#输⼊与⽬标函数结果
inputs =X
target =Y
w =torch .rand (2,requires_grad =True )#设置参数w 开启⾃动微分
#X 的实际结构
X
tensor([[ 1.4000,  1.0000],
[ 5.0000,  1.0000],
[11.0000,  1.0000],
[16.0000,  1.0000],
[21.0000,  1.0000]])
w 0w ×0x 0x =01=y ⋅x w (1-5)
L L (w ,w )=10−∣∣∣y y ∣
∣∣2
#训练前
draw(inputs.mv(w),loss =(inputs.mv(w)- target).pow(2).sum())
# 训练
def train(epochs=1, learning_rate=0.01):
for epoch in range(epochs):
output = inputs.mv(w)linspace numpy
loss =(output - target).pow(2).sum()
loss.backward()
w.data -= learning_rate * w.grad
#由于篇幅问题我们只画出最开始的直线和最后训练出的直线
#if epoch % 80 == 0:  # 每80个epoch
#  draw(output, loss)
return w, loss
def draw(output, loss):#
plt.cla()# 清除当前活动轴
plt.scatter(x.numpy(), Y.numpy())
plt.plot(x.numpy(), output.data.numpy(),'r-', lw=5)# 红⾊，宽度5
<(1,2,'loss=%s'%(loss.item()), fontdict={'size':20,'color':'red'})
plt.pause(0.005)
w, loss = train(10000, learning_rate=1e-4)
print("final loss:", loss.item())# item将Tensor的单⼀张量转化为python的元素值
# 如果我们想要修改 tenso r的数值，但是⼜不希望被autograd记录，那么我么可以对 tensor.data 进⾏操作
print("weight:", w.data)
#训练后再画直线
draw(inputs.mv(w),loss =(inputs.mv(w)- target).pow(2).sum())
final loss: 8.24051284790039
weight: tensor([5.0838, 5.5881])
⼤规模数据实验
使⽤linspace函数在(-3,3)之间划分100000个点，并在y轴上增加⼀些误差
代码在训练部分不变，在数据初始化和draw部分有些许CUDA加速代码变动，并使⽤time记录计算时间from time import perf_counter
import matplotlib.pyplot as plt
import torch
def Produce_X(x):
x0 = s(x.numpy().size)
X = torch.stack((x, x0), dim=1)
return X
x = torch.linspace(-3,3,100000)
X = Produce_X(x)
Y = x +1.2* torch.rand(x.size())# 与x相同个数的随机数
w = torch.rand(2)
plt.scatter(x.numpy(), Y.numpy(), s=0.001)
plt.show()
# 开启gpu加速训练
CUDA = torch.cuda.is_available()
if CUDA:
if CUDA:
print("CUDA success")
inputs = X.cuda()
target = Y.cuda()
w = w.cuda()
else:
print("CUDA fail")
inputs = X
target = Y
w = w
def draw(output, loss):
if CUDA:
output = output.cpu()# 若使⽤了CUDA加速这⼀步要还原为CPU数据类型
plt.cla()
plt.scatter(x.numpy(), Y.numpy())
plt.plot(x.numpy(), output.data.numpy(),'r-', lw=5)# 红⾊，宽度5
<(1,1,'loss=%s'%(loss.item()), fontdict={'size':20,'color':'red'})
plt.pause(0.005)
# 训练
def train(epochs=1, learning_rate=0.01):
global loss
for epoch in range(epochs):
output = inputs.mv(w)
loss =(output - target).pow(2).sum()/100000# 将均⽅误差除以数据个数
loss.backward()
w.data -= learning_rate * w.grad
if epoch %2000==0:# 每80个epoch
draw(output, loss)
return w, loss
start = perf_counter()
w, loss = train(10000, learning_rate=1e-4)
finish = perf_counter()
time = finish - start
print("计算时间:%s"% time)
print("fina loss:", loss.item())
print("wights", w.data)
CUDA success
计算时间:9.94497809999666
fina loss: 0.12648160755634308
wights tensor([0.9995, 0.5204], device='cuda:0')
device='cuda:0’指使⽤显卡的编号，即使⽤我电脑中唯⼀⼀块显卡index为0
神经⽹络实现线性回归
pytorch已经预先编写好了我们要⽤到的损失函数以及优化函数
导⼊所需要的库
import torch
import matplotlib.pyplot as plt
from torch import nn,optim
from time import perf_counter
x=torch.unsqueeze(torch.linspace(-3,3,100000),dim=1)#unsqueeze函数在第⼀维处增加⼀个维度
y=x+1.2*torch.rand(x.size())
定义⼀个LR类继承nn模块中Module，nn是Neural Network的缩写。我们需要在初始化函数时先执⾏⽗类的初始化函数，再⽤nn中预设好的线性的神经⽹络模块nn.Linear()构造线性模型，Linear()的第⼀个参数是输⼊的的维度，第⼆个参数是输出的维度；接下来在类中定义forward()⽅法构造向前传播的计算步骤out相当于之前的(w)求出target
class LR(nn.Module):
def__init__(self):
super(LR, self).__init__()
self.linear = nn.Linear(1,1)# 因为x与y都是⼀维的所以设置为(1,1)
def forward(self, x):
out = self.linear(x)
return out
CUDA加速
CUDA = torch.cuda.is_available()
if CUDA:
LR_model = LR().cuda()
inputs = x.cuda()
target = y.cuda()
else:
LR_model = LR()
inputs = x
target = y
画图
def draw(output, loss):
if CUDA:
output = output.cpu()# 若使⽤了CUDA加速这⼀步要还原为CPU数据类型
plt.cla()
plt.scatter(x.numpy(), Y.numpy())
plt.plot(x.numpy(), output.data.numpy(),'r-', lw=5)# 红⾊，宽度5
<(1,1,'loss=%s'%(loss.item()), fontdict={'size':20,'color':'red'})
plt.pause(0.005)
nn中⾃带均⽅误差函数MSELoss()
数学表达式为
criterion = nn.MSELoss()L(x,y)=x−y
n
1
∑∣i i∣2(1-6)

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。