深度学习+pytorch自学笔记（三）——线性回归

参考书籍《动手学深度学习(pytorch版），参考网址为：https://tangshusen.me/Dive-into-DL-PyTorch/#/
请大家也多多支持这一个很好用的平台~

大部分内容为书中内容，也有部分自己实验和添加的内容，如涉及侵权，会进行删除。

正文——线性回归

一、概念
线性回归输出是一个连续值，因此适用于回归问题。回归问题在实际中很常见，如预测房屋价格、气温、销售额等连续值的问题。

二、基本例子

我们以一个简单的房屋价格预测作为例子来解释线性回归的基本要素。这个应用的目标是预测一栋房子的售出价格（元）。我们知道这个价格取决于很多因素，如房屋状况、地段、市场行情等。为了简单起见，这里我们假设价格只取决于房屋状况的两个因素，即面积（平方米）和房龄（年）。接下来我们希望探索价格与这两个因素的具体关系。

设房屋的面积为 x1，房龄为 x2，售出价格为 y。我们需要建立基于输入 x1和 x2x来计算输出 yy的表达式，也就是模型（model）。顾名思义，线性回归假设输出与各个输入之间是线性关系：

​
其中 w1 和 w2是权重（weight），b是偏差（bias），且均为标量。它们是线性回归模型的参数（parameter）。模型输出 yˆ 是线性回归对真实价格 y 的预测或估计。我们通常允许它们之间有一定误差。

接下来我们需要通过数据来寻找特定的模型参数值，使模型在数据上的误差尽可能小。这个过程叫作模型训练（model training）。下面我们介绍模型训练所涉及的3个要素。

(1) 训练数据

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

(2) 损失函数

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

其中常数 1/2使对平方项求导后的常数系数为1，这样在形式上稍微简单一些。显然，误差越小表示预测价格与真实价格越相近，且当二者相等时误差为0。给定训练数据集，这个误差只与模型参数相关，因此我们将它记为以模型参数为参数的函数。在机器学习里，将衡量误差的函数称为损失函数（loss function）。这里使用的平方误差函数也称为平方损失（square loss）。

通常，我们用训练数据集中所有样本误差的平均来衡量模型预测的质量，即


(3) 优化算法

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

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

在训练本节讨论的线性回归模型的过程中，模型的每个参数将作如下迭代：

在上式中，∣B∣ 代表每个小批量中的样本个数（批量大小，batch size），η 称作学习率（learning rate）并取正数。需要强调的是，这里的批量大小和学习率的值是人为设定的，并不是通过模型训练学出的，因此叫作超参数（hyperparameter）。**我们通常所说的“调参”指的正是调节超参数，例如通过反复试错来找到超参数合适的值。**在少数情况下，超参数也可以通过模型训练学出。

模型训练完成后，我们将模型参数 w1,w2,b在优化算法停止时的值分别记作 wˆ1,wˆ2,bˆ 。注意，这里我们得到的并不一定是最小化损失函数的最优解 w∗1,w∗2,b∗ ，而是对最优解的一个近似。然后，我们就可以使用学出的线性回归模型 x1wˆ1+x2wˆ2+bˆ 来估算训练数据集以外任意一栋面积（平方米）为x1、房龄（年）为x2的房屋的价格了。这里的估算也叫作模型预测、模型推断或模型测试。

三、线性回归表示方法

在深度学习中，我们可以使用神经网络图直观地表现模型结构。为了更清晰地展示线性回归作为神经网络的结构，图3.1使用神经网络图表示本节中介绍的线性回归模型。神经网络图隐去了模型参数权重和偏差。

在图3.1所示的神经网络中，输入分别为 x1和 x2，因此输入层的输入个数为2。输入个数也叫特征数或特征向量维度。图3.1中网络的输出为 o，输出层的输出个数为1。需要注意的是，我们直接将图3.1中神经网络的输出 o 作为线性回归的输出，即 yˆ=o 。由于输入层并不涉及计算，按照惯例，图3.1所示的神经网络的层数为1。所以，线性回归是一个单层神经网络。输出层中负责计算 o 的单元又叫神经元。在线性回归中，o 的计算依赖于 x1和 x2。也就是说，输出层中的神经元和输入层中各个输入完全连接。因此，这里的输出层又叫全连接层（fully-connected layer）或稠密层（dense layer）。

四、编程实现——从零开始

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

#构造一个简单的人工训练数据集
num_inputs = 2
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  #y = w1*x1+w2*x2+b
labels += torch.tensor(np.random.normal(0, 0.01, size=labels.size()),  #给标签加点儿噪声
                       dtype=torch.float32)

print(features[0], labels[0])
print(features.shape, labels.shape)

#通过生成第二个特征features[:, 1]和标签 labels 的散点图，可以更直观地观察两者间的线性关系
plt.scatter(features[:, 1].numpy(), labels.numpy(), 1)
plt.show()

#在训练模型的时候，我们需要遍历数据集并不断读取小批量数据样本。这里我们定义一个函数：它每次返回batch_size（批量大小）个随机样本的特征和标签。
def data_iter(batch_size, features, labels):
    num_examples = len(features)#星1
    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)]) # 最后一次可能不足一个batch，#min函数防止超出样本个数
        #torch.Tensor默认是torch.FloatTensor是32位浮点类型数据，torch.LongTensor是64位整型
        yield  features.index_select(0, j), labels.index_select(0, j)#yield就是 return 返回一个值，并且记住这个返回的位置，下次迭代就从这个位置后开始   星2

#读取第一个小批量数据样本并打印。每个批量的特征形状为(10, 2)，分别对应批量大小和输入个数；标签形状为批量大小。
batch_size = 10
for X, y in data_iter(batch_size, features, labels):
    print(X, y)
    break

#将权重初始化成均值为0、标准差为0.01的正态随机数，偏差则初始化成0。
w = torch.tensor(np.random.normal(0, 0.01, (num_inputs, 1)), dtype=torch.float32)
b = torch.zeros(1, dtype=torch.float32)
#之后的模型训练中，需要对这些参数求梯度来迭代参数的值，因此我们要让它们的requires_grad=True
w.requires_grad_(requires_grad=True)
b.requires_grad_(requires_grad=True)

#定义模型
def linreg(X, w, b):  # 本函数已保存在d2lzh_pytorch包中方便以后使用
    return torch.mm(X, w) + b

#定义损失函数
def squared_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 -= lr * param.grad / batch_size # 注意这里更改param时用的param.data，防止被求梯度

#训练模型
lr = 0.03 #学习率
num_epochs = 3 #迭代次数
net = linreg
loss = squared_loss

for epoch in range(num_epochs):  # 训练模型一共需要num_epochs个迭代周期
    # 在每一个迭代周期中，会使用训练数据集中所有样本一次（假设样本数能够被批量大小整除）。X
    # 和y分别是小批量样本的特征和标签
    for X, y in data_iter(batch_size, features, labels):
        l = loss(net(X, w, b), y).sum()  # l是有关小批量X和y的损失
        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()))

#比较学到的参数和用来生成训练集的真实参数
print(true_w, '\n', w)
print(true_b, '\n', b)

输出：

tensor([ 0.2978, -1.4712]) tensor(9.8123)
torch.Size([1000, 2]) torch.Size([1000])
tensor([[ 0.2254,  1.0722],
        [ 0.0742, -1.0288],
        [-0.0998, -1.0434],
        [-0.1811, -0.5308],
        [ 0.6089, -0.4339],
        [ 1.6132,  1.1606],
        [-0.4886,  0.3814],
        [-2.5397,  0.1622],
        [ 0.9938,  1.5444],
        [ 0.2006,  0.5222]]) tensor([ 1.0101,  7.8434,  7.5516,  5.6336,  6.8956,  3.4759,  1.9282, -1.4244,
         0.9225,  2.8255])
epoch 1, loss 0.044245
epoch 2, loss 0.000170
epoch 3, loss 0.000049
[2, -3.4] 
 tensor([[ 1.9993],
        [-3.4005]], requires_grad=True)
4.2 
 tensor([4.1993], requires_grad=True)

生成的图片：

注意事项：（星标记）
1.len(A)的方法：如果A是个矩阵，则返回的是矩阵的行数。
2.index_select()的用法：
第一个参数是索引的对象，第二个参数0表示按行索引，1表示按列进行索引，第三个参数是一个tensor，就是索引的序号，比如tensor[0， 2]表示第0行和第2行

五、线性回归的简洁实现（利用pytorch)

程序实现：

import numpy as np
import torch
import torch.utils.data as Data # 由于data常用作变量名，我们将导入的data模块用Data代替
from torch import nn#nn是神经网络的缩写
from torch.nn import init
import torch.optim as optim


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)

batch_size = 10
# 将训练数据的特征和标签组合
dataset = Data.TensorDataset(features, labels)
# 随机读取小批量
data_iter = Data.DataLoader(dataset, batch_size, shuffle=True)

for X, y in data_iter:
    print(X, y)
    break

#Sequential是一个有序的容器，网络层将按照在传入Sequential的顺序依次被添加到计算图中
net = nn.Sequential(
    nn.Linear(num_inputs, 1)
    # 此处还可以传入其他层
    )
for param in net.parameters(): #可以通过net.parameters()来查看模型所有的可学习参数，此函数将返回一个生成器
    print(param)


#通过init.normal_将权重参数每个元素初始化为随机采样于均值为0、标准差为0.01的正态分布。偏差会初始化为零。
init.normal_(net[0].weight, mean=0, std=0.01)
init.constant_(net[0].bias, val=0)  # 也可以直接修改bias的data: net[0].bias.data.fill_(0)
# 定义损失函数
loss = nn.MSELoss()
# 定义优化算法
optimizer = optim.SGD(net.parameters(), lr=0.03)
print(optimizer)
#训练模型
num_epochs = 3
for epoch in range(1, num_epochs + 1):
    for X, y in data_iter(batch_size, features, labels):
        output = net(X)
        l = loss(output, y.view(-1, 1))
        optimizer.zero_grad() # 梯度清零，等价于net.zero_grad()
        l.backward()
        optimizer.step()
    print('epoch %d, loss: %f' % (epoch, l.item()))
#分别比较学到的模型参数和真实的模型参数
dense = net[0]
print(true_w, dense.weight)
print(true_b, dense.bias)

输出：

tensor([[ 0.6050, -0.9000],
        [ 0.6541, -1.2699],
        [ 0.1966, -1.6232],
        [-1.9254, -0.4009],
        [ 0.8032, -0.3430],
        [-1.9624, -0.8987],
        [-1.5937, -1.1763],
        [-2.5158, -0.7578],
        [ 0.8001, -0.5710],
        [-0.9854,  0.0255]]) tensor([ 8.4654,  9.8429, 10.1141,  1.7143,  6.9777,  3.3293,  4.9944,  1.7558,
         7.7439,  2.1216])
Parameter containing:
tensor([[ 0.0637, -0.3207]], requires_grad=True)
Parameter containing:
tensor([-0.1270], requires_grad=True)
SGD (
Parameter Group 0
    dampening: 0
    lr: 0.03
    momentum: 0
    nesterov: False
    weight_decay: 0
)
epoch 1, loss: 0.000200
epoch 2, loss: 0.000074
epoch 3, loss: 0.000103
[2, -3.4] Parameter containing:
tensor([[ 2.0000, -3.4005]], requires_grad=True)
4.2 Parameter containing:
tensor([4.1997], requires_grad=True)

六、部分函数代码拓展

1.python的zip函数

原文链接：https://blog.csdn.net/csdn15698845876/article/details/73411541

zip函数的原型为：zip([iterable, …])

参数iterable为可迭代的对象，并且可以有多个参数。该函数返回一个以元组为元素的列表，其中第 i 个元组包含每个参数序列的第 i 个元素。返回的列表长度被截断为最短的参数序列的长度。只有一个序列参数时，它返回一个1元组的列表。没有参数时，它返回一个空的列表。

实验程序：

import numpy as np
#多个参数长度相同
a = [1,2,3,4,5]
b = (1,2,3,4,5)
c = np.arange(5)
d = "abcde"
abcd = zip(a,b,c,d)
print(abcd)
print(list(abcd))#加了list才能打印出来
print('-' * 50)
#仅一个参数
e = [1,2,3]
ee = zip(e)
print(list(ee))
print('-' * 50)
#多个参数长度不同
f = [1,2,3]
g = [4,5,6,7]
h = [8,9,10,11,12]
fgh = zip(f,g,h)
print(list(fgh))
print('-' * 50)
#加*用来unzip
#这里输出的每个都是元组，而不一定是原来的类型，但是值不会发生变化,除非原来的参数列表长度不一样
fgh = zip(f,g,h)
x, y, z = zip(*fgh)#这里注意，如果fgh已转化为list型，则不可被upzip
print(x)
print(y)
print(z)

输出：

<zip object at 0x000001967065CA48>
[(1, 1, 0, 'a'), (2, 2, 1, 'b'), (3, 3, 2, 'c'), (4, 4, 3, 'd'), (5, 5, 4, 'e')]
--------------------------------------------------
[(1,), (2,), (3,)]
--------------------------------------------------
[(1, 4, 8), (2, 5, 9), (3, 6, 10)]
--------------------------------------------------
(1, 2, 3)
(4, 5, 6)
(8, 9, 10)

2.PyTorch的TensorDataset和Data.DataLoader

参考博客：
https://blog.csdn.net/qq_40211493/article/details/107529148

http://blog.sciencenet.cn/home.php?mod=space&uid=3428464&do=blog&id=1251867

TensorDataset 可以用来对 tensor 进行打包，就好像 python 中的 zip 功能。该类通过每一个 tensor 的第一个维度进行索引。因此，该类中的 tensor 第一维度必须相等。

而Data.DataLoader用来把训练数据分成多个小组，此函数每次抛出一组数据。直至把所有的数据都抛出。就是做一个数据的初始化。

实验程序：

import numpy as np
import torch
import torch.utils.data as Data # 由于data常用作变量名，我们将导入的data模块用Data代替

a = torch.tensor([[1,2,3],[4,5,6],[7,8,9],[10,11,12]])
b = torch.tensor([111,222,333,444])

c = Data.TensorDataset(a,b)
print(c)
print(list(c))
print('-' * 100)
d= Data.DataLoader(c,2) #以批量为2的往外读取
print(list(d))

输出：

<torch.utils.data.dataset.TensorDataset object at 0x00000262882342C8>
[(tensor([1, 2, 3]), tensor(111)), (tensor([4, 5, 6]), tensor(222)), (tensor([7, 8, 9]), tensor(333)), (tensor([10, 11, 12]), tensor(444))]
----------------------------------------------------------------------------------------------------
[[tensor([[1, 2, 3],
        [4, 5, 6]]), tensor([111, 222])], [tensor([[ 7,  8,  9],
        [10, 11, 12]]), tensor([333, 444])]]

3.iter()函数和next()函数

参考博客：https://www.cnblogs.com/wangzaixue/p/13539566.html

在python中，列表、元组、字典和集合都是可迭代的对象。它们是可迭代的容器，您可以从中获取迭代器（Iterator）。所有这些对象都有用于获取迭代器的 iter() 方法：iter()方法创建了一个迭代器，你可以用next（）方法逐一把迭代器中的元素给取出来。一旦取值完毕，这个迭代器也就失效。

mytuple = ("apple", "banana", "cherry")
myit = iter(mytuple)

print(next(myit))
print(next(myit))
print(next(myit))

print('-' * 100)
#这段代码，等同于下面的for循环,for循环其实就是创建了一个迭代器，并且为每次循环自动执行netx（）方法
for myit in mytuple:
    print(myit)

apple
banana
cherry
----------------------------------------------------------------------------------------------------
apple
banana
cherry