线性回归手撕[^1]

%matplotlib inline
import random
import torch 
from d2l import torch as d2l

构造数据集

$$\begin{gathered} y=Xw+b+ϵ \\ w=[2,-3.4{]}^{T}b=4.2 \end{gathered}$$

def synstetic_data(w,b,num_examples):X = torch.normal(0,1,(num_examples,len(w)))y = torch.matmul(X,w) + b y += torch.normal(0,0.01,y.shape)return X, y.reshape((-1,1))

true_w = torch.tensor([2,-3.4])
true_b = 4.2
features, labels = synstetic_data(true_w,true_b,1000)

d2l.set_figsize()
d2l.plt.scatter(features[:, 1].numpy(), labels.numpy(), 1)

定义读取小批量函数data_iter,大小为batch_size

def data_iter(batch_size,features,labels):num_examples = len(features)indices = list(range(num_examples))#生成每个样本的indexrandom.shuffle(indices)#随机打乱for i in range(0, num_examples,batch_size):batch_indices = torch.tensor(indices[i:min(i + batch_size, num_examples)])yield features[batch_indices],labels[batch_indices]#按照索引生成函数

batch_size = 10

读取第一个小批量数据样本并打印

for X,y in data_iter(batch_size, features, labels):print(X, '\n',y)break

tensor([[ 1.9921, -0.6007],[ 0.5512, -0.4175],[-0.8084, -1.1460],[-0.3088, -0.1136],[-1.7418, -0.4826],[ 0.8992,  1.9673],[ 0.5621,  1.2874],[-0.4990,  1.4661],[ 0.7456,  1.6236],[ 0.0331,  0.2446]]) tensor([[10.2283],[ 6.7240],[ 6.4990],[ 3.9876],[ 2.3645],[-0.6909],[ 0.9396],[-1.7839],[ 0.1708],[ 3.4304]])

定义模型初始化参数

随机初始化

w = torch.normal(0,0.01,size = (2,1),requires_grad = True)
b = torch.zeros(1,requires_grad = True)

定义模型

def linreg(X,w,b):"""线性回归模型"""return torch.matmul(X,w) + b 

定义损失函数

def squares_loss(y_hat,y):"""均方误差"""return (y_hat - y.reshape(y_hat.shape)) **2 / 2

定义优化算法

• 随机挑选初始值$w_0$
• 重复迭代参数$t=1,2,3$,
  $$w_t=w_{t-1}-\eta \frac{\partial l}{\partial w_{t-1}}$$

def sgd(params, lr, batch_size):#单样本的"""小批量随机下降"""with torch.no_grad():#更新的时候不需要梯度，只是加减法for param in params:param -= lr * param.grad / batch_sizeparam.grad.zero_()

训练

规定超参数

lr = 0.001
num_epochs = 3
net = linreg
loss = squares_loss

for epoch in range(num_epochs):for X,y in data_iter(batch_size, features, labels):l = loss(net(X, w, b),y)#此时这样的loss是一个batch_size长的向量l.sum().backward()#构造标量（求和）求导sgd([w,b],lr,batch_size) #用梯度下降进行小批量更新with torch.no_grad():train_l = loss(net(features, w, b),labels)print(f'epoch {epoch + 1}, loss {float(train_l.mean()):f}')

epoch 1, loss 14.073989
epoch 2, loss 11.410689
epoch 3, loss 9.251449

print(f'w为: {w.reshape(true_w.shape)}')
print(f'b为: {b}')

w为: tensor([ 0.5704, -0.9181], grad_fn=<ViewBackward>)
b为: tensor([1.1257], requires_grad=True)

print(f'w的估计误差: {true_w - w.reshape(true_w.shape)}')
print(f'b的估计误差: {true_b - b}')

w的估计误差: tensor([ 1.4296, -2.4819], grad_fn=<SubBackward0>)
b的估计误差: tensor([3.0743], grad_fn=<RsubBackward1>)

线性回归基于PyTorch实现

import numpy as np
import torch 
from torch.utils import data
from d2l import torch as d2l

true_w = torch.tensor([2,-3.4])
true_b = 4.2
features, labels = d2l.synthetic_data(true_w,true_b,1000)

调用PyTorch数据迭代器

def load_array(data_arrays, batch_size, is_train = True):"""构造一个PyTorch数据迭代器"""dataset = data.TensorDataset(*data_arrays)return data.DataLoader(dataset, batch_size, shuffle = is_train )#shuffle是不是随机打乱

batch_size = 10
data_iter = load_array((features, labels), batch_size)
data_iter

<torch.utils.data.dataloader.DataLoader at 0x7fb099b3bd90>

next(iter(data_iter))

[tensor([[ 0.8754,  0.8060],[-0.5434, -1.1498],[-0.4844, -0.1654],[ 1.1868, -0.8638],[ 1.0601, -0.0980],[ 0.0553,  0.1669],[ 1.5849, -0.6559],[ 0.7097,  0.8507],[-0.4372,  1.2454],[-0.5772, -0.5400]]), tensor([[ 3.2221],[ 7.0248],[ 3.8014],[ 9.5018],[ 6.6535],[ 3.7361],[ 9.5985],[ 2.7213],[-0.9234],[ 4.8920]])]

模型定义

torch.nn.Linear(in_features, out_features, bias=True, device=None, dtype=None)

• 参数

  • in_features – 输入例子的大小

  • out_features – 输出的大小

  • bias – 是否加入偏差项. 默认: True

from torch import nnnet = nn.Sequential(nn.Linear(2,1))

参数初始化

net[0].weight.data.normal_(0,0.01)
net[0].bias.data.fill_(0)

tensor([0.])

loss = nn.MSELoss()
trainer = torch.optim.SGD(net.parameters(),lr = 0.03)#lr是学习率

num_epochs = 3for epoch in range(num_epochs):for X,y in data_iter:l = loss(net(X),y)trainer.zero_grad()l.backward()trainer.step()l = loss(net(features), labels)print(f'epoch {epoch + 1}, loss {l:f}')

epoch 1, loss 0.000228
epoch 2, loss 0.000095
epoch 3, loss 0.000095

import torch
from torch import nnclass MLP(nn.Module):# 声明带有模型参数的层，这里声明了两个全连接层def __init__(self, **kwargs):# 调用MLP父类Block的构造函数来进行必要的初始化。这样在构造实例时还可以指定其他函数super(MLP, self).__init__(**kwargs)self.hidden = nn.Linear(784, 256)self.act = nn.ReLU()self.output = nn.Linear(256,10)# 定义模型的前向计算，即如何根据输入x计算返回所需要的模型输出def forward(self, x):o = self.act(self.hidden(x))return self.output(o)   

X = torch.rand(2,784)
net = MLP()
print(net)

MLP((hidden): Linear(in_features=784, out_features=256, bias=True)(act): ReLU()(output): Linear(in_features=256, out_features=10, bias=True)
)

python知识点补充

python 的 迭代器

描述

迭代是Python最强大的功能之一，是访问集合元素的一种方式.

迭代器是一个可以记住遍历的位置的对象

迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。

迭代器有两个基本的方法：iter()和 next()

iter()

主要是用于生成迭代对象

next()

返回当前迭代对象下一个位置的元素

list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
it
>>> <list_iterator at 0x1c4dffd9c40>

print (next(it))   # 输出迭代器的下一个元素
>>> 1

print (next(it))
>>> 2

python 的 生成器

描述

在 Python 中，使用了 yield 的函数被称为生成器（generator）.

跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器.注意：返回的是一个iter

在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行.

调用一个生成器函数，返回的是一个迭代器对象.

参考文献
[^1]: 李沐 动手学深度学习 V2.0.