1. 技术文章
  2. LinearRegression

LinearRegression

由 孤街醉人 提交于 2020-02-15 16:10:07

线性回归

主要内容包括：

  1. 线性回归的基本要素

  2. 线性回归模型从零开始的实现

  3. 线性回归模型使用pytorch的简洁实现

线性回归的基本要素

模型

为了简单起见，这里我们假设价格只取决于房屋状况的两个因素，即面积（平方米）和房龄（年）。接下来我们希望探索价格与这两个因素的具体关系。线性回归假设输出与各个输入之间是线性关系:

price=warea⋅area+wage⋅age+bprice=w_{area}⋅area+w_{age}⋅age+b

数据集

我们通常收集一系列的真实数据，例如多栋房屋的真实售出价格和它们对应的面积和房龄。我们希望在这个数据上面寻找模型参数来使模型的预测价格与真实价格的误差最小。在机器学习术语里，该数据集被称为训练数据集（training data set）或训练集（training set），一栋房屋被称为一个样本（sample），其真实售出价格叫作标签（label），用来预测标签的两个因素叫作特征（feature）。特征用来表征样本的特点。

损失函数

1、MAE/L1+MSE/L2MAE / L1 + MSE / L2

在模型训练中，我们需要衡量价格预测值与真实值之间的误差。通常我们会选取一个非负数作为误差，且数值越小表示误差越小。一个常用的选择是平方函数。 它在评估索引为 ii 的样本误差的表达式为

l(i)(w,b)=12(y^(i)−y(i))2,l^{(i)}(w,b)=\frac{1}{2}(\hat y^{(i)}−y^{(i)})^2,

L(w,b)=1n∑i=1nl(i)(w,b)=1n∑i=1n12(w⊤x(i)+b−y(i))2.L(w,b)=\frac{1}{n}\sum ^n _{i=1}l^{(i)}(w,b)=\frac{1}{n}\sum^n_{i=1}\frac{1}{2}(w^⊤x^{(i)}+b−y^{(i)})^2.

上面的损失函数属于MSE/L2MSE/L_2损失,令残差r=f(X)−yr=f(X)-y则MAE/L1MAE/L_1损失为：

L1(r)=∣r∣L_1(r)=|r|

MSE（L2损失）MSE（L_2损失）与MAE（L1损失）MAE（L_1损失）的分析：

简单来说，MSE计算简便，但MAE对异常点有更好的鲁棒性。训练一个机器学习模型时，目标就是找到损失函数达到极小值的点。当预测值等于真实值时，这两种函数都能达到最小。

  • 分析：MSE对误差取了平方（令rr=真实值-预测值），因此若rr>1，则MSE会进一步增大误差。如果数据中存在异常点，那么e值就会很大，而e²则会远大于|e|。因此，相对于使用MAE计算损失，使用MSE的模型会赋予异常点更大的权重。用RMSE（即MSE的平方根，同MAE在同一量级中）计算损失的模型会以牺牲了其他样本的误差为代价，朝着减小异常点误差的方向更新。然而这就会降低模型的整体性能。直观上可以这样理解：如果我们最小化MSE来对所有的样本点只给出一个预测值，那么这个值一定是所有目标值的平均值。但如果是最小化MAE，那么这个值，则会是所有样本点目标值的中位数。对异常值而言，中位数比均值更加鲁棒，因此MAE对于异常值也比MSE更稳定。

  • 如何选择损失函数：如果训练数据被异常点所污染（比如，在训练数据中存在大量错误的反例和正例标记，但是在测试集中没有这个问题）或者异常点代表在商业中很重要的异常情况，并且需要被检测出来，则应选用MSE损失函数。相反，如果只把异常值当作受损数据，则应选用MAE损失函数。
    MAE存在一个严重的问题（特别是对于神经网络）：更新的梯度始终相同，也就是说，即使对于很小的损失值，梯度也很大。这样不利于模型的学习。为了解决这个缺陷，可以使用变化的学习率，在损失接近最小值时降低学习率。
    MSE在这种情况下的表现就很好，即便使用固定的学习率也可以有效收敛。MSE损失的梯度随损失增大而增大，而损失趋于0时则会减小。这使得在训练结束时，使用MSE模型的结果会更精确。

  • 总结：处理异常点时，L1损失函数更稳定，但它的导数不连续，因此求解效率较低。L2损失函数对异常点更敏感，但通过令其导数为0，可以得到更稳定的封闭解。
    二者兼有的问题是：在某些情况下，上述两种损失函数都不能满足需求。例如，若数据中90%的样本对应的目标值为150，剩下10%在0到30之间。那么使用MAE作为损失函数的模型可能会忽视10%的异常点，而对所有样本的预测值都为150。这是因为模型会按中位数来预测。而使用MSE的模型则会给出很多介于0到30的预测值，因为模型会向异常点偏移。上述两种结果在许多商业场景中都是不可取的。最简单的办法是对目标变量进行变换。而另一种办法则是换一个损失函数。

2、Huber Loss

Lδ(y,f(x))={12(y−f(x))2for∣y−f(x)∣≤δδ∣y−f(x)∣−12δ2otherwiseL_\delta (y, f(x))= \begin{cases} \frac{1}{2}(y-f(x))^2 & for|y-f(x)|\leq \delta \\[2ex] \delta|y-f(x)|-\frac{1}{2}\delta ^ 2 & otherwise \end{cases}

Huber损失，平滑的平均绝对误差。Huber损失对数据中的异常点没有平方误差损失那么敏感。它在0也可微分。本质上，Huber损失是绝对误差，只是在误差很小时，就变为平方误差。误差降到多小时变为平方误差由超参数δ（delta）来控制。当Huber损失在 [0-δ\delta，0+δ\delta] 之间时，等价为MSE，而在 [−∞-\infty，δ\delta] 和 [δ\delta，+∞+\infty] 时为MAE。

这里超参数delta的选择非常重要，因为这决定了对异常点的定义。当残差大于delta，应当采用L1（对较大的异常值不那么敏感）来最小化，而残差小于超参数，则用L2来最小化。

如何选择损失函数：使用MAE训练神经网络最大的一个问题就是不变的大梯度，这可能导致在使用梯度下降快要结束时，错过了最小点。而对于MSE，梯度会随着损失的减小而减小，使结果更加精确。在这种情况下，Huber损失就非常有用。它会由于梯度的减小而落在最小值附近。比起MSE，它对异常点更加鲁棒。因此，Huber损失结合了MSE和MAE的优点。但是，Huber损失的问题是可能需要不断调整超参数delta。

3、Log-Cosh Loss

L(y,yp)=∑i=1nlog(cosh(yip)−yi)L(y,y^p)=\sum ^n _{i=1}log(cosh(y_i^p)-y_i)

Log-cosh损失是另一种应用于回归问题中的，且比L2更平滑的的损失函数。它的计算方式是预测误差的双曲余弦的对数。

优点：对于较小的xx，log(cosh(x))log(cosh(x))近似等于(x2)/2(x^2)/2，对于较大的xx，近似等于abs(x)−log(2)abs(x)-log(2)。这意味着‘logcosh’‘logcosh’基本类似于均方误差，但不易受到异常点的影响。它具有Huber损失所有的优点，但不同于Huber损失的是，Log-cosh二阶处处可微。

如何选择损失函数：许多机器学习模型如XGBoost，就是采用牛顿法来寻找最优点。而牛顿法就需要求解二阶导数（Hessian）。因此对于诸如XGBoost这类机器学习框架，损失函数的二阶可微是很有必要的。但Log-cosh损失也并非完美，其仍存在某些问题。比如误差很大的话，一阶梯度和Hessian会变成定值，这就导致XGBoost出现缺少分裂点的情况。

4、Quantile Loss

Lγ(u,yp)=∑i:yi<yip(1−γ)∣yi−yip∣+∑i:yi≥yipγ∣yi−yip∣L_\gamma(u,y^p)=\sum_{i:y_i<y_i^p}(1-\gamma)|y_i-y_i^p|+\sum_{i:y_i\geq y_i^p}\gamma|y_i-y_i^p|

许多商业问题的决策通常希望了解预测中的不确定性，更关注区间预测而不仅是点预测时，分位数损失函数就很有用。

使用最小二乘回归进行区间预测，基于的假设是残差（y−y^）（y-\hat{y}）是独立变量，且方差保持不变。一旦违背了这条假设，那么线性回归模型就不成立。这时，就可以使用分位数损失和分位数回归，因为即便对于具有变化方差或非正态分布的残差，基于分位数损失的回归也能给出合理的预测区间。

理解分位数损失函数：如何选取合适的分位值取决于我们对正误差和反误差的重视程度。损失函数通过分位值（γ）对高估和低估给予不同的惩罚。例如，当分位数损失函数γ=0.25时，对高估的惩罚更大，使得预测值略低于中值。

优化函数 - 随机梯度下降

当模型和损失函数形式较为简单时，上面的误差最小化问题的解可以直接用公式表达出来。这类解叫作解析解（analytical solution）。本节使用的线性回归和平方误差刚好属于这个范畴。然而，大多数深度学习模型并没有解析解，只能通过优化算法有限次迭代模型参数来尽可能降低损失函数的值。这类解叫作数值解（numerical solution）。

在求数值解的优化算法中，小批量随机梯度下降（mini-batch stochastic gradient descent）在深度学习中被广泛使用。它的算法很简单：先选取一组模型参数的初始值，如随机选取；接下来对参数进行多次迭代，使每次迭代都可能降低损失函数的值。在每次迭代中，先随机均匀采样一个由固定数目训练数据样本所组成的小批量（mini-batch） B ，然后求小批量中数据样本的平均损失有关模型参数的导数（梯度），最后用此结果与预先设定的一个正数的乘积作为模型参数在本次迭代的减小量。

(w,b)←(w,b)−η∣B∣∑i∈B∂(w,b)l(i)(w,b)(\mathbf{w},b) \leftarrow (\mathbf{w},b) - \frac{\eta}{|\mathcal{B}|} \sum_{i \in \mathcal{B}} \partial_{(\mathbf{w},b)} l^{(i)}(\mathbf{w},b)

学习率: η 代表在每次优化中，能够学习的步长的大小
批量大小: B 是小批量计算中的批量大小batch size

总结一下，优化函数的有以下两个步骤：

  • (i)初始化模型参数，一般来说使用随机初始化；
  • (ii)我们在数据上迭代多次，通过在负梯度方向移动参数来更新每个参数。

矢量计算

在模型训练或预测时，我们常常会同时处理多个数据样本并用到矢量计算。在介绍线性回归的矢量计算表达式之前，让我们先考虑对两个向量相加的两种方法。

  1. 向量相加的一种方法是，将这两个向量按元素逐一做标量加法。
  2. 向量相加的另一种方法是，将这两个向量直接做矢量加法。
import torch
import time

# init variable a, b as 1000 dimension vector
n = 1000
a = torch.ones(n)
b = torch.ones(n)

# define a timer class to record time
class Timer(object):
    """Record multiple running times."""
    def __init__(self):
        self.times = []
        self.start()

    def start(self):
        # start the timer
        self.start_time = time.time()

    def stop(self):
        # stop the timer and record time into a list
        self.times.append(time.time() - self.start_time)
        return self.times[-1]

    def avg(self):
        # calculate the average and return
        return sum(self.times)/len(self.times)

    def sum(self):
        # return the sum of recorded time
        return sum(self.times)

现在我们可以来测试了。首先将两个向量使用for循环按元素逐一做标量加法。

timer = Timer()
c = torch.zeros(n)
for i in range(n):
    c[i] = a[i] + b[i]
'%.5f sec' % timer.stop()

'0.04067 sec'

另外是使用torch来将两个向量直接做矢量加法：

timer.start()
d = a + b
'%.5f sec' % timer.stop()

'0.00000 sec'

结果很明显,后者比前者运算速度更快。因此，我们应该尽可能采用矢量计算，以提升计算效率。

线性回归模型从零开始的实现

# import packages and modules
%matplotlib inline
import torch
from IPython import display
from matplotlib import pyplot as plt
import numpy as np
import random
import seaborn as sns

print(torch.__version__)

1.4.0+cpu

生成数据集

使用线性模型来生成数据集，生成一个1000个样本的数据集，下面是用来生成数据的线性关系：
price=warea⋅area+wage⋅age+bprice=w_{area}⋅area+w_{age}⋅age+b

# set input feature number 
num_inputs = 2
# set example number
num_examples = 1000

# set true weight and bias in order to generate corresponded label
true_w = [2, -3.4]
true_b = 4.2

features = torch.randn(num_examples, num_inputs,
                      dtype=torch.float32)
labels = true_w[0] * features[:, 0] + true_w[1] * features[:, 1] + true_b
labels += torch.tensor(np.random.normal(0, 0.01, size=labels.size()),
                       dtype=torch.float32)

使用图像来展示生成的数据

plt.scatter(features[:, 1].numpy(), labels.numpy(), 1);  # plt.scatter(x, y, s=20)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-95QJFGFI-1581687791701)(output_13_0.png)]

读取数据集

def data_iter(batch_size, features, labels):
    num_examples = len(features)
    indices = list(range(num_examples))
    random.shuffle(indices)  # random read 10 samples
    for i in range(0, num_examples, batch_size):
        j = torch.LongTensor(indices[i: min(i + batch_size, num_examples)]) # the last time may be not enough for a whole batch
        yield  features.index_select(0, j), labels.index_select(0, j)

batch_size = 10

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

tensor([[-1.5533, -1.2282],
        [ 0.1451,  1.4294],
        [-0.3247, -0.6582],
        [-0.4311,  1.1138],
        [ 0.2255,  0.4859],
        [ 0.0138,  1.2828],
        [ 1.6966,  1.4811],
        [ 0.6216, -1.3915],
        [-0.1157,  0.6430],
        [ 0.2604,  1.9266]]) 
 tensor([ 5.2722, -0.3629,  5.7908, -0.4465,  2.9890, -0.1313,  2.5523, 10.1736,
         1.7958, -1.8457])

初始化模型参数

w = torch.tensor(np.random.normal(0, 0.01, (num_inputs, 1)), dtype=torch.float32) # 正态分布
b = torch.zeros(1, dtype=torch.float32)

w.requires_grad_(requires_grad=True)
b.requires_grad_(requires_grad=True)  # 需要求梯度

torch.Size([2, 1])

定义模型

定义用来训练参数的训练模型：
price=warea⋅area+wage⋅age+bprice=w_{area}⋅area+w_{age}⋅age+b

def linreg(X, w, b):
    return torch.mm(X, w) + b  # mm矩阵乘法

定义损失函数

我们使用的是均方误差损失函数：
l(i)(w,b)=12(y^(i)−y(i))2l^{(i)}(w,b)=\frac{1}{2}(\hat{y}^{(i)}-y^{(i)})^2

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LQssjlRU-1581687791702)(img/QQ截图20200211155017.png)]

def squared_loss(y_hat, y): 
    return (y_hat - y.view(y_hat.size())) ** 2 / 2  # view把y维度弄成和y帽一样

定义优化函数

在这里优化函数使用的是小批量随机梯度下降：
(w,b)←(w,b)−η∣B∣∑i∈B∂(w,b)l(i)(w,b)(\mathbf{w},b) \leftarrow (\mathbf{w},b) - \frac{\eta}{|\mathcal{B}|} \sum_{i \in \mathcal{B}} \partial_{(\mathbf{w},b)} l^{(i)}(\mathbf{w},b)

def sgd(params, lr, batch_size): 
    for param in params:
        param.data -= lr * param.grad / batch_size # ues .data to operate param without gradient track

训练

当数据集、模型、损失函数和优化函数定义完了之后就可来准备进行模型的训练了。

# super parameters init
lr = 0.03  # 学习率即步长
num_epochs = 5  # epoch训练5轮

net = linreg  # 模型
loss = squared_loss  # 损失函数

# training
for epoch in range(num_epochs):  # training repeats num_epochs times
    # in each epoch, all the samples in dataset will be used once
    
    # X is the feature and y is the label of a batch sample
    for X, y in data_iter(batch_size, features, labels):
        l = loss(net(X, w, b), y).sum()  
        # calculate the gradient of batch sample loss 
        l.backward()  
        # using small batch random gradient descent to iter model parameters
        sgd([w, b], lr, batch_size)  
        # reset parameter gradient
        w.grad.data.zero_()
        b.grad.data.zero_()
    train_l = loss(net(features, w, b), labels)
    print('epoch %d, loss %f' % (epoch + 1, train_l.mean().item()))

epoch 1, loss 0.038881
epoch 2, loss 0.000143
epoch 3, loss 0.000048
epoch 4, loss 0.000048
epoch 5, loss 0.000048

w, true_w, b, true_b

(tensor([[ 1.9993],
         [-3.3998]], requires_grad=True),
 [2, -3.4],
 tensor([4.2000], requires_grad=True),
 4.2)

线性回归模型使用pytorch的简洁实现

import torch
from torch import nn
import numpy as np
torch.manual_seed(1)

print(torch.__version__)
torch.set_default_tensor_type('torch.FloatTensor')

1.4.0+cpu

生成数据集

在这里生成数据集跟从零开始的实现中是完全一样的。

num_inputs = 2
num_examples = 1000

true_w = [2, -3.4]
true_b = 4.2

features = torch.tensor(np.random.normal(0, 1, (num_examples, num_inputs)), dtype=torch.float)
labels = true_w[0] * features[:, 0] + true_w[1] * features[:, 1] + true_b
labels += torch.tensor(np.random.normal(0, 0.01, size=labels.size()), dtype=torch.float)

读取数据集

import torch.utils.data as Data

batch_size = 10

# combine featues and labels of dataset
dataset = Data.TensorDataset(features, labels)

# put dataset into DataLoader
data_iter = Data.DataLoader(
    dataset=dataset,            # torch TensorDataset format
    batch_size=batch_size,      # mini batch size
    shuffle=True,               # whether shuffle the data or not 是否混淆
    num_workers=2,              # read data in multithreading 两个线程
)

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

tensor([[ 0.1144, -0.2228],
        [ 0.3022,  0.0972],
        [ 0.2309, -0.1299],
        [ 0.3725,  0.7687],
        [ 0.2221, -0.4771],
        [-0.0137,  0.7123],
        [-1.2542,  0.5133],
        [ 0.8199, -0.1336],
        [ 0.9226, -0.3770],
        [-0.4336,  0.4475]]) 
 tensor([ 5.1815,  4.4663,  5.0981,  2.3221,  6.2576,  1.7511, -0.0654,  6.3130,
         7.3475,  1.8041])

定义模型

class LinearNet(nn.Module):
    def __init__(self, n_feature):
        super(LinearNet, self).__init__()      # call father function to init 
        self.linear = nn.Linear(n_feature, 1)  # function prototype: `torch.nn.Linear(in_features, out_features, bias=True)`

    def forward(self, x):
        y = self.linear(x)
        return y
    
net = LinearNet(num_inputs)
print(net)

LinearNet(
  (linear): Linear(in_features=2, out_features=1, bias=True)
)

# ways to init a multilayer network
# method one
net = nn.Sequential(
    nn.Linear(num_inputs, 1)
    # other layers can be added here
    ) 

# method two
net = nn.Sequential()
net.add_module('linear', nn.Linear(num_inputs, 1))
# net.add_module ......

# method three
from collections import OrderedDict
net = nn.Sequential(OrderedDict([
          ('linear', nn.Linear(num_inputs, 1))
          # ......
        ]))

print(net)
print(net[0])

Sequential(
  (linear): Linear(in_features=2, out_features=1, bias=True)
)
Linear(in_features=2, out_features=1, bias=True)

初始化模型参数

from torch.nn import init

init.normal_(net[0].weight, mean=0.0, std=0.01)
init.constant_(net[0].bias, val=0.0)  # or you can use `net[0].bias.data.fill_(0)` to modify it directly

Parameter containing:
tensor([0.], requires_grad=True)

for param in net.parameters():
    print(param)

Parameter containing:
tensor([[-0.0142, -0.0161]], requires_grad=True)
Parameter containing:
tensor([0.], requires_grad=True)

定义损失函数

loss = nn.MSELoss()    # nn built-in squared loss function
                       # function prototype: `torch.nn.MSELoss(size_average=None, reduce=None, reduction='mean')`

定义优化函数

import torch.optim as optim

optimizer = optim.SGD(net.parameters(), lr=0.03)   # built-in random gradient descent function
print(optimizer)  # function prototype: `torch.optim.SGD(params, lr=, momentum=0, dampening=0, weight_decay=0, nesterov=False)`

SGD (
Parameter Group 0
    dampening: 0
    lr: 0.03
    momentum: 0
    nesterov: False
    weight_decay: 0
)

训练

num_epochs = 3
for epoch in range(1, num_epochs + 1):
    for X, y in data_iter:
        output = net(X)
        l = loss(output, y.view(-1, 1))
        optimizer.zero_grad() # reset gradient, equal to net.zero_grad()
        l.backward()
        optimizer.step()
    print('epoch %d, loss: %f' % (epoch, l.item()))

epoch 1, loss: 0.000369
epoch 2, loss: 0.000100
epoch 3, loss: 0.000132

# result comparision
dense = net[0]
print(true_w, dense.weight.data)
print(true_b, dense.bias.data)

[2, -3.4] tensor([[ 2.0004, -3.4000]])
4.2 tensor([4.1998])

两种实现方式的比较

  1. 从零开始的实现（推荐用来学习）

能够更好的理解模型和神经网络底层的原理

  1. 使用pytorch的简洁实现

能够更加快速地完成模型的设计与实现

import torch
import time

# init variable a, b as 1000 dimension vector
n = 1000
a = torch.ones(n)
b = torch.ones(n)
class Timer(object):
    """Record multiple running times."""
    def __init__(self):
        self.times = []
        self.start()

    def start(self):
        # start the timer
        self.start_time = time.time()

    def stop(self):
        # stop the timer and record time into a list
        self.times.append(time.time() - self.start_time)
        return self.times[-1]

    def avg(self):
        # calculate the average and return
        return sum(self.times)/len(self.times)

    def sum(self):
        # return the sum of recorded time
        return sum(self.times)
timer =Timer()
c=torch.zeros(n)
for i in range(n):
    c[i]=a[i]+b[i]
print ('%.5f sec'%timer .stop())
timer.start()
d=a+b
print ('%.5f sec'%timer.stop())

线性回归模型从零开始的实现

import torch
import random
import numpy as np
from matplotlib import pyplot as plt
print (torch.__version__)
#set input feature number
num_inputs=2
#set example number
num_examples=1000
true_w=[2,-3.4]
true_b=4.2
features=torch.randn(num_examples,num_inputs,dtype=torch.float32)
labels =true_w[0]*features[:,0]+true_w[1]*features[:,1]+true_b
#--------------
#读取数据集
#--------------
def data_iter(batch_size,features,labels):
    num_examples=len(features)
    indices=list(range(num_examples))
    random.shuffle(indices)
    for i in range (0,num_examples,batch_size):
        j=torch.LongTensor(indices[i:min(i+batch_size,num_examples)])
        yield features.index_select(0,j),labels.index_select(0,j)
batch_size=10
for X,y in data_iter(batch_size,features,labels):
    print(X,'\n',y)
    break
#-------------------------------------
#初始化模型参数
#线性回归模型y=wx+b,参数只有两个张量 w  和 b
#-----------------------
w=torch.tensor(np.random.normal(0,0.01,(num_inputs,1)),dtype=torch.float32)
b=torch.zeros(1,dtype=torch.float32)
w.requires_grad_(requires_grad=True)
b.requires_grad_(requires_grad=True)



#-----------------------------
#定义模型
#--------------------------------
def linreg(X,w,b):
    return torch.mm(X,w)+b         #注意区分torch .mul点乘 和 torch.mm 矩阵乘法的区别
#----------------------------------------
#定义损失函数
#-----------------------------------
def squared_loss(y_hat,y):
    return (y_hat-y.view(y_hat.size()))**2/2
#--------------------------------------------------
#定义优化函数
#---------------------------------------
def sgd (params,lr,bath_size):
    for param in params:
        param.data-=lr*param.grad/batch_size
#---------------------------------------------------------------------------------------------------
#训练流程
#---------------------------------------------------------------
#super parameters init
# lr=0.03
# num_epochs=5
# net=linreg
# loss=squared_loss
# for epoch in range (num_epochs):
#     for X,y in data_iter(batch_size,features,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_l=loss(net(features,w,b),labels)
#     print ('epoch %d, loss %f'%(epoch+1,train_l.mean().item()))
# super parameters init
lr = 0.03
num_epochs = 5

net = linreg
loss = squared_loss

# training
for epoch in range(num_epochs):  # training repeats num_epochs times
    # in each epoch, all the samples in dataset will be used once

    # X is the feature and y is the label of a batch sample
    for X, y in data_iter(batch_size, features, labels):
        l = loss(net(X, w, b), y).sum()
        # calculate the gradient of batch sample loss
        l.backward()
        # using small batch random gradient descent to iter model parameters
        sgd([w, b], lr, batch_size)
        # reset parameter gradient
        w.grad.data.zero_()
        b.grad.data.zero_()
    train_l = loss(net(features, w, b), labels)
    print('epoch %d, loss %f' % (epoch + 1, train_l.mean().item()))

torch简洁实现

import torch
import random
import numpy as np
from matplotlib import pyplot as plt
print (torch.__version__)
#set input feature number
num_inputs=2
#set example number
num_examples=1000
true_w=[2,-3.4]
true_b=4.2
features=torch.randn(num_examples,num_inputs,dtype=torch.float32)
labels =true_w[0]*features[:,0]+true_w[1]*features[:,1]+true_b
#--------------
#读取数据集
#--------------
def data_iter(batch_size,features,labels):
    num_examples=len(features)
    indices=list(range(num_examples))
    random.shuffle(indices)
    for i in range (0,num_examples,batch_size):
        j=torch.LongTensor(indices[i:min(i+batch_size,num_examples)])
        yield features.index_select(0,j),labels.index_select(0,j)
batch_size=10
for X,y in data_iter(batch_size,features,labels):
    print(X,'\n',y)
    break
#-------------------------------------
#初始化模型参数
#线性回归模型y=wx+b,参数只有两个张量 w  和 b
#-----------------------
w=torch.tensor(np.random.normal(0,0.01,(num_inputs,1)),dtype=torch.float32)
b=torch.zeros(1,dtype=torch.float32)
w.requires_grad_(requires_grad=True)
b.requires_grad_(requires_grad=True)



#-----------------------------
#定义模型
#--------------------------------
def linreg(X,w,b):
    return torch.mm(X,w)+b         #注意区分torch .mul点乘 和 torch.mm 矩阵乘法的区别
#----------------------------------------
#定义损失函数
#-----------------------------------
def squared_loss(y_hat,y):
    return (y_hat-y.view(y_hat.size()))**2/2
#--------------------------------------------------
#定义优化函数
#---------------------------------------
def sgd (params,lr,bath_size):
    for param in params:
        param.data-=lr*param.grad/batch_size
#---------------------------------------------------------------------------------------------------
#训练流程
#---------------------------------------------------------------
#super parameters init
# lr=0.03
# num_epochs=5
# net=linreg
# loss=squared_loss
# for epoch in range (num_epochs):
#     for X,y in data_iter(batch_size,features,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_l=loss(net(features,w,b),labels)
#     print ('epoch %d, loss %f'%(epoch+1,train_l.mean().item()))
# super parameters init
lr = 0.03
num_epochs = 5

net = linreg
loss = squared_loss

# training
for epoch in range(num_epochs):  # training repeats num_epochs times
    # in each epoch, all the samples in dataset will be used once

    # X is the feature and y is the label of a batch sample
    for X, y in data_iter(batch_size, features, labels):
        l = loss(net(X, w, b), y).sum()
        # calculate the gradient of batch sample loss
        l.backward()
        # using small batch random gradient descent to iter model parameters
        sgd([w, b], lr, batch_size)
        # reset parameter gradient
        w.grad.data.zero_()
        b.grad.data.zero_()
    train_l = loss(net(features, w, b), labels)
    print('epoch %d, loss %f' % (epoch + 1, train_l.mean().item()))

总结

torch.mm对应位相乘 和 torch.mul 矩阵乘法
torch.manual_seed(1)初始化随机数种子
optimizer.zero_grad()清楚上一次运算的梯度
均方误差MSELoss有的教材里没有除以2？为了在求导时和均方的平方互相抵消掉。
.data的修改不会被autograd追踪，这样当进行backward()时它不会报错，回得到一个错误的backward值

标签
损失函数
预测模型
误差分析
num
mse
“人造太阳”计划
易学教程内所有资源均来自网络或用户发布的内容，如有违反法律规定的内容欢迎反馈！
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!