神经网络的基本框架的搭建-nn.Module

已于 2023-10-03 20:41:14 修改
阅读量3.6k 收藏 56
点赞数 16
分类专栏： pytorch_learn 文章标签： 神经网络 pytorch
于 2023-09-29 09:55:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_55414382/article/details/133377213
版权

一、Torch.NN简介

torch.nn 是 PyTorch 中用于构建神经网络的模块。它提供了一组类和函数，用于定义、训练和评估神经网络模型。

torch.nn 模块的核心是 nn.Module 类，它是所有神经网络模型的基类。在Containers中

通过继承 nn.Module 类，您可以创建自己的神经网络模型，并定义模型的结构和操作。

以下是 torch.nn 模块中常用的一些类和函数：

  • nn.Linear: 线性层，用于定义全连接层。
  • nn.Conv2d: 二维卷积层，用于处理图像数据。
  • nn.ReLU: ReLU 激活函数。
  • nn.Sigmoid: Sigmoid 激活函数。
  • nn.Dropout: Dropout 层，用于正则化和防止过拟合。
  • nn.CrossEntropyLoss: 交叉熵损失函数，通常用于多类别分类问题。
  • nn.MSELoss: 均方误差损失函数，通常用于回归问题。
  • nn.Sequential: 顺序容器，用于按顺序组合多个层。

使用 torch.nn 模块，您可以创建自定义的神经网络模型，并使用 PyTorch 提供的优化器（如 torch.optim）和损失函数来训练和优化模型。

Module

二、简单示例

import torch.nn as nn

class DQLD(nn.Module):
    def __init__(self):
        super().__init__()

    def forword(self,input):
        output = input + 1
        return output

dqld = DQLD()
output = dqld.forword(1.0)
print(output)

继承nn.Module类，重写init并调用父类init，重写forward前向传播方法，本示例中只进行了加1操作，当然可以进行卷积等操作，再进行输出。

三、卷积介绍-conv2d

3.1conv2d二维卷积

                

3.2示例

代码：

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

input = torch.Tensor([[1,2,0,3,1],
                      [0,1,2,3,1],
                      [1,2,1,0,0],
                      [5,2,3,1,1],
                      [2,1,0,1,1]])
kernel = torch.Tensor([[1,2,1],
                       [0,1,0],
                       [2,1,0]])
print(input.shape)
print(kernel.shape)

input = torch.reshape(input,[1,1,5,5])
kernel = torch.reshape(kernel,[1,1,3,3])

print(input.shape)
print(kernel.shape)

output = F.conv2d(input,kernel,stride=1)
print(output)

output = F.conv2d(input,kernel,stride=2)
print(output)
#padding参数表示在输入矩阵的一周扩充几个维度再进行运算，一般扩充填充值为0
output = F.conv2d(input,kernel,padding=1,stride=2)
print(output)

 结果：

四、卷积层

4.1简介

卷积层是卷积神经网络（CNN）中的核心组件之一，它在图像处理和其他领域的深度学习任务中发挥着重要作用。卷积层通过卷积操作对输入数据进行特征提取和特征映射，具有以下几个主要作用：

  1. 特征提取：卷积层通过卷积操作从输入数据中提取有用的特征。卷积操作通过滑动窗口的方式在输入数据上进行局部采样，并使用卷积核（也称为滤波器）与采样到的数据进行卷积运算。这样可以检测出输入数据中的边缘、纹理、形状等低级特征。

  2. 特征映射：卷积层通过应用多个卷积核并对它们的输出进行叠加，生成多个特征映射（feature map）。每个特征映射对应一个卷积核，它可以捕捉输入数据中不同方面的特征。通过多个卷积核的组合，卷积层可以提取更加丰富和抽象的特征。

  3. 参数共享：卷积层通过参数共享的机制减少了需要学习的参数数量。在卷积操作中，卷积核的权重在整个输入数据上共享，这意味着在不同位置采样到的数据使用相同的权重进行卷积运算。参数共享有效地减少了模型的复杂性，提高了模型的泛化能力。

  4. 空间不变性：卷积层在进行卷积操作时保持输入数据的空间结构。这意味着无论输入数据中的特征出现在图像的哪个位置，卷积层都能够检测到它们。这种空间不变性使得卷积层在处理图像等具有平移不变性的数据时非常有效。

4.2官方文档

4.3示例

代码：DQLD卷积层

import torch
import torch.nn as nn
import torchvision
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

test_set = torchvision.datasets.CIFAR10("../dataset",train=False,transform=torchvision.transforms.ToTensor(),download=True)
dataloader = DataLoader(test_set,batch_size=16,shuffle=True,num_workers=0)

writer = SummaryWriter("../DQLD_logs")
class DQLQ(nn.Module):
    def __init__(self):
        super(DQLQ,self).__init__()
        self.conv1 = nn.Conv2d(in_channels=3,out_channels=6,kernel_size=3,stride=1,padding=1)

    def forward(self,x):
        x = self.conv1(x)
        return x

dqlq = DQLQ()
step = 0
for data in dataloader:
    imgs,targets = data

    # print(imgs.shape)->torch.Size([16, 3, 32, 32])
    writer.add_images("befor Convlution",imgs,step)

    imgs = dqlq(imgs)
    # print(imgs.shape)->torch.Size([16, 6, 32, 32])
    # print(imgs.shape)
    #reshape()第一个参数为-1则batch_size则根据后面的参数进行计算得出
    imgs = torch.reshape(imgs,(-1,3,32,32))
    # print(imgs.shape)->torch.Size([32, 3, 32, 32])

    writer.add_images("after Convlution",imgs,step)
    step = step + 1

结果：

五、池化层

5.1简介

池化层（Pooling Layer）是卷积神经网络（CNN）中常用的一种层类型，用于减小特征图的空间尺寸并提取关键特征。池化层通常紧跟在卷积层之后，其主要作用包括以下几个方面：

  1. 降采样：池化层通过对输入特征图进行降采样，减小特征图的空间尺寸。这有助于减少模型的参数数量和计算量，同时可以提高模型的计算效率。

  2. 特征选择：池化层通过对输入特征图进行汇聚操作，选取最显著的特征。常用的汇聚操作包括最大池化（Max Pooling）和平均池化（Average Pooling）。最大池化选取池化窗口中的最大值作为输出，而平均池化则计算池化窗口中值的平均值作为输出。这样可以保留重要的特征并减少冗余信息。

  3. 平移不变性：池化层具有一定的平移不变性，即无论特征出现在输入特征图的哪个位置，池化层都能够检测到它们。这种平移不变性使得模型对目标在图像中的具体位置不敏感，提高了模型的鲁棒性。

  4. 尺度不变性：池化层可以使模型对输入数据的尺度变化具有一定的不变性。通过对输入特征图进行降采样，池化层可以在一定程度上对输入数据的尺度变化进行适应。

需要注意的是，池化层没有可训练的参数，它主要通过设置池化窗口的大小和步幅来控制降采样的程度和特征选择的效果。

总结起来，池化层在卷积神经网络中用于降采样、特征选择和提高模型的平移不变性和尺度不变性。它通过对输入特征图进行汇聚操作来减小特征图的空间尺寸，并选取重要的特征。池化层没有可训练的参数，它的操作主要由池化窗口的大小和步幅决定。

说白了保留特征并且减少数据量

5.2官方文档

5.3示例

5.3.1一维数据示例

代码：

import torch
import torchvision
from torch import nn
from torch.nn import MaxPool2d

input = torch.tensor([[[1,2,0,3,1],
                      [0,1,2,3,1],
                      [1,2,1,0,0],
                      [5,2,3,1,1],
                      [2,1,0,1,1]]],dtype=torch.float)

torch.reshape(input,(-1,1,5,5))

print(input.shape)

class DQLD(nn.Module):
    def __init__(self):
        super(DQLD,self).__init__()
        self.maxpool1 = MaxPool2d(kernel_size=3,ceil_mode=True)

    def forward(self,input):
        output = self.maxpool1(input)
        return output

dqld = DQLD()
output = dqld(input)
print(output)

结果：ceil_mode = True                       ceil_mode = False

5.2.2图片示例

CIFAR10数据集为例

代码：

import torch
import torchvision
from torch import nn
from torch.nn import MaxPool2d
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

test_set = torchvision.datasets.CIFAR10("../dataset",train=False,transform=torchvision.transforms.ToTensor(),download=True)
dataloader = DataLoader(test_set,64,shuffle=True)

writer = SummaryWriter("../MaxPool_logs")
class DQLD(nn.Module):
    def __init__(self):
        super(DQLD,self).__init__()
        self.maxpool1 = MaxPool2d(kernel_size=3,ceil_mode=True)

    def forward(self,input):
        output = self.maxpool1(input)
        return output


dqld = DQLD()
step = 0
for data in dataloader:
    imgs,targets = data
    writer.add_images("Before MaxPool",imgs,step)
    output = dqld(imgs)
    writer.add_images("After MaxPool",output,step)
    step = step + 1

 结果：

六、非线性激活

6.1简介

非线性激活函数是神经网络中常用的一种组件，用于引入非线性变换，增加模型的表达能力。在神经网络的每个神经元中，非线性激活函数将神经元的输入进行非线性变换，产生神经元的输出。

常见的非线性激活函数包括：

  1. Sigmoid函数（Logistic函数）：Sigmoid函数将输入值映射到0到1之间的连续范围。它的公式为 f(x) = 1 / (1 + exp(-x))。Sigmoid函数在早期的神经网络中广泛使用，但在一些情况下可能存在梯度消失的问题。

  2. 双曲正切函数（Tanh函数）：Tanh函数将输入值映射到-1到1之间的连续范围。它的公式为 f(x) = (exp(x) - exp(-x)) / (exp(x) + exp(-x))。Tanh函数与Sigmoid函数类似，但输出范围更广，可以更好地处理负数输入。

  3. ReLU函数（Rectified Linear Unit函数）：ReLU函数将负数输入映射为0，而正数输入保持不变。它的公式为 f(x) = max(0, x)。ReLU函数在实践中被广泛使用，因为它简单且有效，可以缓解梯度消失的问题。

  4. Leaky ReLU函数：Leaky ReLU函数是ReLU函数的变种，它在负数输入时引入一个小的斜率，以解决ReLU函数在负数区域的输出为0的问题。它的公式为 f(x) = max(0.01x, x)。

  5. ELU函数（Exponential Linear Unit函数）：ELU函数在负数输入时引入一个指数衰减的负值，以解决ReLU函数的一些问题。它的公式为 f(x) = x if x >= 0, alpha * (exp(x) - 1) if x < 0，其中alpha是一个小的正数。

这些非线性激活函数可以帮助神经网络学习复杂的非线性关系，并提高模型的表达能力。在实际应用中，选择适当的非线性激活函数通常取决于任务的性质和数据的特点。

6.2示例

6.2.1ReLu函数

6.2.2ReLu激活函数数据示例

代码：

import torch
from torch import nn
from torch.nn import ReLU
input = torch.tensor([[[1,-1],
                     [2,-3]]])
torch.reshape(input,(-1,1,2,2))
print(input.shape)

class DQLD(nn.Module):

    def __init__(self):
        super(DQLD,self).__init__()
        # 此处ReLu(implace= True/False)若为True则会将连同原数据一同更改，False则不会更改原数据
        self.relu1 = ReLU()

    def forward(self,input):

        output= self.relu1(input)
        return output

dqld = DQLD()
output = dqld(input)
print(output)

结果：

6.2.3图片示例-sigmoid函数

代码：

import torch
import torchvision
from torch import nn
from torch.nn import ReLU
from torch.nn import Sigmoid
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

test_set = torchvision.datasets.CIFAR10("../dataset",train=False,transform=torchvision.transforms.ToTensor(),download=True)
dataloader = DataLoader(test_set,64)
writer = SummaryWriter("../sigmoid_logs")

class DQLD(nn.Module):

    def __init__(self):
        super(DQLD,self).__init__()
        # 此处ReLu(implace= True/False)若为True则会将连同原数据一同更改，False则不会更改原数据
        self.relu1 = ReLU()
        self.sigmoid1 = Sigmoid()

    def forward(self,input):
        output= self.sigmoid1(input)
        return output
dqld = DQLD()
step = 0
for data in dataloader:
    imgs,targets = data
    writer.add_images("input",imgs,step)
    output = dqld(imgs)
    writer.add_images("output",output,step)
    step = step + 1

writer.close()

结果：引入非线性特征增加模型鲁棒性

七、线性层

7.1简介

在机器学习和深度学习中，线性层（Linear Layer）通常指的是全连接层（Fully Connected Layer），也称为密集层（Dense Layer）或仿射层（Affine Layer）。

线性层是神经网络中最常见的一种层类型之一，它将输入的每个特征与一组可学习的权重进行线性组合，并添加一个可学习的偏置项。线性层的输出是输入特征与权重的加权和，可以表示为：

output = input * weight^T + bias

其中，input是输入特征向量，weight是权重矩阵，bias是偏置向量，^T表示权重矩阵的转置。

线性层的作用是将输入特征映射到输出空间，通过学习适当的权重和偏置，使得网络能够学习输入特征之间的非线性关系。线性层通常紧跟在卷积层或池化层之后，用于将高维特征转换为更低维的表示，或将特征向量映射到特定的输出空间。

7.2示例

不是很理解其作用

代码：

import torchvision
import torch
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
from torch import nn
from torch.nn import Linear

test_set = torchvision.datasets.CIFAR10("../dataset",train=False,transform=torchvision.transforms.ToTensor(),download=True)
dataloader = DataLoader(test_set,batch_size=64,shuffle=False)

writer = SummaryWriter("../liear_logs")

class DQ(nn.Module):
    def __init__(self):
        super(DQ,self).__init__()
        self.linear1 = Linear(196608,200)
    def forward(self,input):
        output = self.linear1(input)
        return output

dq = DQ()
step = 0
for data in dataloader:
    imgs,targets = data
    print(imgs.shape)
    output = torch.flatten(imgs)
    print(output.shape)
    output = dq(output)
    print(output.shape)

结果：

 

八、损失函数与反向传播

8.1简介

损失函数（Loss Function）是在机器学习和深度学习中使用的一种函数，用于衡量模型预测结果与真实标签之间的差异或误差。损失函数的选择取决于任务的性质和模型的输出类型。

在监督学习任务中，常见的损失函数包括：

  1. 均方误差（Mean Squared Error，MSE）：用于回归问题，计算预测值与真实值之间的平方差的平均值。

  2. 交叉熵损失（Cross-Entropy Loss）：用于分类问题，衡量预测类别和真实类别之间的差异。包括二分类交叉熵和多分类交叉熵。

  3. 对数损失（Log Loss）：用于二分类问题，衡量预测概率与真实标签之间的差异。

  4. 感知损失（Perceptron Loss）：用于感知机模型，当预测结果与真实标签不一致时给出固定的惩罚。

  5. Hinge损失：用于支持向量机（SVM）模型，鼓励正确分类的边界足够远离决策边界。

此外，还有许多其他类型的损失函数，如平滑L1损失、Huber损失、Kullback-Leibler（KL）散度等，它们在特定的任务和模型中具有不同的应用。

选择合适的损失函数是模型训练的重要一环，它直接影响模型的学习能力和性能。在训练过程中，优化算法通过最小化损失函数来调整模型的参数，使预测结果与真实标签尽可能接近。

8.2示例

8.2.1均值损失函数

代码：

import torch
from torch.nn import L1Loss
from torch.nn import MSELoss
input = torch.tensor([2,3,4],dtype=torch.float32)
input = torch.reshape(input,(1,1,1,3))

output = torch.tensor([2,3,7],dtype=torch.float32)
output = torch.reshape(output,(1,1,1,3))
loss_mean = L1Loss()
#就是求均值（2-2 + 3-3 + 7-4）/ 3.0 = 1.
result_mean = loss_mean(input,output)
print(result_mean)

结果：

8.2.2均方误差（Mean Squared Error，MSE）

代码：

import torch
from torch.nn import L1Loss
from torch.nn import MSELoss
input = torch.tensor([2,3,4],dtype=torch.float32)
input = torch.reshape(input,(1,1,1,3))

output = torch.tensor([2,3,7],dtype=torch.float32)
output = torch.reshape(output,(1,1,1,3))

loss_mse = MSELoss()
#差值平方再取平均（（2-2）^2 + (3-3)^2 + (7-4）^2)/ 3.0 = 3.
result_mse = loss_mse(input,output)
print(result_mse)

结果：

8.2.3交叉熵损失函数（多用于分类）

？

示例采用的是第二个上图第二个计算公式无权重

代码：

import torch
from torch.nn import L1Loss
from torch.nn import MSELoss
from torch.nn import CrossEntropyLoss

x = torch.tensor([0.1,0.2,0.3])
y = torch.tensor([1])
x = torch.reshape(x,(1,3))
loss_cross = CrossEntropyLoss()
result_cross = loss_cross(x,y)
print(result_cross)

结果：

计算损失函数时将会为反向传播提供每个节点的梯度。

8.3示例-利用反向传播减小损失函数

代码：

import torch
import torch.nn as nn
import torchvision
from torch.nn import Conv2d
from torch.nn import MaxPool2d
from torch.nn import Linear
from torch.nn import Flatten
from torch.nn import Sequential
from torch.nn import CrossEntropyLoss
from torch.nn import Sequential
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

dataset = torchvision.datasets.CIFAR10("../dataset",train=False,transform=torchvision.transforms.ToTensor(),download=True)
dataloader = DataLoader(dataset,1)

class DQLD(nn.Module):
    def __init__(self):
        super(DQLD,self).__init__()
        self.module1 = Sequential(
            Conv2d(3,32,5,stride=1,padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, stride=1, padding=2),
            MaxPool2d(2),
            Conv2d(32, 64, 5, stride=1, padding=2),
            MaxPool2d(2),
            Flatten(),
            Linear(1024, 64),
            Linear(64, 10)
                            )

    def forward(self,input):
        output = self.module1(input)
        return output


dqld = DQLD()
# 优化器-SGD梯度下降算法
optimizer = torch.optim.SGD(dqld.parameters(),lr=0.01)
loss_cross = CrossEntropyLoss()
for i in range(20):
    result_running = 0.0
    for data in dataloader:
#重置梯度
        optimizer.zero_grad()
        imgs,targets = data
        output = dqld(imgs)
        result_loss_cross = loss_cross(output,targets)
#计算梯度
        result_loss_cross.backward()
#调节参数使得损失函数值减小
        optimizer.step()
        result_running = result_running + result_loss_cross
    print("第" + str(i) + "轮，损失总和:")
    print(result_running)

结果：

九、其他层

9.1Normalization Layer

归一化层（Normalization Layer）是深度学习中常用的一种层类型，用于对输入数据进行归一化处理。归一化的目的是将输入数据的分布调整为均值为0、方差为1（或其他目标值）的形式，以便更好地进行训练和优化。

归一化层可用于不同层之间或同一层内的特征归一化。常见的归一化层包括批量归一化层（Batch Normalization）、层归一化层（Layer Normalization）、实例归一化层（Instance Normalization）等。

这些归一化层的具体实现方式有所不同，但它们的共同目标是通过对输入数据进行归一化处理，提供更好的训练稳定性、加速收敛速度以及提高模型的泛化能力。

。。。。

DQ小恐龙
关注
  • 16
    点赞
  • 踩
  • 56
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
Unet_pytorch-master.zip
07-24
在实现U-Net时，可以利用PyTorch的`nn.Module`构建网络结构，`autograd`模块处理反向传播，以及`torch.optim`进行优化器配置。此外，PyTorch还支持分布式训练和多GPU并行计算，对于大规模数据集的处理十分高效。 3....
PyTorch上搭建简单神经网络实现回归和分类的示例
09-20
在PyTorch中构建神经网络可以分为几个关键步骤，这里我们将探讨如何使用PyTorch搭建简单的神经网络以实现回归和分类任务。 首先，我们需要了解PyTorch的基本组件。其中，`torch.Tensor`是核心数据结构，它类似于...
PyTorch `nn.Module` 详解：深度学习的构建秘籍
DeepViewInsight的博客
09-15 501
nn.Module创建自定义神经网络模型是使用PyTorch的关键步骤之一。return x在上述示例中，我们首先导入了PyTorch的必要模块，然后创建了一个名为SimpleNN的自定义神经网络类。该类继承自nn.Module，并在构造函数中定义了网络的层次结构。在forward方法中，我们定义了前向传播操作，将输入x传递给全连接层、激活函数和输出层。通过这种方式，我们可以轻松地构建不同结构的神经网络模型，然后将它们用于各种任务，如图像分类、回归、生成等。
PyTorch的nn.Module类的详细介绍
xw555666的博客
01-29 3230
在PyTorch中，nn.Module类是构建神经网络模型的基础类，所有自定义的层、模块或整个神经网络架构都需要继承自这个类。nn.Module类提供了一系列属性和方法用于管理网络的结构和训练过程中的计算。
深度学习（六）——神经网络的基本骨架：nn.Module的使用
最新发布
2401_85325519的博客
06-14 1184
**Module**：对于**所有**神经网络提供一个基本的骨架，一般定义一个神经网络用如下代码。其中，_Model_代表模型的名称，_nn.Module_就是继承了这个类的模板。然后我们先用`__init__`初始化，其中`super(Model,self).__init__()`指的是对父类进行初始化，后面的部分是根据自己构建的神经网络个性化定制的。之后我们使用`forword`函数对输入数据进行计算，也可以这么理解：对于一个神经网络，_首先输入数据-->使用forword函数计算数据-->输出数据
Pytorch —— nn.Module类(nn.sequential)
hxxjxw的博客
05-20 7380
nn.Module nn.Module类是所有网络结构层次的父类。 当你要实现一个自己的层的时候，必须要继承这个类。 而当我们使用一些现有的层，比如说线性层、卷积层的时候，它其实也是继承自nn.Module，只不过这个类因为使用的非常广泛 ，所以pytorch官方已经写好了 当我们自己实现类的话，必须继承自nn.Module，并且在init中完成初始化的步骤和forward中完成计算图的前向构建的过程 1、every layer is nn.Module 这些都是继承自nn.Mod..
Pytorch nn.Module模块详解
Vic_Hao的博客
05-10 4万+
torcn.nn是专门为神经网络设计的模块化接口. nn构建于autograd之上，可以用来定义和运行神经网络。 nn.Module是nn中十分重要的类，包含网络各层的定义及forward方法。 如何定义自己的网络： 需要继承nn.Module类，并实现forward方法。 一般把网络中具有可学习参数的层放在构造函数__init__()中。 不具有可学习参数的层（如ReLU）可放在构造函数中，也...
nn.Module介绍(一)
wulele2的博客
01-11 1万+
目录 文章目录目录前言一、构造一个极简网络二、使用步骤1.引入库2.读入数据总结 前言 一、构造一个极简网络 import torch import torch.nn as nn from collections.abc import Iterable, Iterator class Net(nn.Module): def __init__(self): super(Net, self).__init__() def forward(self,x):
nn.Module模块
qq_36296794的博客
06-30 2569
pytorch, 深度学习基础
PyTorch 源码解读之 nn.Module：核心网络模块接口详解
qq_39967751的博客
03-14 5451
PyTorch 源码解读系列更新啦~
深度学习（PyTorch）——nn.Module的使用
qq_42233059的博客
09-01 1894
深度学习（PyTorch）——nn.Module的使用
Residual-Networks.zip_-baijiahao_47W_python residual_python残差网络
07-13
总结来说，"Residual-Networks.zip"这个压缩包很可能包含了使用Python和PyTorch实现的残差神经网络代码，包括ResidualBlock的定义以及整个ResNet模型的搭建。通过学习和理解这个实现，开发者可以深入理解ResNets的...
基于Pytorch的气象预测神经网络搭建与模型训练源码.zip
10-27
在本项目中，我们主要探讨的是如何利用Python的深度学习框架PyTorch构建一个神经网络模型来进行气象预测。PyTorch因其灵活性和易用性，已成为数据科学家和研究人员进行深度学习任务的首选工具之一，特别是在复杂的...
B站@同济子豪兄 用pytorch搭建全连接神经网络分类Fashion-MNIST数据集
03-27
在本项目中，我们将深入探讨如何使用PyTorch框架构建一个全连接的神经网络来解决图像分类问题。PyTorch是Python中广泛使用的深度学习库，以其灵活性和易用性而受到开发者的喜爱。我们将专注于Fashion-MNIST数据集，...
pytorch教程之nn.Module类详解——使用Module类来自定义模型
热门推荐
MIss-Y的博客
05-30 13万+
前言：pytorch中对于一般的序列模型，直接使用torch.nn.Sequential类及可以实现，这点类似于keras，但是更多的时候面对复杂的模型，比如：多输入多输出、多分支模型、跨层连接模型、带有自定义层的模型等，就需要自己来定义一个模型了。本文将详细说明如何让使用Mudule类来自定义一个模型。 一、torch.nn.Module类概述 个人理解，pytorch不...
nn.Module模块概述
CandyLa*
04-16 1155
nn.Module模块概述nn.Modulereference: nn.Module 在定义自已的网络的时候，需要继承nn.Module类，并重新实现构造函数__init__()和forward这两个方法。在构造函数__init__()中使用super(Model, self).init()来调用父类的构造函数，forward方法是必须要重写的，它是实现模型的功能，实现各个层之间的连接关系的核心。 1.一般把网络中具有可学习参数的层（如全连接层、卷积层）放在构造函数__init__()中。 2.一般把不具
Pytorch nn.Module源码解析
just
12-26 828
官网介绍：https://pytorch.org/docs/stable/generated/torch.nn.Module.html；，任何类都应该继承这个nn.Module类并且实现__init__和forward两个方法(forward方法基类中不实现)；Modules本身可以嵌套；
[PyTorch][chapter 39][nn.Module]
4AM_明朝百晓生
06-12 1448
利用nn.Sequential()搭建好模型架构，模型前向传播时调用forward()方法，模型接收的输入首先被传入nn.Sequential()包含的第一个网络模块中。然后，第一个网络模块的输出传入第二个网络模块作为输入，按照顺序依次计算并传播，直到nn.Sequential()里的最后一个模块输出结果。假设类型为 torch.tensor 的张量 a 的形状如下所示：(2,4,3,5,6)，则 torch.flatten(a, 1, 3).shape 的结果为 (2, 60, 6)。
pytorch学习笔记二——nn.Module
墨夜之枫的博客
11-26 1732
《神经网络与深度学习》笔记一——机器学习基础
nn.modulelist
05-24
`nn.ModuleList`是PyTorch中的一个模块，它允许用户将多个子模块组合成一个更大的模块，并且可以像访问普通列表一样访问它们。`nn.ModuleList`通常用于在神经网络中管理子模块，例如在深度学习中的一些复杂模型中，我们需要使用多个子模块来构建整个网络，而`nn.ModuleList`就可以很方便地管理这些子模块。 当我们在`nn.Module`的子类中定义一个`nn.ModuleList`成员时，PyTorch会自动地将该成员注册为当前模块的子模块，因此我们可以通过`named_children()`或`named_modules()`方法来遍历整个模型。 关于`nn.ModuleList`，还需要注意以下几点： - `nn.ModuleList`本身并不是一个可调用对象，因此不能直接调用它。 - `nn.ModuleList`不会自动注册为模型的参数，因此不会在模型参数列表中显示。 - `nn.ModuleList`不会像普通列表一样自动扩展，因此我们需要手动添加新的子模块。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

DQ小恐龙

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值