动手学深度学习（线性神经网络）

看这一节前最好先移动至--动手学深度学习（预备知识），把基础知识打牢，使后续理解代码和原理更加容易

因为这里是第三章的内容了，所以笔者的目录就从3开始咯。

目录

3.线性神经网络

3.1线性回归

3.11线性回归的基本元素

3.12损失函数

3.13解析解

3.14随机梯度下降

3.15矢量化加速

3.16正态分布

3.2线性回归从零开始实现

生成数据集

读取数据集

初始化模型参数

定义模型

定义损失函数

 小批量随机梯度下降

训练

3.3线性回归简洁实现

---

3.线性神经网络

3.1线性回归

3.11线性回归的基本元素

学基本元素之前，我们需要先理解回归和分类的区别

相同点：两者都是对输入的特征，判断并预测类别。

不同点：

1.输出不同。  分类问题是输出物体所属类别，回归问题是输出值。

比如说：南阳最近下暴雨，分类问题就会输出过几天是下雨，还是多云，还是晴天。回归问题，就会判断过几天的温度是多少到多少摄氏度。

分类问题是定性的，离散的，回归问题是定量的，连续的。

2.目的不同。

分类的目的是为了寻找决策边界，即分类算法得到是一个决策面，用于对数据集中的数据进行分类。

回归的目的是为了找到最优拟合，通过回归算法得到是一个最优拟合线，这个线条可以最好的接近数据集中的各个点。

3.结果不同。

分类的结果说一不二，回归可以有逼近，损失很小就是很不错的回归了。

---

接下来就是基本元素了，这里我们用一款皮肤的价格来进行举例。

我们根据英雄的出场率和平台中英雄的热度以及之前发售皮肤的品质收割的利润来预测这个英雄该出多少价格区间的皮肤。

研制这个模型需要以下方面：

训练数据集：英雄的出场率和平台中英雄的热度以及之前发售皮肤的品质。

样本：每一次发售的皮肤相对应的数据。(每行数据)

标签或目标：预测的皮肤价格

自变量：出场率和销量等等。

线性是可以用一个方程式来表示

这个式子其实是一个仿射变换。通过（加权和）对特征进行线性变换，并通过偏置进行平移。

（仿射变换变化包括缩放（Scale、平移(transform)、旋转(rotate)、反射（reflection,对图形照镜子）、错切(shear mapping，感觉像是一个图形的倒影)，原来的直线仿射变换后还是直线，原来的平行线经过仿射变换之后还是平行线，这就是仿射）

特征比较多的时候我们就会有多个w权重，但后面b是一个

---

3.12损失函数

在我们开始考虑如何用模型拟合数据之前，我们需要确定一个拟合程度的度量。

损失函数（loss function）能够量化目标的实际值与预测值之间的差距.

通常我们会选择非负数作为损失，且数值越小表示损失越小，完美预测时的损失为0。

回归问题中最常用的损失函数是平方误差函数:

第一个y代表预测，第二个y代表真实

y可以用wx+b来表示

训练模型时我们需要不断更新w和b使在所有样本中有最小损失

3.13解析解

预测问题是最小化||y-Xw||

这在损失平面上只有一个临界点，这个临界点对应于整个区域的损失极小点。

将损失关于𝑤的导数设为0,也就是||y-Xw||对w求导等于0，所求出来的w就是最符合的w

求导最终值

3.14随机梯度下降

y=wx+b

w表示权重 表示偏置

以房子举例 x为房子面积 y为房子价格

已知y，把b去掉

假设w已经算出来了

求（wx-y）**2越小说明与结果越接近

w底t= w（底t-1）-学习率*w的导数

循环迭代

也就是这么个过程

正常的梯度下降在每一次更新前都要遍历整个数据集

而小批量随机梯度下降就是定义超参数批量数

结果：

即使我们的函数确实是线性的且无噪声，这些估计值也不会使损失函数真正地达到最小值。 因为算法会使得损失向最小值缓慢收敛，但却不能在有限的步数内非常精确地达到最小值。

泛化：

在训练集表现良好，遇见没有见过的数据进行处理的能力。

如果处理的比较好，就叫做泛化能力强；否则就是泛化能力弱

3.15矢量化加速

在训练我们的模型时，我们经常希望能够同时处理整个小批量的样本。

为了实现这一点，需要我们对计算进行矢量化， 从而利用线性代数库，而不是在Python中编写开销高昂的for循环。

import math
import time
import numpy as np
import torch
from d2l import torch as d2l
n = 10000
a = torch.ones([n])
b = torch.ones([n])
class Timer:  #@save
    """记录多次运行时间"""
    def __init__(self):
        self.times = []
        self.start()

    def start(self):
        """启动计时器"""
        self.tik = time.time()

    def stop(self):
        """停止计时器并将时间记录在列表中"""
        self.times.append(time.time() - self.tik)
        return self.times[-1]

    def avg(self):
        """返回平均时间"""
        return sum(self.times) / len(self.times)

    def sum(self):
        """返回时间总和"""
        return sum(self.times)

    def cumsum(self):
        """返回累计时间"""
        return np.array(self.times).cumsum().tolist()

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

运行该代码可以很轻松的得出所用时间的区别

3.16正态分布

正态分布的代码函数：

def normal(x, mu, sigma):
    p = 1 / math.sqrt(2 * math.pi * sigma**2)
    return p * np.exp(-0.5 / sigma**2 * (x - mu)**2)

这两张图片相互对比就可以理解sigma和mu的含义了。

sigma就代表标准差  mu就代表均值

可视化操作：

# 再次使用numpy进行可视化
x = np.arange(-7, 7, 0.01)

# 均值和标准差对
params = [(0, 1), (0, 2), (3, 1)]
d2l.plot(x, [normal(x, mu, sigma) for mu, sigma in params], xlabel='x',
         ylabel='p(x)', figsize=(4.5, 2.5),
         legend=[f'mean {mu}, std {sigma}' for mu, sigma in params])

用于根据给定的参数列表params生成一个由正态分布函数normal(x, mu, sigma)组成的列表

由图可知：改变均值会产生沿𝑥轴的偏移，增加方差将会分散分布、降低其峰值。

3.2线性回归从零开始实现

生成数据集->读取数据集->初始化模型参数->定义模型->定义损失函数->定义优化算法->训练

生成数据集

def synthetic_data(w, b, num_examples):  #@save
    """生成y=Xw+b+噪声"""
    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 = synthetic_data(true_w, true_b, 1000)

normal是生成正态分布的参数，括号里第一个值为均值，第二个值为标准差，第三个值是输出张量 x 的形状。这里，num_examples 表示样本的数量或批次大小，而 len(w) 表示每个样本的特征数量，w 是一个列表或类似的可迭代对象，其长度表示特征的数量。

生成了一个形状为 (num_examples, len(w)) 的张量 x，其中包含了从标准正态分布（均值为0，标准差为1）中随机抽取的 num_examples 个样本，每个样本包含 len(w) 个特征。

y += torch.normal(0, 0.01, y.shape)这一行是给创建一个和y相同形状的张量作为噪声

features代表特征 labels代表特征

print('features:',features[0],"\nlabel:",labels[0])
d2l.set_figsize()
d2l.plt.scatter(features[:,(1)].detach().numpy(),labels.detach().numpy(),1)

读取数据集

读之前先对数据集进行打乱，然后以自定义的小批量方式获取数据

先定义一个data_iter函数，该函数接收批量大小，

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):
        batch_indices=torch.tensor(indices[i:min(i+batch_size,num_examples)])
        """如果我们有一个包含1000个样本的数据集，并且我们想要以批量大小为32来处理它，那么对于第一个批次（i=0）
        ，indices[0:min(0+32,1000)]将等价于indices[0:32]，表示我们选择了从索引0到索引31的32个样本作为第一个批次的数据。
        对于第二个批次（i=32），我们将选择从索引32到索引63的样本，依此类推，直到处理完整个数据集。"""
        yield features[batch_indices],labels[batch_indices]
        

        在Python中，yield和return在函数中的使用有着本质的区别，尤其是在生成器（generator）函数中。

return语句用于从函数中返回一个值，并结束函数的执行。一旦return语句被执行，函数将不再继续执行其后的代码，并将控制权返回给函数的调用者。
在普通函数中，return可以返回任何类型的值，包括None（如果不显式指定返回值）。
在一个函数中，return语句只能被执行一次（除非在try/except块中，但即使这样，函数也会在第一次遇到return后结束执行）。

yield语句用于从函数中返回一个值，但不同于return，yield不会结束函数的执行。相反，它允许函数在暂停和恢复执行之间“记住”其状态。
当一个函数包含至少一个yield语句时，该函数就变成了一个生成器函数。调用这样的函数不会执行函数体中的代码，而是返回一个生成器对象。
通过对生成器对象进行迭代（如使用for循环或使用next()函数），可以逐个获取yield语句返回的值。每次迭代时，函数将从上次yield语句之后的地方继续执行，直到遇到下一个yield语句或函数结束。
在生成器函数中，yield语句可以被多次执行，以产生多个值。
在批量处理数据中的应用
当你看到yield features[batch_indices], labels[batch_indices]这样的代码时，它通常出现在一个生成器函数中，用于逐个批次地产生数据和标签。这个生成器函数可能接受整个数据集（或数据集的索引）作为输入，并逐个批次地产生数据，而不是一次性将所有数据加载到内存中。

使用yield而不是return的好处是，它允许你以流的方式处理数据，这对于处理大型数据集或需要节省内存的情况非常有用。
此外，使用生成器还可以使代码更加简洁和易于理解，因为你可以直接在一个for循环中迭代

数据批次，而不是编写复杂的循环逻辑来手动管理批次索引和数据加载。

初始化模型参数

开始用小批量随机梯度下降优化我们的模型参数之前， 我们需要先有一些参数

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

后面就是不断调整w和b来使损失最小啦

定义模型

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

b是一个标量，利用广播机制可以加到向量的每个分量里

定义损失函数

def squared_loss(y_hat, y):  #@save
    """均方损失"""
    return (y_hat - y.reshape(y_hat.shape)) ** 2 / 2

 小批量随机梯度下降

回顾一下w和b是怎样更新的，会帮助我们更容易理解代码

def sgd(params, lr, batch_size):  #@save
    """小批量随机梯度下降"""
    with torch.no_grad():
        for param in params:
            param -= lr * param.grad / batch_size
            param.grad.zero_()

params在这里就是【w，b】

学习率就是lr param.grad就是对应的梯度 batch——size就是自己定义的小批量

训练

lr = 0.03
num_epochs = 3
net = linreg
loss = squared_loss

for epoch in range(num_epochs):
    for X, y in data_iter(batch_size, features, labels):
        with autograd.record():
            l = loss(net(X, w, b), y)  # X和y的小批量损失
        # 计算l关于[w,b]的梯度
        l.backward()
        sgd([w, b], lr, batch_size)  # 使用参数的梯度更新参数
    train_l = loss(net(features, w, b), labels)
    print(f'epoch {epoch + 1}, loss {float(train_l.mean()):f}')

3次大循环 每一次都读取数据集返回特征和标签，我们需要根据特征进行线性变化得出标签，与实际标签损失最小，所以我们需要不断更新w和b，调整好后，此时的features进行权重的计算后，得出来的就是预测标签，再与实际标签labels进行均方损失，最后得出来损失多少

3.3线性回归简洁实现

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)

def load_array(data_arrays, batch_size, is_train=True):  #@save
    """构造一个PyTorch数据迭代器"""
    dataset = data.TensorDataset(*data_arrays)
    return data.DataLoader(dataset, batch_size, shuffle=is_train)

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

next(iter(data_iter))

# nn是神经网络的缩写
from torch import nn

net = nn.Sequential(nn.Linear(2, 1))

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_epochs = 3
for 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}')
w = net[0].weight.data
print('w的估计误差：', true_w - w.reshape(true_w.shape))
b = net[0].bias.data
print('b的估计误差：', true_b - b)

我们首先定义一个模型变量net，它是一个Sequential类的实例。 Sequential类将多个层串联在一起。 当给定输入数据时，Sequential实例将数据传入到第一层， 然后将第一层的输出作为第二层的输入，以此类推。

在PyTorch中，全连接层在Linear类中定义。 值得注意的是，我们将两个参数传递到nn.Linear中。 第一个指定输入特征形状，即2，第二个指定输出特征形状，输出特征形状为单个标量，因此为1

1. 初始化SGD优化器：通过torch.optim.SGD创建了一个SGD优化器的实例，命名为trainer。这个优化器将用于更新你的神经网络（在这里用net表示）的参数。

2. 指定优化对象：net.parameters()作为torch.optim.SGD的第一个参数传入，它告诉优化器需要优化的参数是哪些。在PyTorch中，net.parameters()会返回一个包含网络所有可训练参数的迭代器

很好用的，但要理解原理