Pytorch神经网络基础

已于 2023-02-01 20:41:09 修改
阅读量646 收藏 9
点赞数 1
文章标签： pytorch 神经网络 深度学习
于 2023-02-01 20:39:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Vteran/article/details/128824778
版权

学习了李沐——《动手学深度学习》的视频课程，在此对知识点进行整理以及记录动手实践中遇到的一些问题和想法。

一.神经网络的搭建

        首先，我们导入可能用到的包

import torch
from torch import nn
from torch.nn import functional as F

 1.自定义块

        我们可以通过自定义块进行神经网络的初步搭建，这个块中包含一个多层感知机。这个感知机具有256个隐藏单元的隐藏层和一个10维的输出层。在构造搭建神经网络时，每一个class都需要继承torch,nn.Module类，并重写父类的初始化函数__init__()和前向传播函数forward()。        

class MLP(nn.Module):
    # 用模型参数声明层。这里，我们声明两个全连接的层
    def __init__(self):
        # 调用MLP的父类Module的构造函数来执行必要的初始化。
        # 这样，在类实例化时也可以指定其他函数参数，例如模型参数params（稍后将介绍）
        super().__init__()
        self.hidden = nn.Linear(20, 256)  # 隐藏层
        self.out = nn.Linear(256, 10)  # 输出层

    # 定义模型的前向传播，即如何根据输入X返回所需的模型输出
    def forward(self, X):
        # 注意，这里我们使用ReLU的函数版本，其在nn.functional模块中定义。
        return self.out(F.relu(self.hidden(X)))

        我们在初始化函数中，定义神经网络的每一层，可以看到，我们在此声明了两个全连接层。在前向传播函数中，它以x作为输入，经过hidden层，再使用激活函数进行输出，之后再次进入out层，作为最后的输出。

        上述代码是《动手学深度学习》书中的示例代码。笔者自己的代码如下：

class Mlp(nn.Module):
    
    def __init__(self):
        super().__init__()
        self.hidden = nn.Linear(20, 256)
        self.out = nn.Linear(256, 10)
        
    def forward(self, X):
        X = self.hidden(X)
        X = F.relu(X)
        X = self.out(X)
        
        return X

        这段代码与书中区别不大，只不过是将relu函数写在了__init__()中。

        接下来，我们使用以下这个方法。

net = Mlp()

X = torch.rand(2, 20)
y_hat = net(X)

        我们随机生成了一个2x20的矩阵X作为输入，y_hat为输出，我们得到的结果如下。

tensor([[ 0.1855, -0.0653, -0.0294,  0.0289, -0.3788, -0.3535,  0.0319,  0.2367,
          0.0234,  0.1758],
        [ 0.1773, -0.1185,  0.1917,  0.1266, -0.3549, -0.3114,  0.0384,  0.2747,
         -0.0602,  0.2141]], grad_fn=<AddmmBackward0>)

         块的一个主要优点是它的多功能性。 我们可以子类化块以创建层（如全连接层的类）、 整个模型（如上面的MLP类）或具有中等复杂度的各种组件。 我们在接下来的章节中充分利用了这种多功能性， 比如在处理卷积神经网络时。

2.顺序块

        书中对于顺序块的讲述，使用到了自定义简化的块MySequential，可能工作原理与nn.Sequential类是一样的。

class MySequential(nn.Module):
    def __init__(self, *args):
        super().__init__()
        for idx, module in enumerate(args):
            # 这里，module是Module子类的一个实例。我们把它保存在'Module'类的成员
            # 变量_modules中。_module的类型是OrderedDict
            self._modules[str(idx)] = module

    def forward(self, X):
        # OrderedDict保证了按照成员添加的顺序遍历它们
        for block in self._modules.values():
            X = block(X)
        return X

        在笔者自己重写这个类的时候，误将self._modules写成了self.modules_，后来程序报错，经过查询后才知道，_modules是nn.Module中固有的一个属性，通过Pycharm打开nn.Moudle中可以看到这个属性的声明。

         在_modules这个属性中，保存了这个神经网络每一层的定义，我们可以将这个属性print一下看看。

net = MySequential(nn.Linear(20, 256), nn.ReLU(), nn.Linear(256, 10))
print("#############################")
print(net._modules)
print("#############################")
print(net(X))

        我们往自定义的顺序块中定义了一个多层感知机，输出的结果如下。

#############################
OrderedDict([('0', Linear(in_features=20, out_features=256, bias=True)), ('1', ReLU()), ('2', Linear(in_features=256, out_features=10, bias=True))])
#############################
tensor([[ 0.0451,  0.0506,  0.0708,  0.1691, -0.0690,  0.2757,  0.1234,  0.0643,
          0.2320,  0.1050],
        [ 0.0815, -0.0634,  0.1051,  0.1634, -0.0173,  0.3460,  0.0656,  0.1276,
          0.2268,  0.1578]], grad_fn=<AddmmBackward0>)

        可以看到，_modules属性中，存储了我们声明的每一层。

二.在前向传播函数中执行代码

        前向传播函数就是class类中写到的forward()函数。当我们需要更强的灵活性，或者需要在神经网络中进行某种自定义的数学运算，就可以用到这个函数。

        例如，在上述例子中的多层感知机，我们想额外增加两个操作：

  • 自己编写Relu函数，即  XW + b。
  • 使得最后输出的L1范数小于1
class FixedHiddenMLP(nn.Module):
    def __init__(self):
        super().__init__()
        # 不计算梯度的随机权重参数。因此其在训练期间保持不变
        self.rand_weight = torch.rand((20, 20), requires_grad=False)
        self.linear = nn.Linear(20, 20)
        
    def forward(self, X):
        X = self.linear(X)
        
        X = F.relu(X @ self.rand_weight + 10)
        # 为了保证后面L1范数的约束效果，我们把bias设置大一些
        X = self.linear(X)
        
        while X.abs().sum() > 1:
            X /= 2
            
        return X.sum()

X = torch.rand(2, 20)
net = FixedHiddenMLP()
y_hat = net(X)
print(y_hat)

        我们来看一下最后的输出。

tensor(0.1166, grad_fn=<SumBackward0>)

三.神经网络中的参数获取与初始化

        我们首先看一下单隐藏层的多层感知机

import torch
from torch import nn

net = nn.Sequential(nn.Linear(4, 8), nn.ReLU(), nn.Linear(8, 1))
X = torch.rand(size=(2, 4))
net(X)
tensor([[-0.4626],
        [-0.5465]], grad_fn=<AddmmBackward0>)

1.参数访问

        当我们用Sequential()类定义模型的时候，我们可以通过索引来访为模型的任意层。这就像模型是一个列表一样，每层的参数都在其属性中。 如下所示，我们可以检查第二个全连接层的参数。

print(net[2].state_dict())
OrderedDict([('weight', tensor([[-0.1514, -0.2675, -0.3112, -0.1464,  0.0989,  0.3014,  0.1620, -0.1384]])), ('bias', tensor([-0.3249]))])

        这个输出表示，在第三层，也就是神经网络的第二个全连接层中，包含两个参数，第一个是权重weight 和偏置bias，二者都已单精度浮点数float32的方式储存。

        可以看到，上一行代码中，我们使用到了state_dict()的方法，我们来看一下这个方法的官方解释。

    def state_dict(self, *args, destination=None, prefix='', keep_vars=False):
        r"""Returns a dictionary containing references to the whole state of the module.

        Both parameters and persistent buffers (e.g. running averages) are
        included. Keys are corresponding parameter and buffer names.
        Parameters and buffers set to ``None`` are not included.

        方法定义中表示，该方法可以返回包含对模块整个状态的引用的字典。既然是个字典，我们就可以通过字典索引的方法获取值。当我们执行了net[2].state_dict()这一行代码时，可以看到整个字典中，有两个键，分别是weight和bias，下面，我们就可以直接通过键值对索引的方法获取参数了。注意不要忘记引号。

print(net[2].state_dict()['weight'])
print(net[2].state_dict()['bias'])
tensor([[-0.0272, -0.0133, -0.3240,  0.3132, -0.1283,  0.2246,  0.1192, -0.2657]])
tensor([-0.0799])

        起初照着教材敲代码的时候，笔者有个疑惑，这个data属性是怎么来的，看到返回的属性是一个tensor数据类型，于是打开了torch.tensor()的文档，发现data是该方法的属性。

def tensor(data: Any, dtype: Optional[_dtype]=None, device: Device=None, requires_grad: _bool=False) -> Tensor: ...

         上文中，我们只获取了神经网络其中一层的参数，接下来我们可以尝试着获取神经网络中每一层的参数，我们直接暴力一点。

print(net.state_dict())
OrderedDict(
[('0.weight', tensor([[-0.3578, -0.0779, -0.4654,  0.2061],
        [-0.2745,  0.2116,  0.0571,  0.0851],
        [-0.0334,  0.3411, -0.3570,  0.0618],
        [ 0.1501,  0.1214, -0.0715,  0.1124],
        [ 0.2564, -0.4512,  0.3402, -0.4430],
        [ 0.3695,  0.2382, -0.2993, -0.1740],
        [-0.1359, -0.0580, -0.0948, -0.4430],
        [ 0.0654, -0.2478, -0.4690, -0.1755]])), 
('0.bias', tensor([ 0.1552, -0.3691, -0.3870,  0.3516,  0.2946, -0.1366, -0.4313,  0.2209])), 
('2.weight', tensor([[-0.0272, -0.0133, -0.3240,  0.3132, -0.1283,  0.2246,  0.1192, -0.2657]])), 
('2.bias', tensor([-0.0799]))])

        这里可以看到，整个字典中一共有4对键值对，由此可以分析出，键的命名方式就是“层数.参数名称”。也就说，我们获取到了第1层和第3层的两个参数，而没有获取第二层的参数，因为在这个网络中，第二层是一个ReLU()，该方法并没有参数的设置，只是起到激活作用。因此，我们就获得了另一种访问网络参数的方式。

print(net.state_dict()['0.weight'].data)
print(net.state_dict()['0.bias'].data)
print(net.state_dict()['2.weight'].data)
print(net.state_dict()['2.bias'].data)
tensor([[-0.3578, -0.0779, -0.4654,  0.2061],
        [-0.2745,  0.2116,  0.0571,  0.0851],
        [-0.0334,  0.3411, -0.3570,  0.0618],
        [ 0.1501,  0.1214, -0.0715,  0.1124],
        [ 0.2564, -0.4512,  0.3402, -0.4430],
        [ 0.3695,  0.2382, -0.2993, -0.1740],
        [-0.1359, -0.0580, -0.0948, -0.4430],
        [ 0.0654, -0.2478, -0.4690, -0.1755]])
tensor([ 0.1552, -0.3691, -0.3870,  0.3516,  0.2946, -0.1366, -0.4313,  0.2209])
tensor([[-0.0272, -0.0133, -0.3240,  0.3132, -0.1283,  0.2246,  0.1192, -0.2657]])
tensor([-0.0799])

        上文中，我们提到，当我们使用nn.Sequential()方法创建一个神经网络的时候，我们可以直接使用层数的下标索引值获取参数。方法如下。

print(net[0].weight.data)
print(net[0].bias.data)
print(net[2].weight.data)
print(net[2].bias.data)

2.从嵌套块中访问参数

        让我们看看，如果我们将多个块相互嵌套，参数命名约定是如何工作的。 我们首先定义一个生成块的函数（可以说是“块工厂”），然后将这些块组合到更大的块中。

def block1():
    return nn.Sequential(nn.Linear(4, 8), nn.ReLU(),
                         nn.Linear(8, 4), nn.ReLU())

def block2():
    net = nn.Sequential()
    for i in range(4):
        # 在这里嵌套
        net.add_module(f'block {i}', block1())
    return net

rgnet = nn.Sequential(block2(), nn.Linear(4, 1))
y_hat = rgnet(X)
print(y_hat)
print(rgnet)

tensor([[-0.3078],
        [-0.3078]], grad_fn=<AddmmBackward0>)

Sequential(
  (0): Sequential(
    (block 0): Sequential(
      (0): Linear(in_features=4, out_features=8, bias=True)
      (1): ReLU()
      (2): Linear(in_features=8, out_features=4, bias=True)
      (3): ReLU()
    )
    (block 1): Sequential(
      (0): Linear(in_features=4, out_features=8, bias=True)
      (1): ReLU()
      (2): Linear(in_features=8, out_features=4, bias=True)
      (3): ReLU()
    )
    (block 2): Sequential(
      (0): Linear(in_features=4, out_features=8, bias=True)
      (1): ReLU()
      (2): Linear(in_features=8, out_features=4, bias=True)
      (3): ReLU()
    )
    (block 3): Sequential(
      (0): Linear(in_features=4, out_features=8, bias=True)
      (1): ReLU()
      (2): Linear(in_features=8, out_features=4, bias=True)
      (3): ReLU()
    )
  )
  (1): Linear(in_features=4, out_features=1, bias=True)
)

        因为层是分层嵌套的，所以我们也可以像通过嵌套列表索引一样访问它们。 下面，我们访问第一个主要的块中、第二个子块的第一层的偏置项，以及最后一个全连接层的偏置项。

print(rgnet[0][1][0].bias.data)
print(rgnet[1].bias.data)
tensor([-0.4040,  0.1900, -0.0780,  0.1957, -0.2150,  0.0059, -0.4671, -0.2036])
tensor([0.4097])

3.参数初始化

        在神经网络中，参数初始化是十分有必要的。参数初始化也是建立一个神经网络的必要工作。

（1）.内置初始化

        Pytorch在torch.nn模块中，已经写好了若干内置的初始化器，我们可以直接调用这些初始化器实现参数的初始化。具体的初始化器读者可以通过查看官方的定义。

        下面的代码，我们将所有权重参数初始化为标准差为0.01的正态随机变量，将所有的偏置参数设置成0。

        

def init_normal(m):
    if type(m) == nn.Linear:
        nn.init.normal_(m.weight, mean=0, std=0.01)
        nn.init.zeros_(m.bias)
net.apply(init_normal)
print(net[0].weight.data[0])
print(net[0].bias.data[0])

(tensor([-0.0128, -0.0141,  0.0062,  0.0028])
(tensor(0.))

        我们还可以将所有参数属初始化为常数。

def init_constant(m):
    if type(m) == nn.Linear:
        nn.init.constant_(m.weight, 1)
        nn.init.zeros_(m.bias)
net.apply(init_constant)
print(net[0].weight.data[0])
print(net[0].bias.data[0])

(tensor([1., 1., 1., 1.])
(tensor(0.))

        我们还可以对某些不同的层设置不同的初始化方法。例如，下面我们使用Xavier初始化方法初始化第一个神经网络层， 然后将第三个神经网络层初始化为常量值42。

def init_xavier(m):
    if type(m) == nn.Linear:
        nn.init.xavier_uniform_(m.weight)
def init_42(m):
    if type(m) == nn.Linear: 
        nn.init.constant_(m.weight, 42)

net[0].apply(init_xavier)
net[2].apply(init_42)
print(net[0].weight.data[0])
print(net[2].weight.data)
tensor([ 0.3809,  0.5354, -0.4686, -0.2376])
tensor([[42., 42., 42., 42., 42., 42., 42., 42.]])

（2）.自定义初始化

        有时候，Pytorch框架并没有给出我们想要的初始化，我们也可以根据自己的需求进行设置。比如，我们使用以下的分布来初始化权重参数。

def my_init(m):
    if type(m) == nn.Linear:
        print("Init", *[(name, param.shape)
                        for name, param in m.named_parameters()][0])
        nn.init.uniform_(m.weight, -10, 10)
        m.weight.data *= m.weight.data.abs() >= 5

net.apply(my_init)
print(net[0].weight[:2])
Init weight torch.Size([8, 4])
Init weight torch.Size([1, 8])
tensor([[-0.0000, 0.0000, -0.0000, 0.0000],
        [-0.0000, 9.3464, 5.5061, 6.8197]], grad_fn=<SliceBackward0>)

 (3）.参数绑定

        书中在本章的最后还提到了一个参数绑定的概念，其目的是在多层之间共享参数。

        我们定义一个全连接层，然后使用它的参数来设置另一个层的参数。

# 我们需要给共享层一个名称，以便可以引用它的参数
shared = nn.Linear(8, 8)
net = nn.Sequential(nn.Linear(4, 8), nn.ReLU(),
                    shared, nn.ReLU(),
                    shared, nn.ReLU(),
                    nn.Linear(8, 1))
net(X)
# 检查参数是否相同
print(net[2].weight.data[0] == net[4].weight.data[0])
net[2].weight.data[0, 0] = 100
# 确保它们实际上是同一个对象，而不只是有相同的值
print(net[2].weight.data[0] == net[4].weight.data[0])
tensor([True, True, True, True, True, True, True, True])
tensor([True, True, True, True, True, True, True, True])

四.突发奇想

        学习完之后，笔者突发奇想，想尝试一下利用一个神经网络实现矩阵的运算操作，具体想法如下。

       

          实现代码如下：

def init_paras_shared(m):
    torch.nn.init.constant_(m.weight, 2)
    torch.nn.init.zeros_(m.bias)

def init_paras_Linear(m):
    torch.nn.init.constant_(m.weight, 4)
    torch.nn.init.constant_(m.bias, 1)

shared = nn.Linear(5, 5)

net = nn.Sequential(
    shared, 
    shared, 
    nn.Linear(5, 1)
)


shared.apply(init_paras_shared)
net[2].apply(init_paras_Linear)

X = torch.arange(1, 6, dtype=torch.float32)
y_hat = net(X)
print(y_hat)

tensor([6001.], grad_fn=<AddBackward0>)

        头次写稿，若有不足，还请各路大牛批评指出。 

深度不学习。
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
卷积神经网络基础 pytorch
02-17
卷积神经网络基础 本节我们介绍卷积神经网络的基础概念，主要是卷积层和池化层，并解释填充、步幅、输入通道和输出通道的含义。
pytorch自带网络_一篇长文学懂 pytorch
weixin_39619270的博客
11-20 332
作为目前越来越受欢迎的深度学习框架，pytorch 基本上成了新人进入深度学习领域最常用的框架。相比于 TensorFlow，pytorch 更易学，更快上手，也可以更容易的实现自己想要的 demo。今天的文章就从 pytorch 的基础开始，帮助大家实现成功入门。首先，本篇文章需要大家对深度学习的理论知识有一定的了解，知道基本的 CNN，RNN 等概念，知道前向传播和反向传播等流程，毕竟本文重点...
完整的模型测试(deom）步骤
m0_51816252的博客
06-07 2487
本文主要讲解了完整的模型验证，测试（deom）的具体步骤。简单来讲就是利用已经训练好的模型，给它提供输入，查看这输入经过模型后输出的结果。
PyTorch 神经网络基础
qq_41799291的博客
06-15 125
1.https://morvanzhou.github.io/tutorials/machine-learning/torch/
PyTorch中关于backward、grad、autograd的计算原理的深度剖析
Yale-曼陀罗
06-19 1万+
PyTorch中关于backward、grad、autograd的计算原理的深度剖析PyTorch中Tensor的详细说明 PyTorch中Tensor的详细说明 PyTorch中所有的计算其实都可以回归到Tensor上，所以有必要重新认识一下Tensor。如果我们需要计算某个Tensor的导数，那么我们需要设置其.requires_grad属性为True。 在PyTorch我们自己定义的变量，我们称之为叶子节点(leaf nodes)，而基于叶子节点得到的中间或最终变量则可称之为结果节点。例如下面例子中的
pytorch深度学习实战lesson16
weixin_48304306的博客
11-16 1116
从代码实战的角度看深度学习的基础操作，包括模型构造参数管理，自定义层和读写文件。
手把手教你使用PyTorch搭建神经网络
weixin_39915649的博客
07-14 4334
使用PyTorch搭建基本神经网络的分步指南。
深度学习PyTorch笔记（9）：自动求导
niexinyu0026的博客
11-14 1694
深度学习PyTorch笔记（9）：自动求导4. 自动求导4.1 理解4.2 梯度4.3 .requires_grad与.grad_fn4.4 调用.backward()反向传播来完成所有梯度计算 这是《动手学深度学习》（PyTorch版）（Dive-into-DL-PyTorch）的学习笔记，里面有一些代码是我自己拓展的。 其他笔记在专栏 深度学习 中。 4. 自动求导 4.1 理解 逼近法就是积分（integral calculus）的起源。 在微分学最重要的应用是优化问题，即考虑如何把事情做到最好。
pytorch学习笔记九：权值初始化
Dear_learner的博客
02-21 2234
一、概念 权值初始化是指在网络模型训练之前，对各节点的权值和偏置初始化的过程，正确的初始化会加快模型的收敛，从而加快模型的训练速度，而不恰当的初始化可能会导致梯度消失或梯度爆炸，最终导致模型无法训练。 如上图所示的一个基本的CNN网络结构，数据在网络结构中流动时，会有如下的公式（默认没有偏置）： 在反向传播的过程中，由于是复合函数的求导，根据链式求导法则，会有两组导数，一个是损失函数Cost对Z的导数，一个是损失函数对W的导数， 1、损失函数关于状态Z的梯度： 2、损失函数关于W的梯度： 可以看出，
神经网络中的权重和偏置初始化
最新发布
weixin_43845922的博客
09-17 843
【代码】神经网络中的权重和偏置初始化。
基于pytorch各种神经网络基础模型复现.zip
05-19
基于pytorch各种神经网络基础模型复现.zip
pytorch-卷积神经网络基础
01-06
卷积神经网络基础 本节我们介绍卷积神经网络的基础概念，主要是卷积层和池化层，并解释填充、步幅、输入通道和输出通道的含义。 二维卷积层 本节介绍的是最常见的二维卷积层，常用于处理图像数据。 二维互相关运算 ...
【全网首发】Pytorch深度学习与图神经网络卷1：基础知识
01-15
Pytorch深度学习与图神经网络卷1：基础知识的ppt与code下载
pytorch基础教学简单实例
01-10
这个代码主要是针对刚入门pytorch的小伙伴，会带大家完整走一遍使用神经网络训练的流程，以及介绍一些pytorch常用的函数。
PyTorch深度学习实战（3）——使用PyTorch构建神经网络
热门推荐
盼小辉丶的博客
06-13 4万+
PyTorch 是一个用于构建深度神经网络的库，具有灵活性和可扩展性，可以轻松自定义模型。在本节中，我们将使用 PyTorch 库构建神经网络，利用张量对象操作和梯度值计算更新网络权重，并利用 Sequential 类简化网络构建过程，最后还介绍了如何使用 save、load 方法保存和加载模型，以节省模型训练时间。
【动手学深度学习】16.PyTorch 神经网络基础
qq_21506765的博客
10-04 763
为了实现这些复杂的网络，我们引入了神经网络块的概念。 块（block）可以描述单个层、由多个层组成的组件或整个模型本身。使用块进行抽象的一个好处是可以将一些块组合成更大的组件， 这一过程通常是递归的， 通过定义代码来按需生成任意复杂度的块， 我们可以通过简洁的代码实现复杂的神经网络。如下图所示： 我们首先关注具有单隐藏层的多层感知机 state_dict() 函数为一个参数字典如下所示 out:OrderedDict([(‘weight’, tensor([[ 0.0181, 0.0557, 0.02
Pytorch实现MLP(基于PyTorch实现)
CSDN 精品推荐
02-09 1万+
本专栏整理了《图神经网络代码实战》，内包含了不同图神经网络的相关代码实现（PyG以及自实现），理论与实践相结合，如GCN、GAT、GraphSAGE等经典图网络，每一个代码实例都附带有完整的代码。
深度学习之Pytorch（一）神经网络基础及代码实现
侧耳倾听
08-24 6509
1.1 Tensor (张量) Tensor 可以和 numpy 的 ndarray相互转换 Tensor有不同数据类型，有32位浮点型torch.FloatTensor、64位浮点型 torch.DoubleTensor等 1.2 Variable (变量) Variable 和 Tensor 本质上没有区别，不过 Variable 会被放入一个计算图中，然后进行前向传播，反向传播，自动求...
神经网络基础之模型构造
如月之恒，如日之升
04-15 1198
基础知识 层和块 为了实现这些复杂的网络，我们引入了神经网络块的概念。 块（block）可以描述单个层、由多个层组成的组件或整个模型本身。 使用块进行抽象的一个好处是可以将一些块组合成更大的组件， 继承Module类来构造模型 Module类是nn模块里提供的一个模型构造类，是所有神经网络模块的基类，我们可以继承它来定义我们想要的模型。下面继承Module类构造本节开头提到的多层感知机 Module的子类 Module类是一个通用的部件，我们可以继承Module 类来创建其他类比如：Se..
神经网络pytorch教程
09-13
在PyTorch的神经网络教程中，你将学习如何构建和训练神经网络。这些教程包含了从构建第一个简单的神经网络到构建一些最新的...这些教程将帮助你建立坚实的神经网络基础，并指导你在PyTorch中构建自己的神经网络模型。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值