wordpress修改文章阅读量企业网站优化外包

动手学深度学习网址：动手学深度学习

注：本部分只对基础知识进行简单的介绍并附上完整的代码实现，更多内容可参考上述网址。

简述

需要的准备知识

• 数学的偏导
• 线性代数

线性模型

回归是能为一个或多个自变量与因变量之间关系建模的一类方法。 在自然科学和社会科学领域，回归经常用来表示输入和输出之间的关系。

线性回归基于几个简单的假设： 首先，假设自变量x和因变量y之间的关系是线性的， 即y可以表示为中元素的x加权和，这里通常允许包含观测值的一些噪声； 其次，我们假设任何噪声都比较正常，如噪声遵循正态分布。
给定一个数据集，线性回归的目标是寻找模型的权重w和偏差b。公式为：

将权重放到一个向量里面，变成：

损失函数

使用平方误差：

其中y是真实的数据。
将上式展开，为：

最终的目标就是寻找一组参数（w,b），这组参数能最小化在所有训练样本上的总损失，即：

优化方法

在训练过程中需要不断优化w和b，使得最终的损失达到最小，这就需要一种优化方法，通常使用的式梯度下降方法。
对于线性回归，参数更新的形式为：

因为在每一次更新参数之前，我们必须遍历整个数据集。 因此，**我们通常会在每次需要计算更新的时候随机抽取一小批样本， 这种变体叫做小批量随机梯度下降。**如上图所示，其中的B就是选取的小批量样本个数，n是学习率。

将上述式子展开，为：

代码

从头开始实现线性回归

1.生成数据集

我们生成一个包含1000个样本的数据集， 每个样本包含从标准正态分布中采样的2个特征。

import torch
import random
from d2l import torch as d2l
# 生成数据集
def generate_data(w,b,num_examples):# 生成正太分布的数据X = torch.normal(0,1,(num_examples,len(w)))# 进行矩阵乘法y = torch.matmul(X,w) + by += torch.normal(0,0.01,y.shape)return X,y.reshape((-1,1))
# 真实的w
true_w = torch.tensor([2,-3.4])
# 真实的b
true_b = 4.2
# features shape: N * len(W)
# lables shape: N
features,labels = generate_data(true_w,true_b,1000)
print('features:',features[0],'\nlabel:',labels[0])
# 展示生成的数据
d2l.set_figsize()
d2l.plt.scatter(features[:,1].detach().numpy(),labels.detach().numpy(),1)

2.读取数据操作

定义一个data_iter函数， 该函数接收批量大小、特征矩阵和标签向量作为输入，生成大小为batch_size的小批量。

# 小批量读取数据集
def data_iter(batch_size,features,lables):# 获取第一维的大小num_examples = len(features)indices = list(range(num_examples))# 打乱顺序random.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]
# 调用该函数
# 小批量大小为10
batch_size = 10
for X,y in data_iter(batch_size,features,batch_size):print(X,'\n',y)break

3.定义模型相关部分

（1）初始化参数
我们通过从均值为0、标准差为0.01的正态分布中采样随机数来初始化权重， 并将偏置初始化为0。

（2）定义模型
使用wx+b形式。

（3）损失函数
使用平方损失函数

（4）优化方法
在每一步中，使用从数据集中随机抽取的一个小批量，然后根据参数计算损失的梯度。 接下来，朝着减少损失的方向更新我们的参数。 每一步更新的大小由学习速率lr决定。 因为我们计算的损失是一个批量样本的总和，所以我们用批量大小（batch_size） 来规范化步长，这样步长大小就不会取决于我们对批量大小的选择。

# 初始化模型参数
def init_params():# w服从均值为0,方差为0.01的正太分布,大小为(2,1)w = torch.normal(0,0.01,(2,1),requires_grad = True)b = torch.zeros(1,requires_grad = True)return w,b
# 定义模型
def linear_reg(X,w,b):# wx + breturn torch.matmul(X,w) + b# 定义损失函数
def squared_loss(y_pred,y):return (y_pred - y.reshape(y_pred.shape)) ** 2 / 2# 定义优化算法
def sgd(params,lr,batch_size):# 使梯度计算disablewith torch.no_grad():for param in params:param -= lr * param.grad / batch_size# 手动将梯度设置成 0 ，在下一次计算梯度的时候就不会和上一次相关了param.grad.zero_()

4.训练模型

执行以下循环：

• 初始化参数
• 重复以下训练，直到完成
  • 计算梯度 （l.sum().backward()）
  • 更新参数（sgd）

# 训练
# 学习率
lr = 0.02
# 迭代次数
num_epoches = 3
net = linear_reg
loss = squared_loss
w,b = init_params()
for epoch in range(num_epoches):for X,y in data_iter(batch_size,features,labels):l = loss(net(X,w,b),y)# 后向传播计算梯度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())}')print(f'w的估计误差: {true_w - w.reshape(true_w.shape)}')
print(f'b的估计误差: {true_b - b}')

线性回归的框架实现

# 简洁实现
import numpy as np
import torch
from torch.utils import data
from d2l import torch as d2l
from torch import nntrue_w = torch.tensor([2,-3.4])
true_b = 4.2
# 生成数据集
features,labels = d2l.synthetic_data(true_w,true_b,1000)def load_dataset(data_arrs,batch_size,is_train = True):dataset = data.TensorDataset(*data_arrs)return data.DataLoader(dataset,batch_size,shuffle=is_train)batch_size = 10
data_iter = load_dataset((features,labels),batch_size)
# iter构造迭代器
next(iter(data_iter))# 定义模型
net = nn.Sequential(nn.Linear(2,1))
# 初始化参数,注意上面使用的是nn.Sequential，创造的是一个序列,所以net[0]表示我们的网络
net[0].weight.data.normal_(0,0.01)
net[0].bias.data.fill_(0)
# 损失函数
loss = nn.MSELoss()
# 优化算法
trainer = torch.optim.SGD(net.parameters(),lr = 0.03)
# 训练
num_epoches = 3
for epoch in range(num_epoches):for X,y in data_iter:l = loss(net(X),y)# 将梯度重置为0trainer.zero_grad()# 计算梯度l.backward()# 更新所有的参数trainer.step()l = loss(net(features),labels)print(f'epch {epoch + 1} loss {l:f}')
w = net[0].weight.data
b = net[0].bias.data
print(f'w的估计误差: {true_w - w.reshape(true_w.shape)}')
print(f'b的估计误差: {true_b - b}')