《动手学深度学习》——线性神经网络

这篇具有很好参考价值的文章主要介绍了《动手学深度学习》——线性神经网络。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

参考资料:

  • 《动手学深度学习》

3.1 线性回归

3.1.1 线性回归的基本元素

样本: n n n 表示样本数, x ( i ) = [ x 1 ( i ) , x 2 ( i ) , ⋯   , x d ( i ) ] x^{(i)}=[x^{(i)}_1,x^{(i)}_2,\cdots,x^{(i)}_d] x(i)=[x1(i),x2(i),,xd(i)] 表示第 i i i 个样本。

预测: y ^ = w T x + b \hat{y}=w^Tx+b y^=wTx+b 表示单个样本的预测值, y ^ = X w + b \hat{y}=Xw+b y^=Xw+b 表示所有样本的预测值。

损失函数:
L ( w , b ) = ∑ i = 1 n 1 2 ( y ^ ( i ) − y ( i ) ) L(w,b)=\sum\limits_{i=1}^{n}\frac12\Big(\hat{y}^{(i)}-y^{(i)}\Big) L(w,b)=i=1n21(y^(i)y(i))

随机梯度下降:在每次迭代中,我们首先随机抽样一个小批量 B \mathcal{B} 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\limits_{i \in \mathcal{B}} \partial_{(\mathbf{w},b)} l^{(i)}(\mathbf{w},b) (w,b)(w,b)BηiB(w,b)l(i)(w,b)
其中, η \eta η 为学习率,是一个超参数。

3.1.2 矢量化加速

尽可能使用效率较高的线性代数库。

3.1.3 正态分布与平方损失

假设观测存在噪声 ϵ \epsilon ϵ
y = w ⊤ x + b + ϵ , y = \mathbf{w}^\top \mathbf{x} + b + \epsilon, y=wx+b+ϵ,
ϵ ∼ N ( 0 , σ 2 ) \epsilon \sim N(0, \sigma^2) ϵN(0,σ2)

此时有条件概率为:
P ( y ∣ x ) = 1 2 π σ 2 exp ⁡ ( − 1 2 σ 2 ( y − w ⊤ x − b ) 2 ) P(y \mid \mathbf{x}) = \frac{1}{\sqrt{2 \pi \sigma^2}} \exp\left(-\frac{1}{2 \sigma^2} (y - \mathbf{w}^\top \mathbf{x} - b)^2\right) P(yx)=2πσ2 1exp(2σ21(ywxb)2)
于是似然函数为:
L ( w , b ) = ∏ i = 1 n p ( y ( i ) ∣ x ( i ) ) L(w,b) = \prod\limits_{i=1}^{n} p(y^{(i)}|\mathbf{x}^{(i)}) L(w,b)=i=1np(y(i)x(i))
取对数再加负号,得:
− l ( w , b ) = ∑ i = 1 n ( 1 2 log ⁡ ( 2 π σ 2 ) + 1 2 σ 2 ( y ( i ) − w ⊤ x ( i ) − b ) 2 ) . -l(w,b) = \sum\limits_{i=1}^n \bigg(\frac{1}{2} \log(2 \pi \sigma^2) + \frac{1}{2 \sigma^2} \left(y^{(i)} - \mathbf{w}^\top \mathbf{x}^{(i)} - b\right)^2\bigg). l(w,b)=i=1n(21log(2πσ2)+2σ21(y(i)wx(i)b)2).
由于 π , σ \pi,\sigma π,σ 均为常数,故由上式可知,对线性模型的最小化均方误差等价于极大似然估计。

3.1.4 从线性回归到深度网络

《动手学深度学习》——线性神经网络,动手学深度学习,深度学习,神经网络,人工智能

3.2 线性回归的从零开始实现

3.2.1 生成数据集

假定我们要生成一个包含 1000 个样本的数据集,每个样本包含从标准正态分布中采样的 2 个特征,样本的标签为:
y = X w + b + ϵ \mathbf{y}= \mathbf{X} \mathbf{w} + b + \mathbf\epsilon y=Xw+b+ϵ
其中, w = [ 2 , − 3.4 ] ⊤ \mathbf{w} = [2, -3.4]^\top w=[2,3.4] b = 4.2 b = 4.2 b=4.2 ϵ \epsilon ϵ 服从均值为 0 ,标准差为 0.01 的正态分布。

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)
    # 如果没有y.reshape,那么y将只有一个维度
    return X, y.reshape((-1, 1))

3.2.2 读取数据集

由于随机梯度下降法要求我们每次从样本中随机抽取一部分样本,所以我们可以定义 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)])
        # 每次参数更新只用到一小部分样本
        yield features[batch_indices], labels[batch_indices]

上面的代码仅用于理解抽取样本的过程,实际实现时可以使用内置的迭代器。

3.2.3 初始化参数

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

3.2.4 定义模型

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

3.2.5 定义损失函数

def squared_loss(y_hat, y):
    """均方损失"""
    # 这里的y.reshape其实是没有必要的,因为labels在前面已经reshape过了
    return (y_hat - y.reshape(y_hat.shape)) ** 2 / 2

3.2.6 定义优化算法

def sgd(params, lr, batch_size):
    """小批量随机梯度下降"""
    # 表示下一个代码块不需要进行梯度计算
    with torch.no_grad():
        for param in params:
            param -= lr * param.grad / batch_size
            # 清空梯度
            param.grad.zero_()

3.2.7 训练

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):
        l = loss(net(X, w, b), y)  # X和y的小批量损失
        # 因为l形状是(batch_size,1),而不是一个标量。l中的所有元素被加到一起,
        # 并以此计算关于[w,b]的梯度
        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}')

3.3 线性回归的简洁实现

3.3.1 生成数据

这部分和 3.2.1 相同。

3.3.2 读取数据集

from torch.utils import data

我们可以直接使用 data 中的 API 来进行样本抽样:

def load_array(data_arrays, batch_size, is_train=True):
    """构造一个PyTorch数据迭代器"""
    # TensorDataset相当于把所有tensor打包,传入的tensor的第0维必须相同
    # *的作用是“解压”参数列表
    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)
# 访问数据
for input,label in data_iter:
    print(input,label)

3.3.3 定义模型

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

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

上面的代码中,Sequential 可以将多个层串联在一起;Linear 实现了全连接层,其参数 2,1 指定了输入的形状和输出的形状。

3.3.4 初始化模型参数

# net[0]表示选中网络中的第0层
net[0].weight.data.normal_(0, 0.01)
net[0].bias.data.fill_(0)

3.3.5 定义损失函数

# 返回所有样本损失的均值
loss = nn.MSELoss()

3.3.6 定义优化算法

# SGD的输入为参数和超参数
trainer = torch.optim.SGD(net.parameters(), lr=0.03)

3.3.7 训练

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}')

3.4 softmax回归

3.4.1 分类问题

一般将不同的类别用独热编码表示。

3.4.2 网络架构

假设每个样本有 4 个特征和 3 种可能的类别,则 softmax 回归的网络结构如下图所示:

《动手学深度学习》——线性神经网络,动手学深度学习,深度学习,神经网络,人工智能

3.4.3 全连接层的参数开销

一般而言全连接层有 d d d 个输入和 q q q 个输出,则其参数开销为 O ( d p ) O(dp) O(dp)

3.4.4 softmax运算

对于分类问题,我们想得到的是输入属于每一种类别的概率,所以我们要对输出进行一定的处理,使之满足概率基本公理:
y ^ = s o f t m a x ( o ) 其中 y ^ j = exp ⁡ ( o j ) ∑ k exp ⁡ ( o k ) \hat{\mathbf{y}} = \mathrm{softmax}(\mathbf{o})\quad \text{其中}\quad \hat{y}_j = \frac{\exp(o_j)}{\sum\limits_k \exp(o_k)} y^=softmax(o)其中y^j=kexp(ok)exp(oj)
显然, y ^ \hat{\mathbf{y}} y^ 的每个分量恒正且和为 1 1 1 ,且 softmax 不会改变 o \mathbf{o} o 之间的大小顺序。

3.4.5 小批量样本的矢量化

KaTeX parse error: Expected 'EOF', got '&' at position 13: \mathbf{O} &̲= \mathbf{X} \m…

3.4.6 损失函数

softmax 回归的似然函数为:
L ( θ ) = ∏ i = 1 n P ( y ( i ) ∣ x ( i ) ) L(\theta)=\prod\limits_{i=1}^n P(\mathbf{y}^{(i)} \mid \mathbf{x}^{(i)}) L(θ)=i=1nP(y(i)x(i))
取负对数,得:
− log ⁡ L ( θ ) = ∑ i = 1 n − log ⁡ P ( y ( i ) ∣ x ( i ) ) = ∑ i = 1 n ∑ j = 1 q − y j log ⁡ y ^ j \begin{align} -\log L(\theta)&=\sum\limits_{i=1}^n -\log P(\mathbf{y}^{(i)} \mid \mathbf{x}^{(i)})\notag\\ &=\sum\limits_{i=1}^n\sum\limits_{j=1}^q-y_j\log \hat{y}_j \end{align} logL(θ)=i=1nlogP(y(i)x(i))=i=1nj=1qyjlogy^j

解释以下上面的式子:因为样本的标签是一个长度为 q q q 的独热编码,所以里面的求和实际上就是求由输入推出其标签的条件的概率的负对数,这与 − log ⁡ P ( y ( i ) ∣ x ( i ) ) -\log P(\mathbf{y}^{(i)} \mid \mathbf{x}^{(i)}) logP(y(i)x(i)) 是等价的。

称:
l ( y , y ^ ) = ∑ j = 1 q − y j log ⁡ y ^ j l(\mathbf{y}, \hat{\mathbf{y}})=\sum\limits_{j=1}^q-y_j\log \hat{y}_j l(y,y^)=j=1qyjlogy^j
交叉熵损失(cross-entropy loss)。
l ( y , y ^ ) = − ∑ j = 1 q y j log ⁡ exp ⁡ ( o j ) ∑ k = 1 q exp ⁡ ( o k ) = ∑ j = 1 q y j log ⁡ ∑ k = 1 q exp ⁡ ( o k ) − ∑ j = 1 q y j o j = log ⁡ ∑ k = 1 q exp ⁡ ( o k ) − ∑ j = 1 q y j o j ∂ o j l ( y , y ^ ) = exp ⁡ ( o j ) ∑ k = 1 q exp ⁡ ( o k ) − y j = s o f t m a x ( o ) j − y j \begin{aligned} l(\mathbf{y}, \hat{\mathbf{y}}) &= - \sum_{j=1}^q y_j \log \frac{\exp(o_j)}{\sum_{k=1}^q \exp(o_k)}\notag \\ &= \sum_{j=1}^q y_j \log \sum_{k=1}^q \exp(o_k) - \sum_{j=1}^q y_j o_j\notag\\ &= \log \sum_{k=1}^q \exp(o_k) - \sum_{j=1}^q y_j o_j\notag\\ \partial_{o_j} l(\mathbf{y}, \hat{\mathbf{y}}) &= \frac{\exp(o_j)}{\sum_{k=1}^q \exp(o_k)} - y_j = \mathrm{softmax}(\mathbf{o})_j - y_j\notag \end{aligned} l(y,y^)ojl(y,y^)=j=1qyjlogk=1qexp(ok)exp(oj)=j=1qyjlogk=1qexp(ok)j=1qyjoj=logk=1qexp(ok)j=1qyjoj=k=1qexp(ok)exp(oj)yj=softmax(o)jyj
可以看出,梯度是观测值 y y y 和估计值 y ^ \hat{y} y^ 之间的差异,这使梯度计算在实践中变得容易很多。

3.5 图像分类数据集

3.5.2 读取小批量数据

batch_size = 256

def get_dataloader_workers():
    """使用4个进程来读取数据"""
    return 4

train_iter = data.DataLoader(mnist_train, batch_size, shuffle=True,
                             num_workers=get_dataloader_workers())

3.6 softmax回归的从零开始实现

3.6.1 初始化模型参数

输入是 28*28 的图像,可以看作长度为 784 的向量;输出为属于 10 个可能的类别的概率,故 W W W 应为 784*10 的矩阵, b b b 为 1*10 的行向量:

num_inputs = 784
num_outputs = 10

W = torch.normal(0, 0.01, size=(num_inputs, num_outputs), requires_grad=True)
b = torch.zeros(num_outputs, requires_grad=True)

3.6.2 定义softmax操作

实现softmax由三个步骤组成:

  1. 对每个项求幂;
  2. 对每一行求和(小批量中每个样本是一行),得到每个样本的规范化常数;
  3. 将每一行除以其规范化常数,确保结果的和为1。

对应的代码为:

def softmax(X):
    X_exp = torch.exp(X)
    # 确保求和之后张量的维度不变
    partition = X_exp.sum(1, keepdim=True)
    return X_exp / partition  # 这里应用了广播机制

3.6.3 定义模型

def net(X):
    return softmax(torch.matmul(X.reshape((-1, W.shape[0])), W) + b)

这里的输入为什么只是一张图像呢?

3.6.4 定义损失函数

def cross_entropy(y_hat, y):
    return - torch.log(y_hat[range(len(y_hat)), y])

cross_entropy(y_hat, y)

其中,y 为标签列表,代表样例的类别编号,如 [0,1,3]

3.6.5 分类精度

精度(accuracy)= 正确预测数量 / 总预测数量

def accuracy(y_hat, y):
    """计算预测正确的数量"""
    if len(y_hat.shape) > 1 and y_hat.shape[1] > 1:
        y_hat = y_hat.argmax(axis=1)
    cmp = y_hat.type(y.dtype) == y
    return float(cmp.type(y.dtype).sum())

上面的代码表示:如果 y_hat 是矩阵,那么假定第二个维度存储每个类的预测分数。 我们使用 argmax 获得每行中最大元素的索引来获得预测类别。 然后我们将预测类别与真实 y 元素进行比较。 由于等式运算符 “==” 对数据类型很敏感, 因此我们将 y_hat 的数据类型转换为与 y 的数据类型一致。 结果是一个包含0(错)和1(对)的张量。 最后,我们求和会得到正确预测的数量。

3.7 softmax回归的简洁实现

3.7.1 初始化模型参数

# PyTorch不会隐式地调整输入的形状。因此,
# 我们在线性层前定义了展平层(flatten),来调整网络输入的形状
net = nn.Sequential(nn.Flatten(), nn.Linear(784, 10))

def init_weights(m):
    if type(m) == nn.Linear:
        nn.init.normal_(m.weight, std=0.01)

# apply会对net里的每一层执行init_weights函数
# 所以init_weights函数里的m是用来限定只初始化Linear层参数的
net.apply(init_weights);

3.7.2 定义损失函数

CorssEntropyLoss 的输入为 o \mathbf{o} o (未经过 softmax)和标签列表,输出为交叉熵。也就是说,我们在计算损失的时候不需要将输出通过 softmax 转化为概率,这是因为 softmax 中的指数运算非常容易溢出。

# none表示不合并结果,即loss为一个列表,元素为每个样本的交叉熵
# 这里之所以选择none,是因为后面既要用到损失的总和,又要用到损失的均值
loss = nn.CrossEntropyLoss(reduction='none')

3.7.3 优化算法

trainer = torch.optim.SGD(net.parameters(), lr=0.1)

3.7.4 训练

# 累加器类
class Accumulator:
    """在n个变量上累加"""
    def __init__(self, n):
        self.data = [0.0] * n
	
    # 将参数列表逐个加到累加器里
    def add(self, *args):
        self.data = [a + float(b) for a, b in zip(self.data, args)]

    def reset(self):
        self.data = [0.0] * len(self.data)

    def __getitem__(self, idx):
        return self.data[idx]
def train_epoch_ch3(net, train_iter, loss, updater):
    """训练模型一个迭代周期(定义见第3章)"""
    # 将模型设置为训练模式
    if isinstance(net, torch.nn.Module):
        net.train()
    # 训练损失总和、训练准确度总和、样本数
    metric = Accumulator(3)
    for X, y in train_iter:
        # 计算梯度并更新参数
        y_hat = net(X)
        l = loss(y_hat, y)
        if isinstance(updater, torch.optim.Optimizer):
            # 使用PyTorch内置的优化器和损失函数
            updater.zero_grad()
            l.mean().backward()
            updater.step()
        metric.add(float(l.sum()), accuracy(y_hat, y), y.numel())
    # 返回训练损失和训练精度
    return metric[0] / metric[2], metric[1] / metric[2]
def evaluate_accuracy(net, data_iter):  #@save
    """计算在指定数据集上模型的精度"""
    if isinstance(net, torch.nn.Module):
        net.eval()  # 将模型设置为评估模式
    metric = Accumulator(2)  # 正确预测数、预测总数
    with torch.no_grad():
        for X, y in data_iter:
            # 这里的accuracy出自3.6.5
            metric.add(accuracy(net(X), y), y.numel())
    return metric[0] / metric[1]
def train_ch3(net, train_iter, test_iter, loss, num_epochs, updater):
    """训练模型(定义见第3章)"""
    animator = Animator(xlabel='epoch', xlim=[1, num_epochs], ylim=[0.3, 0.9],
                        legend=['train loss', 'train acc', 'test acc'])
    for epoch in range(num_epochs):
        # 训练一轮
        train_metrics = train_epoch_ch3(net, train_iter, loss, updater)
        # 在测试集上测试精度
        test_acc = evaluate_accuracy(net, test_iter)
        animator.add(epoch + 1, train_metrics + (test_acc,))
    train_loss, train_acc = train_metrics
    # 这条代码的意思是:如果train_loss<0.5则继续执行,否则报错,报错内容为"train_loss"
    assert train_loss < 0.5, train_loss
    assert train_acc <= 1 and train_acc > 0.7, train_acc
    assert test_acc <= 1 and test_acc > 0.7, test_acc
num_epochs = 10
d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, trainer)

3.7.5 预测

使用 y_hat.argmax(axis=1) 即可。文章来源地址https://www.toymoban.com/news/detail-522498.html

到了这里,关于《动手学深度学习》——线性神经网络的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【动手学深度学习】现代卷积神经网络汇总

    本文为作者阅读学习李沐老师《动手学深度学习》一书的阶段性读书总结,原书地址为:Dive into Deep Learning。 网络结构 实现代码 网络特征 最早发布的卷积神经网络之一。 每个卷积块中的基本单元是一个卷积层、一个sigmoid激活函数和平均汇聚层。 网络结构 实现代码 网络特

    2024年02月07日
    浏览(50)
  • 自己动手实现一个深度学习算法——三、神经网络的学习

    这里所说的“学习”是指从训练数据中自动获取最优权重参数的过程 。为了使神经网络能进行学习,将导入 损失函数 这一指标。而学习的目的就是以该损失函数为基准,找出能使它的值达到最小的权重参数。为了找出尽可能小的损失函数的值,利用了 函数斜率的梯度法 。

    2024年02月05日
    浏览(52)
  • 动手学深度学习—卷积神经网络(原理解释+代码详解)

    多层感知机对图像处理是百万维度,模型不可实现。 如果要在图片中找到某个物体,寻找方法应该和物体位置无关。 适合 计算机视觉 的神经网络架构: 平移不变性 :不管检测对象出现在图像中的哪个位置,神经网络前几层应该对相同图像区域有相似的反应。 局部性 :神

    2024年02月14日
    浏览(55)
  • 《动手学深度学习》学习笔记 第9章 现代循环神经网络

    书籍链接: 动手学深度学习 笔记是从第四章开始,前面三章为基础知识,有需要的可以自己去看看 关于本系列笔记: 书里为了让读者更好的理解,有大篇幅的描述性的文字,内容很多,笔记只保留主要内容,同时也是对之前知识的查漏补缺 《动手学深度学习》学习笔记 第

    2024年01月18日
    浏览(54)
  • 《动手学深度学习 Pytorch版》 9.4 双向循环神经网络

    之前的序列学习中假设的目标是在给定观测的情况下对下一个输出进行建模,然而也存在需要后文预测前文的情况。 数学推导太复杂了,略。 双向循环神经网络(bidirectional RNNs)添加了反向传递信息的隐藏层,以便更灵活地处理此类信息。 前向和反向隐状态的更新如下:

    2024年02月07日
    浏览(46)
  • 深度学习——第7章 项目实战:自己动手写一个神经网络模型

    7.1 导入数据集 7.2 定义神经网络输入层、隐藏层、输出层神经元个数 7.3 网络参数W和b初始化 7.4 正向传播过程 7.5 损失函数 7.6 反向传播过程 7.7 网络参数更新 7.8 搭建整个神经网络模型 7.9 模型训练 7.10 模型预测 7.11 隐藏层神经元个数对分类效果的影响 上一课主要介绍了最简

    2024年01月16日
    浏览(43)
  • 【AI】《动手学-深度学习-PyTorch版》笔记(十七):卷积神经网络入门

    我们在前面学习的多层感知机中,已经认识了全链接层,缺点很明显,在稍微大点的网络模型中,参数成指数级别增长。参数量很快就达到数十亿,这样的量级几乎无法计算。为此科学家们想出一个减少参数的方法:卷积。 从全链接层到卷积的推论,使用如下两个原则: 平

    2024年02月13日
    浏览(61)
  • 十 动手学深度学习v2 ——卷积神经网络之NiN + GoogLeNet

    NiN块使用卷积层加两个1x1卷积层 后者对每个像素增加了非线性性 NiN使用全局平均池化层来替代VGG和AlexNet中的全连接层 不容易过拟合,更少的参数个数 Inception块由四条并行路径组成。 前三条路径使用窗口大小为1x1、3x3和5x5的卷积层,从不同空间大小中提取信息。 中间的两条

    2024年02月09日
    浏览(65)
  • 【AI】《动手学-深度学习-PyTorch版》笔记(十八):卷积神经网络模型

    发布时间:1989年 模型目的:识别手写数字 1.3.1 相关函数原型 1)nn.Conv2d:卷积层

    2024年02月13日
    浏览(79)
  • 16 PyTorch 神经网络基础【李沐动手学深度学习v2】

    在构造自定义块之前,我们先回顾一下多层感知机的代码。 下面的代码生成一个网络,其中包含一个具有256个单元和ReLU激活函数的全连接隐藏层, 然后是一个具有10个隐藏单元且不带激活函数的全连接输出层。 层和块 构造单层神经网咯:线性层+RELU+线性层 生成2x20(2是批量

    2024年03月10日
    浏览(89)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包